def _bnf_rhs(stream: TokenStream, gram: Grammar) -> RHSItem:
choice = _bnf_seq(stream, gram)
# Special case: Only one alternative
if stream.peek().kind != TokenCat.DISJUNCT:
return choice
choices = gram.choice()
choices.append(choice)
while stream.peek().kind == TokenCat.DISJUNCT:
stream.take()
choice = _bnf_seq(stream, gram)
choices.append(choice)
return choices
def _bnf_seq(stream: TokenStream, gram: Grammar) -> RHSItem:
"""Sequence of rhs items"""
# Could be an empty list ...
if stream.peek().kind == TokenCat.TERMINATOR:
return gram.seq() # The empty sequence
first = _bnf_primary(stream, gram)
# Could be a single item
if stream.peek().kind not in FIRST_SYM:
return first
seq = gram.seq()
seq.append(first)
while stream.peek().kind in FIRST_SYM:
next_item = _bnf_primary(stream, gram)
seq.append(next_item)
return seq
def _block(stream: TokenStream, gram: Grammar):
"""
block ::= { production }
(Adds to dicts in grammar module)
"""
log.debug(f"Parsing block from token {stream.peek()}")
while stream.peek().kind == TokenCat.IDENT:
_statement(stream, gram)
return
def _bnf_primary(stream: TokenStream, gram: Grammar) -> RHSItem:
"""A symbol or group, possibly with kleene star"""
item = _bnf_symbol(stream, gram)
# log.debug(f"Primary: {item}")
if stream.peek().kind == TokenCat.KLEENE:
token = stream.take()
return gram.kleene(item)
else:
return item
def require(stream: TokenStream,
category: TokenCat,
desc: str = "",
consume=False):
"""Requires the next token in the stream to match a specified category.
Consumes and discards it if consume==True.
"""
if stream.peek().kind != category:
msg = f"Expecting {desc or category}, but saw " +\
f"{stream.peek()} instead in line {stream.line_num}"
raise InputError(msg)
if consume:
stream.take()
return
def _bnf_symbol(stream: TokenStream, gram: Grammar) -> RHSItem:
"""A single identifier or literal, or a parenthesized group"""
if stream.peek().kind == TokenCat.LPAREN:
stream.take()
subseq = _bnf_rhs(stream, gram)
require(stream, TokenCat.RPAREN, consume=True)
# log.debug(f"Subsequence group: {subseq}")
return subseq
token = stream.take()
if token.kind == TokenCat.STRING or token.kind == TokenCat.CHAR:
# log.debug("Forming literal")
return gram.literal(token.value[1:-1]) # Clips quotes
elif token.kind == TokenCat.IDENT:
# log.debug("Forming symbol")
return gram.symbol(token.value)
else:
raise InputError(f"Unexpected input token {token.value}")