def B(self):
if self.LA.good_end:
if self.IT():
return True
else:
raise SyntaxError(
"Expected an element from {v} but found: {f}".format(
v=str(selection_set["B"]), f=self.lex))
else:
raise SyntaxError(
"Missing {end} at the end of boolean expression".format(
end=TOKEN.END.value))
def create_tree(self, tuples):
self.__tuples = tuples
tree, result = self.__check(':s', 0)
if tree is None or tree.length() != len(tuples):
message = f'syntax error on line {self.__last_correct_tuple[0][1]}:{self.__last_correct_tuple[0][0]}'
raise SyntaxError(message)
return tree
def __init__(self, inpt):
if inpt == '':
raise SyntaxError(inpt, "Empty input")
self.inpt = self.build_token_list(
inpt.split()) #[t for t in inpt.strip().split(DELIMITER)])
print("Parsed input: {}".format(self.inpt))
self.good_end = True if self.inpt[len(self.inpt) -
1] == TOKEN.END.value else False
self.lex = ''
self.current_position = -1
def L(self):
if self.A():
return True
else:
if self.lex == TOKEN.NOT.value:
try:
self.lex = self.LA.get()
except:
return False
if self.L():
return True
else:
return False
else:
raise SyntaxError(
"expecting an element from {e} but found: {f}".format(
e=str(selection_set['L']), f=self.lex))
def IT_TAIL(self):
if self.lex == TOKEN.IMP.value:
try:
self.lex = self.LA.get()
except:
return False
if self.OT():
if self.IT_TAIL():
return True
else:
return False
else:
return False
else:
if self.lex in list(selection_set['IT_TAIL'][1]):
return True
else:
raise SyntaxError(
"expecting an element of {ex} but found: {f}".format(
ex=str(selection_set['IT_TAIL']), f=self.lex))
def OT_TAIL(self):
if self.lex == TOKEN.OR.value:
try:
self.lex = self.LA.get()
except:
return False
if self.AT():
if self.AT_TAIL():
return True
else:
return False
else:
return False
else:
if self.lex in selection_set['OT_TAIL'][1]:
return True
else:
raise SyntaxError(
"expecting a {expected} but found : {found}".format(
expected=str(selection_set['OT_TAIL']),
found=self.lex))
def parse_children(self,
tokens_list,
sym_table,
end_type=None,
expect_next=None):
next_token = tokens_list.lookahead()
while not isinstance(next_token, end_type):
if isinstance(next_token, EOFToken):
raise ParseError(f"EOF Reached for {self.__class__.__name__}")
if expect_next and next_token.__class__ not in expect_next:
raise SyntaxError(
f"{self.__class__.__name__} expects one of: {expect_next}. {self.row}:{self.col}"
)
child_tree = next_token.parse_tree(tokens_list, sym_table)
if child_tree:
yield child_tree
next_token = tokens_list.lookahead()
def pop(self):
if self.feed:
return self.feed.pop(0)
raise SyntaxError("EOF Reached")
def error(self, error_code, token):
raise SyntaxError(
error_code=error_code,
token=token,
message=f'{error_code.value} -> {token}',
)
def check_symbol(self, symbol):
if symbol.value not in self.symbols:
raise SyntaxError(f"Symbol not defined: {symbol}")
def become_identifier(self):
if isinstance(self, LiteralToken):
self.__class__ = IdentifierToken
else:
raise SyntaxError(
f"Expected a literal for {self.__class__.__name__}")