Can nested parentheticals be parsed in chemical fo

Question

I am trying to create a parser for simple chemical formulae. Meaning, they have no states of matter, charge, or anything like that. The formulae only have strings representing compounds, quantities, and parentheses.

Following this answer to a similar question, and some rudimentary knowledge of discrete math, I hoped that I could write a simple Recursive Descent Parser to generate the number of each atom inside of the formula. I already have a really simple answer for this that involves single parentheses, but not nested parentheses.

Here are the productions of the grammar without parentheses:

Compound:  Component { Component };
Component: Atom [Quantity] 
Atom: 'H' | 'He' | 'Li' | 'Be' ...
Quantity: Digit { Digit }
Digit: '0' | '1' | ... '9'

• [...] is read as optional, and will be an if test in the program (either it is there or missing)
• | is alternatives, and so is an if .. else if .. else or switch 'test', it is saying the input must match one of these
• { ... } is read as repetition of 0 or more, and will be a while loop in the program
• Characters between quotes are literal characters which will be in the string. All the other words are names of rules, and for a recursive descent parser, end up being the names of the functions which get called to chop up, and handle the input.

With nested parentheses, I have no idea what to do. By nested parentheses I mean something like (Fe2(OH)2(H2O)8)2, or something fictitious and complicated like (Ab(CD2(Ef(G2H)3)(IJ2)4)3)2

Because now there is a production that I don't really understand how to articulate, but here is my best attempt:

Parenthetical:  Compound { Parenthetical } [Quantity]

Answer 1

So the basic rules parse any simple sequence of chemical symbols and quantities without parenthesis.

I assume the Quantity is defining the quantity of the whole chunk of stuff between '(' ... ')'

So, '(' ... ') [Quantity] needs to be parsed as exactly the same thing as the Component, i.e. as an alternative to: Atom [Quantity]

So the only thing to change is the Component rule; it becomes:

Component: Atom [Quantity] | '(' Compound ')' [Quantity]

In the code function (or procedure) which is parsing Component, it will have a look at the next character (token), and if it is an '(', it will consume it, then call the function (or procedure) responsible for parsing Compound, and after that, check the next character (token) is a ')' (if not, it's a syntax error), then handle the optional Quantity, and then it is finished.

I am assuming you are using a programming language which supports recursive function (or procedure) calls. That housekeeping, done by code behind the scenes for your program, will make this 'just work' (TM).

Alternatively, you could solve the problem in a different way. Add a new rule, which says:

Stuff: Atom | '(' Compound ')'

Then modify the rule:

Compound: Stuff [Quantity]

Then write a new function (or procedure) for Stuff, and change the Compound code to simply call Stuff, then handle the optional Quantity.

There are good technical reasons for doing this to support some parsing technology. However you're using recursive descent where it won't really matter.

Edit:
The type of grammar which works very well for a recursive decent parser is called LL(1), which means parse from left-to-right, and create the left-most derivation. That is a 'natural' way to parse when the code and function calls is the control flow. To find the theory of how to check grammars are LL(1) search the web for "parsing LL(1)" or "grammar follow sets".