def parse_param_expr(self):
token = self.token_current()
e1 = self.parse_expr()
p1 = ast.Parameter(e1, None)
token = self.token_current()
while token.type == scanner.TK_COMMA:
self.token_accept_any()
e2 = self.parse_expr()
p2 = ast.Parameter(e2, None)
p1 = ast.SequentialParameter(p1, p2)
token = self.token_current()
return p1
def parse_toplevel_declaration(self, annots):
self.expect_word('def')
subject = None
is_prefix = False
name = None
allow_extra = False
if self.at_type(Token.IDENTIFIER):
# def <ident>
ident = self.current().value
name = self.expect_type(Token.IDENTIFIER)
if self.at_punctuation(':='):
# def <ident> :=
self.expect_punctuation(':=')
value = self.parse_expression(True)
return ast.NamespaceDeclaration(annots, name, value)
else:
if self.at_punctuation('('):
# def <ident> (
subject = ast.Parameter(name, [data._SUBJECT], ast.Guard.eq(ast.Variable(name.shift_back())))
is_async = ast.Parameter(None, [data._TRANSPORT], ast.Guard.eq(ast.Literal(data._SYNC)))
(params, operation, allow_extra, reified) = self.parse_parameters(Parser._SAUSAGES)
body = self.parse_method_tail(True)
selector = self.name_as_selector(operation)
signature = ast.Signature([subject, selector, is_async] + params, allow_extra, reified)
return ast.FunctionDeclaration(name, ast.Method(signature, body))
else:
# def <ident> ...
subject = ast.Parameter(name, [data._SUBJECT], ast.Guard.any())
elif self.at_word('type'):
# def type <atomic> is <atomic>
self.expect_word('type')
subtype = self.parse_atomic_expression()
self.expect_word('is')
supertype = self.parse_atomic_expression()
self.expect_statement_delimiter(True)
return ast.IsDeclaration(subtype, supertype)
elif self.at_type(Token.OPERATION):
# def <operation> ...
(name, is_async) = self.expect_type(Token.OPERATION)
subject = self.parse_subject()
is_prefix = True
else:
# def (<parameter>)
subject = self.parse_subject()
signature = self.parse_functino_signature([subject], is_prefix, name)
body = self.parse_method_tail(True)
stage = self.get_subject_stage(subject)
return ast.MethodDeclaration(stage + 1, annots, ast.Method(signature, body))
def parse_functino_signature(self, subject, is_prefix, default_name=None):
name = default_name
is_async = False
if self.at_punctuation("->"):
is_async = True
self.expect_punctuation("->")
if (not is_prefix) and self.at_type(Token.OPERATION):
(name, is_async) = self.expect_type(Token.OPERATION)
if name:
default_operation = data.Operation.infix(name)
else:
default_operation = Parser._SAUSAGES
(params, param_operation, allow_extra, reified) = self.parse_parameters(default_operation)
if is_prefix:
op = data.Operation.prefix(name)
params = []
elif params is None:
params = []
if name is None:
op = Parser._SAUSAGES
else:
op = data.Operation.infix(name)
else:
op = param_operation
is_async_param = ast.Parameter(None, [data._TRANSPORT], ast.Guard.eq(ast.Literal(data._ASYNC if is_async else data._SYNC)))
if self.at_punctuation(':='):
self.expect_punctuation(':=')
(assign_params, assign_op, allow_extra, reified) = self.parse_parameters(None, start_index=len(params))
params += assign_params
op = data.Operation.assign(op)
if allow_extra and (op.type == data.Operation._CALL):
selector = self.any_selector()
else:
selector = self.name_as_selector(op)
return ast.Signature(subject + [selector, is_async_param] + params, allow_extra, reified)
def parse_move(self):
self.indentator.indent('Parsing move')
self.expect('MOVE')
coords = self.parse_coord()
param = ast.Parameter("position", coords)
self.indentator.dedent()
return ast.moveOperation(param)
def parse_position(self):
self.indentator.indent('Parsing Position')
self.expect('POSITION')
self.expect('COLON')
value = self.parse_coord()
param = ast.Parameter("position", value)
self.indentator.dedent()
return param
def parse_signature(self):
prefix = [
self.name_as_subject(data.Identifier(0, data.Path(['self']))),
self.name_as_selector(Parser._SAUSAGES),
ast.Parameter(None, [data._TRANSPORT], ast.Guard.eq(ast.Literal(data._SYNC)))
]
(params, operation, allow_extra, reified) = self.parse_parameters(None)
if params is None:
params = []
return ast.Signature(prefix + params, allow_extra, reified)
def parse_vitesse(self):
self.indentator.indent('Parsing Vitesse')
self.expect('VITESSE')
self.expect('COLON')
value = self.show_next().value
self.expect('INT')
param = ast.Parameter("vitesse", value)
self.indentator.dedent()
return param
def parse_uv(self):
self.indentator.indent('Parsing Uv')
self.expect('UV')
self.expect('COLON')
value = self.show_next().value
self.expect('INT')
param = ast.Parameter("uv", value)
self.indentator.dedent()
return param
def parse_duree(self):
self.indentator.indent('Parsing Duree')
self.expect('DUREE')
self.expect('COLON')
value = self.show_next().value
self.expect('INT')
param = ast.Parameter("duree", value)
self.indentator.dedent()
return param
def parse_direction(self):
self.indentator.indent('Parsing Direction')
self.expect('DIRECTION')
self.expect('COLON')
if self.show_next().kind in self.DIR:
value = self.show_next().value
self.accept_it()
param = ast.Parameter("direction", value)
self.indentator.dedent()
return param
def parse_intensite(self):
self.indentator.indent('Parsing Intensite')
self.expect('INTENSITE')
self.expect('COLON')
if self.show_next().kind in self.TYPE_INTENS:
value = self.show_next().value
self.accept_it()
param = ast.Parameter("intensite", value)
self.indentator.dedent()
return param
def parse_type_rainfall(self):
self.indentator.indent('Parsing Type_rainfall')
self.expect('TYPE_RAIN')
self.expect('COLON')
if self.show_next().kind in self.TYPE_RAINFALL:
value = self.show_next().value
self.accept_it()
param = ast.Parameter("typeRain", value)
self.indentator.dedent()
return param
def parse_type_cloud(self):
self.indentator.indent('Parsing Type_could')
self.expect('TYPE_CLOUD')
self.expect('COLON')
if self.show_next().kind in self.TYPE_CLOUD:
value = self.show_next().value
self.accept_it()
param = ast.Parameter("typeCloud", value)
self.indentator.dedent()
return param
def parameter(self):
lead = self.leadComments()
l = self._peek().location
ats = self.attribs()
var = None
if self._peekTag() is VAR:
var = self._next().text
pat = self.simplePattern()
p = ast.Parameter(ats, var, pat, None, self._location(l))
self._liftComments(p, None, pat)
p.comments.before = lead + p.comments.before
return p
def parse_param(self):
tk_argident = self.token_current().val
self.token_accept(scanner.TK_IDENTIFIER)
self.token_accept(scanner.TK_COLON)
arg_type = self.parse_typedenoter()
p1 = ast.Parameter(tk_argident, arg_type)
token = self.token_current()
while token.type == scanner.TK_COMMA:
self.token_accept_any()
tk_argident = self.token_current().val
self.token_accept(scanner.TK_IDENTIFIER)
self.token_accept(scanner.TK_COLON)
arg_type = self.parse_typedenoter()
p2 = ast.Parameter(tk_argident, arg_type)
p1 = ast.SequentialParameter(p1, p2)
token = self.token_current()
return p1
def parse_pattern_call(self, end):
pattern = []
while not self.cur_is(end):
tok = self.cur_tok
if not self.expect_cur_any([token.ID, token.PARAM] +
list(token.keywords.values())):
return None
if tok.type == token.ID or tok.type in token.keywords.values():
pattern.append(ast.Identifier(tok))
else:
pattern.append(ast.Parameter(tok, tok.literal))
return pattern
def parse_parameter(self, default_tag):
tags = [default_tag]
if self.at_type(Token.TAG):
tag = self.expect_type(Token.TAG)
if type(tag) == int:
# TODO: This is kind of a hack but how to handle integer tags that
# overlap with the default tags? Ban them maybe?
tags = [tag]
else:
tags = [tag, default_tag]
elif self.at_operation('*'):
self.expect_operation('*')
return None
else:
tags = [default_tag]
name = self.expect_type(Token.IDENTIFIER)
guard = self.parse_guard(default_tag)
result = ast.Parameter(name, tags, guard)
return result
def parse_def_stmt(self):
stmt = ast.FunctionDefinition(self.cur_tok, [], None)
self.next()
while not self.cur_is(token.LBRACE):
tok = self.cur_tok
if not self.expect_cur_any([token.ID, token.PARAM] +
list(token.keywords.values())):
return None
if tok.type == token.ID or tok.type in token.keywords.values():
stmt.pattern.append(ast.Identifier(tok))
else:
stmt.pattern.append(ast.Parameter(tok, tok.literal))
stmt.body = self.parse_block_statement()
if len(stmt.pattern) == 0:
self.err("expected at least one item in a pattern")
return None
return stmt
def name_as_selector(self, name): assert isinstance(name, data.Operation) return ast.Parameter(None, [data._SELECTOR], ast.Guard.eq(ast.Literal(name)))
def any_selector(self): return ast.Parameter(None, [data._SELECTOR], ast.Guard.any())
def name_as_subject(self, name): return ast.Parameter(name, [data._SUBJECT], ast.Guard.any())