def p_assignment_expression(self, p):
"""assignment_expression : expr
| unary_expression assignment_operator assignment_expression
"""
p[0] = (
p[1] if len(p) == 2 else ast.Assignment(p[2], p[1], p[3], coord=p[1].coord)
)
def assignment(self, level):
"""
Assignment -> Identifier '=' Expression ';'
:param level: indicates level of assignment; type(level) - int
:return: An ast.Assignment object
:raise CliteSyntaxError if an unexpected token is seen
"""
# Save and consume identifier
identifier = self.curr_tok
self.curr_tok = self.lex.__next__()
# Match equal sign
if self.curr_tok[self.CODE] != tokens.SINGLE_TOKENS[tokens.ASSIGN][0]:
raise errors.CliteSyntaxError("An assignment statement expected!",
self.curr_tok[self.LINE])
# Consume equal sign
self.curr_tok = self.lex.__next__()
expr = self.expression()
# Match semicolon
if self.curr_tok[self.CODE] != tokens.SINGLE_TOKENS[tokens.SEMICOLON][0]:
raise errors.CliteSyntaxError("Semicolon expected!",
self.curr_tok[self.LINE])
# Consume semicolon
self.curr_tok = self.lex.__next__()
# Check if the identifier is declared
if identifier[2] not in self.decls:
raise errors.CliteSyntaxError("Identifier is not declared!",
self.curr_tok[self.LINE])
return ast.Assignment(identifier[2], expr, level)
def p_assignment(p):
'''statement : ID ASSIGN expr SEMICOL
| index ASSIGN expr SEMICOL'''
ref = p[1]
if isinstance(ref, str):
ref = ast.VarUse(ref).at(loc(p, 1))
p[0] = ast.Assignment(ref, p[3]).at(loc(p))
def p_assignment_expression(self, p):
""" assignment_expression : conditional_expression
| unary_expression assignment_operator assignment_expression
"""
if len(p) == 2:
p[0] = p[1]
else:
p[0] = ast.Assignment(p[2], p[1], p[3])
def p_assignment_expr(p):
'''
assignment_expr : conditional_expr
| conditional_expr EQUALS conditional_expr
'''
if DEBUG:
print("\nassignment expr: ", end="")
for i in range(len(p)):
print(i, " ", p[i], " ", end="")
# only w/ constant
if len(p) == 4:
p[0] = ast.Assignment(p[2], p[1], p[3])
else:
p[0] = p[1]
def assignment(self):
"""
Assignment ⇒ Identifier = Expression ;
"""
# Check for an identifier.
if self.currToken[0] == lexer.Lexer.ID:
# Check if the identifier has been declared.
if self.currToken[2] in self.parseTree.declarations.keys():
# Capture the identifier to create an Assignment object.
identify = self.currToken[2]
# Move to the next token.
self.currToken = next(self.tokens)
# Check for '='.
if self.currToken[0] == lexer.Lexer.ASSIGN:
# Move to the next token.
self.currToken = next(self.tokens)
# Check for an expression and capture it to create an Assignment object.
expr = self.expression()
# Check for ';'.
if self.currToken[0] == lexer.Lexer.SEMICOLON:
# Move to the next token.
self.currToken = next(self.tokens)
# Create an Assignemt object.
assign = ast.Assignment(identify, expr)
# Return the assignment object.
return assign
# Unexpected token encountered.
else:
raise CLiteSyntaxError(self.currToken, ';')
# Unexpected token encountered.
else:
raise CLiteSyntaxError(self.currToken, '=')
# Unexpected token encountered.
else:
raise CLiteSyntaxError(self.currToken, 'N/A',
'Undeclared variable encountered')
# Unexpected token encountered.
else:
raise CLiteSyntaxError(self.currToken, 'Identifier')
def parse_name_expr(source):
global loc
if (source[loc] == '='): # Whitespace already skipped
loc += 1
name = buff
return ast.Assignment(name, parse_expr(source))
elif not isname(source[loc]): # Variable
return ast.Lookup(buff)
else: # So it's a call
name = buff
q = tok(source)
assert q == 'name'
name2 = buff
# try:
return ast.Call(name, name2, [parse_expr(source)])
def parse_let(self):
tok = self.current
self.step()
if not isinstance(self.current, tokens.IDENT):
raise ParserError(
f"Expected identifer after `let` keyword, found {self.current}"
)
ident = self.parse_identifier()
if not isinstance(self.current, tokens.ASSIGN):
raise ParserError(
f"Expected `=` after identifier keyword, found {self.current}")
self.step()
expr = self.parse_expr()
return ast.Assignment(ident, expr)
def resolveName_FuncDef(self, func):
# self.logger.debug('resolveName_FuncDef', func.name, func, func.owner)
if isinstance(func.owner, ast.ExtensionDef):
func.cls = func.owner.cls
func.owner.cls.addSymbol(func)
owner = func.owner
if func.info.type == ast.FuncType.constructor:
# self.logger.debug('resolveName_FuncDef constructor returnType', func.name, func, func.owner)
assert func.spec.returnType is None
func.spec.returnType = ast.UserType([func.cls.name])
self.setupNewItem(func.spec.returnType, func.spec, False)
assert isinstance(owner, ast.ClassDef) or isinstance(owner, ast.CodeUnit) or isinstance(owner, ast.ExtensionDef), 'resolveName_FuncDef owner is invalid: %s %s' % (owner, func)
if func.info.type == ast.FuncType.constructor:
for var in func.owner.vars:
if var.initial:
stmt = ast.Assignment([ast.Identifier(var.name)], '=', [var.initial])
func.body.statements.insert(0, stmt)
# self.logger.debug('resolveName_FuncDef initialize var', func.name, stmt, var, var.initial)
self.setupNewItem(stmt, func.body, False)
func.visitChildren(self)
# == LVALUES ==
lvalue = MatchFirst([lvariable, mem_lvalue, special_loc, struct_access])
declarevar = (Keyword('var') + identifier +
Optional(Literal(':=').suppress() + expr, default=None)
).setParseAction(lambda t: ast.DeclareVar(t[1], t[2]))
declarefn = (Keyword('declare') + identifier + Optional(Keyword('returns').setParseAction(lambda t: True), default = False))\
.setParseAction(lambda t: ast.DeclareFunction(t[1], t[2]))
declare_struct = (Keyword('struct') + type_identifier + '{' + identifier_list +
'}').setParseAction(lambda t: ast.DeclareStruct(t[1], t[3]))
assignment = (lvalue + Literal(':=') +
expr).setParseAction(lambda t: ast.Assignment(t[0], t[2]))
return_ = (
Keyword('return') +
Optional(expr, default=None)).setParseAction(lambda t: ast.Return(t[1]))
halt = Keyword('halt').setParseAction(lambda t: ast.Halt())
expr_statement = expr.copy().setParseAction(lambda t: ast.ExprStatement(t[0]))
if_ = (Keyword('if') + '(' + expr + ')' + block_sequence + Optional(Keyword('else').suppress() + block_sequence, default=None))\
.setParseAction(lambda t: ast.If(t[2], t[4], t[5]))
while_ = (Keyword('while') + '(' + expr + ')' + block_sequence)\
.setParseAction(lambda t: ast.While(t[2], t[4]))
def p_assignment(p):
'''
assignment : ID ASSIGN expression
'''
p[0] = ast.Assignment(ast.Identifier(p[1]), p[3])
def p_expr_assign(p):
'''
expr : identifier equal_tok assignable
'''
p[0] = ast.Assignment(p[1], p[3])
def p_statement_assign(p):
'statement : NAME "=" expression'
names[p[1]] = p[3]
p[0] = ast.Assignment(p[1], p[3])
def p_assignment(self, p):
"""
assignment : variable assignment_operator expression
"""
p[0] = ast.Assignment(p[1], p[2], p[3], p.lexer.lexer.lineno)
def statement_assign(s):
return ast.Assignment(s[0].getstr(), s[2])
def p_expression_assignment(self, parse):
'''
expression : ID ASSIGN expression
'''
parse[0] = AST.Assignment(AST.Object(name=parse[1]),
expression=parse[3])
def p_expression_assignment(self, parse):
"""
expression : ID ASSIGN expression
"""
parse[0] = AST.Assignment(AST.Object(name=parse[1]), expr=parse[3])
def assign(p):
assert p[0].gettokentype() == "ID"
return ast.Assignment(ast.IdentifierReference(p[0].getstr()), p[2])
def parse(self, parser, tokens, left):
tokens.consume_expected('ASSIGN')
right = Expression().parse(parser, tokens)
tokens.consume_expected('NEWLINE')
return ast.Assignment(left, right)
