def funcBody(parser, name, names, types, header, returnType, do):
body = Tree.FuncBody(parser)
body.name = name
body.returnType = returnType
body.package = parser.package
body.do = do
parser.currentNode.addNode(body)
parser.currentNode = body
for i in range(len(names)):
n = Tree.InitArg(names[i], body)
n.package = parser.package
n.varType = types[i]
n.imutable = not Scope.isMutable(parser, parser.package, names[i])
body.addNode(n)
parser.nextToken()
Parser.callToken(parser) #incase next case is newline
while not Parser.isEnd(parser):
parser.nextToken()
t = parser.thisToken().token
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = body.owner
Scope.decrScope(parser)
def forExpr(parser):
toplevel = Tree.For(parser)
parser.currentNode.addNode(toplevel)
parser.currentNode = toplevel
while not (Parser.isEnd(parser) or parser.thisToken().token == "do"):
token = parser.nextToken()
if token.token == "do":
break
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.nodeBookmark.append(len(parser.currentNode.nodes))
if parser.thisToken().token != "do":
Error.parseError(parser, "Expecting do")
if len(toplevel.nodes) != 1: #or not type(toplevel.nodes[0]) is Tree.CreateAssign:
Error.parseError(parser, "Expecting single node")
count = 0
while not (Parser.isEnd(parser) and count > 0): #avoid breaking on do keyword
count += 1
token = parser.nextToken()
Parser.callToken(parser)
parser.nodeBookmark.pop()
parser.currentNode = toplevel.owner
def whileExpr(parser):
toplevel = Tree.While(parser)
parser.currentNode.addNode(toplevel)
parser.currentNode = toplevel
n = Tree.WhilePreCondition(parser)
cond = Tree.WhileCondition(parser)
parser.currentNode.addNode(n)
parser.currentNode.addNode(cond)
parser.currentNode = cond
while not Parser.isEnd(parser):
token = parser.nextToken()
iter = parser.iter
if token.token == "do":
ExprParser.endExpr(parser)
block = Tree.WhileBlock(parser)
cond.owner.addNode(block)
parser.currentNode = block
continue
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = n.owner.owner
def funcBody(parser, name, names, types, brace, returnType, do):
body = Tree.FuncBody(parser)
body.name = name
body.returnType = returnType
body.package = parser.package
body.do = do
brace.body = body
parser.currentNode.addNode(body)
parser.currentNode = body
for i in range(len(names)):
n = Tree.InitArg(names[i], body)
n.package = parser.package
n.varType = types[i]
n.imutable = not Scope.isMutable(parser, parser.package, names[i])
body.addNode(n)
parser.nextToken()
Parser.callToken(parser) #incase next case is newline
while not Parser.isEnd(parser):
parser.nextToken()
t = parser.thisToken().token
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = body.owner
Scope.decrScope(parser)
return body
def elseExpr(parser):
toplevel = Tree.Else(parser)
try:
inside = parser.currentNode.nodes[-1].nodes[-2]
except IndexError:
Error.parseError(parser, "unexpected else")
if not type(inside) is Tree.IfCondition:
Error.parseError(parser, "unexpected else")
parser.currentNode.nodes[-1].addNode(toplevel)
parser.currentNode = toplevel
block = Tree.Block(parser)
parser.currentNode.owner.addNode(block)
parser.currentNode = block
opening = None
single = 0
while not Parser.isEnd(parser):
token = parser.nextToken()
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = toplevel.owner.owner
def funcCallBody(parser, paren, onlyOneArg):
parser.nodeBookmark.append(1)
def notParen():
t = parser.thisToken()
if t.token in ["then", "with", "do", ":="]:
return False
return not Parser.isEnd(parser)
if paren:
notEnd = lambda: parser.paren > parser.parenBookmark[-1]
else:
notEnd = notParen
while not onlyOneArg and notEnd():
t = parser.nextToken()
if t.token == ",":
ExprParser.endExpr(parser)
parser.nodeBookmark[-1] = len(parser.currentNode.nodes)
continue
if t.token in ["then", "with", "do", ":="]:
break
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
def elseExpr(parser):
toplevel = Tree.Else(parser)
try:
inside = parser.currentNode.nodes[-1].nodes[-2]
except IndexError:
Error.parseError(parser, "unexpected else")
if not type(inside) is Tree.IfCondition:
Error.parseError(parser, "unexpected else")
parser.currentNode.nodes[-1].addNode(toplevel)
parser.currentNode = toplevel
block = Tree.Block(parser)
parser.currentNode.owner.addNode(block)
parser.currentNode = block
opening = None
single = 0
while not Parser.isEnd(parser):
token = parser.nextToken()
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = toplevel.owner.owner
def whileExpr(parser):
toplevel = Tree.While(parser)
parser.currentNode.addNode(toplevel)
parser.currentNode = toplevel
n = Tree.WhilePreCondition(parser)
cond = Tree.WhileCondition(parser)
parser.currentNode.addNode(n)
parser.currentNode.addNode(cond)
parser.currentNode = cond
while not Parser.isEnd(parser):
token = parser.nextToken()
iter = parser.iter
if token.token == "do" :
ExprParser.endExpr(parser)
block = Tree.WhileBlock(parser)
cond.owner.addNode(block)
parser.currentNode = block
continue
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = n.owner.owner
def arrayRead(parser):
numB = parser.bracket - 1
parser.nextToken()
Struct.popAt(parser)
parser.nodeBookmark.append(1)
try:
arr = parser.currentNode.nodes[-1]
except IndexError:
Error.parseError(parser, "unexpected array read")
del parser.currentNode.nodes[-1]
arrRead = Tree.ArrRead(parser)
arrRead.addNode(arr)
parser.currentNode.addNode(arrRead)
parser.currentNode = arrRead
while parser.thisToken().token != "]":
Parser.callToken(parser)
if parser.thisToken().token == "]" and parser.bracket <= numB:
break
parser.nextToken()
else:
closeBracket(parser)
ExprParser.endExpr(parser)
parser.currentNode = arrRead.owner
parser.nodeBookmark.pop()
def elseExpr(parser, canHaveElse=False):
toplevel = Tree.Else(parser)
ifexpr = False
if not canHaveElse:
try:
inside = parser.currentNode.nodes[-1].nodes[-2]
except IndexError:
Error.parseError(parser, "unexpected else")
if not type(inside) is Tree.IfCondition:
ifexpr = IfExpr.ifPatternMatch(parser)
if not ifexpr:
Error.parseError(parser, "unexpected else")
if not ifexpr:
parser.currentNode.nodes[-1].addNode(toplevel)
parser.currentNode = toplevel
block = Tree.Block(parser)
parser.currentNode.owner.addNode(block)
parser.currentNode = block
else:
parser.currentNode = parser.currentNode.nodes[-1].nodes[-1]
while len(parser.currentNode.nodes) > 0:
parser.currentNode = parser.currentNode.nodes[-1]
add_block = len(parser.currentNode.nodes) > 0
if add_block:
block = Tree.Block(parser)
parser.currentNode.nodes[-1].addNode(toplevel)
parser.currentNode.nodes[-1].addNode(block)
parser.currentNode = parser.currentNode.nodes[-1]
parser.currentNode = block
opening = None
single = 0
while not Parser.isEnd(parser):
token = parser.nextToken()
Parser.callToken(parser)
ExprParser.endExpr(parser)
if ifexpr:
parser.currentNode = ifexpr
else:
parser.currentNode = toplevel.owner.owner
def assignParser(parser, name="", init=False, package=""):
if not init:
ExprParser.endExpr(parser, -2)
i = parser.currentNode.nodes[-1]
if type(i) is Tree.Create:
createAndAssignParser(parser, False)
return
del parser.currentNode.nodes[-1]
if package == "": package = parser.package
if name == "":
node = Tree.Assign("", parser=parser)
node.addNode(i)
else:
node = Tree.Assign(name, parser=parser)
parser.nodeBookmark.append(0)
node.package = package
node.init = init
parser.currentNode.addNode(node)
parser.currentNode = node
curr = parser.thisToken()
while not Parser.isEnd(parser):
parser.nextToken()
if parser.thisToken().token == "do":
break
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = node.owner
parser.nodeBookmark.pop()
self = node
if self.init:
if len(node.nodes) > 1 or len(node.nodes) == 0:
self.error("expecting single expression, not " +
str(len(node.nodes)))
else:
if len(node.nodes) > 2 or len(node.nodes) == 1:
self.error("expecting single expression, not " +
str(len(node.nodes) - 1))
def initStruct(parser, package= ""):
if ExprParser.isUnary(parser, parser.lookBehind()):
Error.parseError(parser, "unexpected {")
if package == "": package = parser.package
if len(parser.currentNode.nodes) == 0:
Error.parseError(parser, "unexpected {")
if not type(parser.currentNode.nodes[-1]) in [Tree.ReadVar, Tree.Field]:
Error.parseError(parser, "unexpected {")
readVar = type(parser.currentNode.nodes[-1]) is Tree.ReadVar
name = parser.currentNode.nodes[-1].name if readVar else parser.currentNode.nodes[-1].field
init = Tree.InitStruct(parser)
if not readVar:
package = parser.currentNode.nodes[-1].nodes[0].name
t = (parser.currentNode.nodes[-1].nodes[0])
if not package in parser.imports:
t.error("no package called " + package)
elif not type(t) is Tree.ReadVar:
init.error("unexpected {")
init.package = package
del parser.currentNode.nodes[-1]
s = parser.structs[package][name]
init.paramNames = offsetsToList(parser.structs[package][name].offsets)
init.s = s
init.mutable = False
parser.currentNode.addNode(init)
parser.currentNode = init
parser.nextToken()
while parser.thisToken().token != "}":
if parser.thisToken().token == ",":
ExprParser.endExpr(parser)
else: Parser.callToken(parser)
parser.nextToken()
t = parser.thisToken().token
continue
ExprParser.endExpr(parser)
parser.currentNode = init.owner
def index(parser, unary=False):
if not unary:
unary = ExprParser.isUnary(parser, parser.lookBehind())
if not unary and len(parser.currentNode.nodes) == 0:
Error.parseError(parser, "unexpected .")
field = parser.nextToken()
if not field.type in ["identifier", "i32"]:
Error.parseError(parser, "field name must be an identifier")
acess = Tree.Field(0, Types.Null(), parser)
acess.unary = unary
acess.number = field.type == "i32"
field = field.token
acess.owner = parser.currentNode
acess.field = field
if not unary:
acess.addNode(parser.currentNode.nodes[-1])
parser.currentNode.nodes[-1] = acess
else:
parser.currentNode.addNode(acess)
def funcBody(parser, name, names, types, brace, returnType, do):
body = Tree.FuncBody(parser)
body.name = name
body.returnType = returnType
body.package = parser.package
body.do = do
body.types = types
brace.body = body
parser.currentNode.addNode(body)
parser.currentNode = body
if not parser.sc and not SimplifyAst.isGenericFunc(brace):
body.sc = False
if parser.nextToken().token == "\n":
Parser.callToken(parser)
while not Parser.isEnd(parser):
if parser.nextToken().token == "\n":
Parser.callToken(parser)
parser.currentNode = body.owner
Scope.decrScope(parser)
#print("should not compile", name)
return body
for i in range(len(names)):
n = Tree.InitArg(names[i], parser)
n.package = parser.package
n.varType = types[i]
n.imutable = not Scope.isMutable(parser, parser.package, names[i])
body.addNode(n)
parser.nextToken()
Parser.callToken(parser) #incase next case is newline
while not Parser.isEnd(parser):
parser.nextToken()
t = parser.thisToken().token
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = body.owner
Scope.decrScope(parser)
return body
def assignParser(parser, name="", init=False, package=""):
if not init:
i = parser.currentNode.nodes[-1]
del parser.currentNode.nodes[-1]
if package == "": package = parser.package
if name == "":
node = Tree.Assign("", parser=parser)
node.addNode(i)
else:
node = Tree.Assign(name, parser=parser)
parser.nodeBookmark.append(0)
node.package = package
node.init = init
parser.currentNode.addNode(node)
parser.currentNode = node
curr = parser.thisToken()
while not Parser.isEnd(parser):
parser.nextToken()
Parser.callToken(parser)
if name == "_random":
print()
ExprParser.endExpr(parser)
parser.currentNode = node.owner
parser.nodeBookmark.pop()
self = node
if self.init:
if len(node.nodes) > 1 or len(node.nodes) == 0:
self.error("expecting single expression, not " +
str(len(node.nodes)))
else:
if len(node.nodes) > 2 or len(node.nodes) == 1:
self.error("expecting single expression, not " +
str(len(node.nodes) - 1))
def ifBody(parser):
cond = Tree.IfCondition(parser)
parser.currentNode.addNode(cond)
parser.currentNode = cond
single = 0
parser.nodeBookmark.append(0)
then = False
while not (Parser.isEnd(parser) and then) :
token = parser.nextToken()
if token.token == "then" and not then:
then = True
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
block = Tree.Block(parser)
cond.owner.addNode(block)
parser.currentNode = block
continue
isEnd = Parser.maybeEnd(parser)
if (token.token in ["else", "elif"]) and isEnd:
break
token = parser.thisToken()
Parser.callToken(parser)
next = parser.lookInfront()
if (next.token == "else" or next.token == "elif") and isEnd:
break
ExprParser.endExpr(parser)
cond.type = Types.Bool()
parser.currentNode = cond.owner.owner
def ifBody(parser):
cond = Tree.IfCondition(parser)
parser.currentNode.addNode(cond)
parser.currentNode = cond
single = 0
parser.nodeBookmark.append(0)
then = False
while not (Parser.isEnd(parser) and then) :
token = parser.nextToken()
if token.token == "then" and not then:
then = True
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
block = Tree.Block(parser)
cond.owner.addNode(block)
parser.currentNode = block
continue
Parser.callToken(parser)
next = parser.lookInfront()
if (next.token == "else" or next.token == "elif") and Parser.maybeEnd(parser):
parser.iter -= 1
break
ExprParser.endExpr(parser)
cond.type = Types.Bool()
parser.currentNode = cond.owner.owner
def funcCallBody(parser, paren):
parser.nodeBookmark.append(1)
def notParen():
return not Parser.isEnd(parser)
if paren:
notEnd = lambda: parser.paren > parser.parenBookmark[-1]
else:
notEnd = notParen
while notEnd():
t = parser.nextToken()
if t.token == ",":
ExprParser.endExpr(parser)
parser.nodeBookmark[-1] = len(parser.currentNode.nodes)
continue
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
def funcCallBody(parser, paren):
parser.nodeBookmark.append(1)
def notParen():
return not Parser.isEnd(parser)
if paren :
notEnd = lambda: parser.paren > parser.parenBookmark[-1]
else:
notEnd = notParen
while notEnd():
t = parser.nextToken()
if t.token == "," :
ExprParser.endExpr(parser)
parser.nodeBookmark[-1] = len(parser.currentNode.nodes)
continue
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
def assignParser(parser, name= "", init= False, package = ""):
if not init:
i = parser.currentNode.nodes[-1]
del parser.currentNode.nodes[-1]
if package == "": package = parser.package
if name == "":
node = Tree.Assign("", parser= parser)
node.addNode(i)
else:
node = Tree.Assign(name, parser=parser)
node.package = package
node.init = init
parser.currentNode.addNode(node)
parser.currentNode = node
curr = parser.thisToken()
while not Parser.isEnd(parser):
parser.nextToken()
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = node.owner
self = node
if self.init:
if len(node.nodes) > 1 or len(node.nodes) == 0:
self.error("expecting single expression")
else:
if len(node.nodes) > 2 or len(node.nodes) == 1:
self.error("expecting single expression")
def initStruct(parser, package= "", shouldRead=True):
numB = parser.curly
unary = not shouldRead
if shouldRead and ExprParser.isUnary(parser, parser.lookBehind()):
unary = True
parser.curly += 1
readVar = True
if not unary:
if package == "": package = parser.package
if len(parser.currentNode.nodes) == 0:
Error.parseError(parser, "unexpected {")
if not type(parser.currentNode.nodes[-1]) in [Tree.ReadVar, Tree.Field]:
Error.parseError(parser, "unexpected {")
readVar = type(parser.currentNode.nodes[-1]) is Tree.ReadVar
name = parser.currentNode.nodes[-1].name if readVar else parser.currentNode.nodes[-1].field
init = Tree.InitStruct(parser)
if not readVar:
if type(parser.currentNode.nodes[-1].nodes[0]) is Tree.ReadVar:
package = parser.currentNode.nodes[-1].nodes[0].name
t = (parser.currentNode.nodes[-1].nodes[0])
if not package in parser.imports:
t.error("no package called " + package)
init.package = package
if not unary:
init.constructor = parser.currentNode.nodes[-1]
init.addNode(parser.currentNode.nodes[-1])
del parser.currentNode.nodes[-1]
init.mutable = False
init.unary = unary
parser.currentNode.addNode(init)
parser.currentNode = init
parser.nextToken()
while parser.thisToken().token != "}":
if parser.thisToken().token in [",", "\n"]:
ExprParser.endExpr(parser)
if parser.thisToken().token != ",": Parser.callToken(parser)
t = parser.thisToken().token
if t == "}" and parser.curly <= numB:
break
parser.nextToken()
else:
closeCurly(parser)
ExprParser.endExpr(parser)
parser.currentNode = init.owner
def ifBody(parser):
cond = Tree.IfCondition(parser)
parser.currentNode.addNode(cond)
parser.currentNode = cond
single = 0
parser.nodeBookmark.append(0)
then = False
assign = False
while not (Parser.isEnd(parser) and then):
if parser.thisToken().token == ":=":
assign = True
token = parser.nextToken()
if token.token == "then" and not then:
then = True
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
block = Tree.Block(parser)
cond.owner.addNode(block)
parser.currentNode = block
continue
isEnd = Parser.maybeEnd(parser)
if (token.token in ["else", "elif"]) and isEnd:
break
token = parser.thisToken()
Parser.callToken(parser)
token = parser.thisToken()
if token.token == "then" and not then:
then = True
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
block = Tree.Block(parser)
cond.owner.addNode(block)
parser.currentNode = block
continue
next = parser.lookInfront()
if (next.token == "else" or next.token == "elif") and isEnd:
break
ExprParser.endExpr(parser)
cond.type = Types.Bool()
parser.currentNode = cond.owner.owner
if assign:
m = Tree.Match(cond.owner)
m.addNode(cond.nodes[1])
c = Tree.MatchCase(cond)
c.addNode(cond.nodes[0])
m.addNode(c)
m.addNode(cond.owner.nodes[1])
c = Tree.MatchCase(cond)
u = Tree.Under(cond)
c.addNode(u)
m.addNode(c)
b = Tree.Block(cond.owner)
m.addNode(b)
parser.currentNode.nodes[-1] = m
m.owner = parser.currentNode
b.ifexpr = m.owner
def func(parser):
place = Tree.Lambda(parser)
parser.currentNode.addNode(place)
brace = Tree.FuncBraceOpen(parser)
place.addNode(brace)
parser.currentNode = brace
b = parser.nextToken()
count = -1
while parser.thisToken().token != "|":
if b.type == "identifier" and parser.lookInfront().token != ":":
count += 1
def callback(typ):
print(u.varName, "changed to", typ)
u = Types.Unknown(parser, callback)
u.varName = parser.thisToken().token
VarParser.createParser(parser, b, typ=u, check=False)
b = parser.nextToken()
continue
elif parser.thisToken().token == ":":
count += 1
elif b.token == ",":
b = parser.nextToken()
continue
Parser.declareOnly(parser)
b = parser.nextToken()
vars = [i.varType for i in brace]
typ = False
do = False
parser.nextToken()
place.returnTyp = False
if parser.thisToken().token == "->":
parser.nextToken()
typ = Types.parseType(parser)
place.returnTyp = True
parser.nextToken()
body = Tree.FuncBody(parser)
place.addNode(body)
parser.currentNode = body
if parser.thisToken().token == "do":
do = True
parser.nextToken()
brace.do = do
brace.body = body
body.do = do
first = True
parser.iter -= 1
while not Parser.isEnd(parser):
parser.nextToken()
Parser.callToken(parser, lam=first)
first = False
ExprParser.endExpr(parser)
place.args = vars
place.returnTyp = typ
place.do = do
parser.currentNode = place.owner
def guardExpr(parser):
ExprParser.endExpr(parser, -1)
parser.nodeBookmark.append(0)
place = Tree.PlaceHolder(parser)
parser.currentNode.addNode(place)
m = Tree.Match(parser)
m.guard = True
m.place = place
parser.currentNode.addNode(m)
parser.currentNode = m
assign = False
while True:
parser.nextToken()
if parser.thisToken().token == ":=":
assign = True
ExprParser.endExpr(parser, -1)
else:
Parser.callToken(parser)
b = parser.thisToken()
if b.token == ":=":
assign = True
isEnd = Parser.maybeEnd(parser)
next = parser.lookInfront()
if (next.token in ["else", "elif"]) and isEnd:
break
if len(m.nodes) != 2:
Error.parseError(
parser,
"Expecting singular expression, not " + str(len(m.nodes) - 1))
if not assign:
Error.parseError(parser, "Expecting :=")
#parser.currentNode.addNode(m)
ExprParser.endExpr(parser)
parser.nodeBookmark.pop()
create = m.nodes[0]
assign = m.nodes[1]
m.nodes[0] = assign
m.nodes[0].owner = m
del m.nodes[1]
case = Tree.MatchCase(parser)
m.addNode(case)
case.addNode(create)
m.addNode(Tree.Block(parser))
case2 = Tree.MatchCase(parser)
m.addNode(case2)
if not parser.nextToken().token in ["else", "elif"]:
Error.parseError(parser, "Expecting else")
if parser.thisToken().token == "else":
case2.addNode(Tree.Under(parser))
m.addNode(Tree.Block(parser))
ElseExpr.elseExpr(parser, canHaveElse=True)
m.nodes[4].nodes = m.nodes[4].nodes[1].nodes
else_block = m.nodes[4]
else:
IfExpr.elifExpr(parser, canHaveElse=True)
conditions = case2.nodes[0].nodes
block = case2.nodes[1]
case2.nodes = conditions
m.addNode(block)
else_block = block
if len(else_block) == 0:
Error.parseError(parser, "Guard block requires exit statement")
exit_condition = else_block.nodes[-1]
if not (type(exit_condition) in [Tree.Continue, Tree.Return, Tree.Break] or
(type(exit_condition) is Tree.FuncCall
and exit_condition.nodes[0].name == "panic")):
Error.parseError(parser, "Guard block requires exit statement")
parser.currentNode = m.owner
def match(parser):
t = parser.thisToken()
self = Tree.Match(parser)
parser.currentNode.addNode(self)
parser.currentNode = self
while t.token != "with":
t = parser.nextToken()
if t.token == "with":
break
Parser.callToken(parser)
t = parser.thisToken()
ExprParser.endExpr(parser)
parser.nextToken()
Parser.callToken(parser)
while not Parser.isEnd(parser):
t = parser.nextToken()
if t.token == "->":
ExprParser.endExpr(parser)
#print("entered ->")
if len(self.nodes) == 0:
Error.parseError(parser, "unexpected ->")
previos = self.nodes[-1]
if type(previos) is [Tree.MatchCase, Tree.Block]:
Error.parseError(parser, "unexpected ->")
case = Tree.MatchCase(parser)
case.addNode(previos)
self.nodes[-1] = case
case.owner = self
body = Tree.Block(parser)
self.addNode(body)
parser.currentNode = body
Parser.addBookmark(parser)
parser.nextToken()
Parser.callToken(parser)
while not Parser.isEnd(parser):
parser.nextToken()
"""if Parser.isEnd(parser):
parser.callToken(parser)
#print("break", parser.thisToken())
break
"""
Parser.callToken(parser)
#print("break", parser.thisToken())
Parser.returnBookmark(parser)
ExprParser.endExpr(parser)
parser.currentNode = body.owner
continue
Parser.callToken(parser)
if parser.thisToken().token == "->":
parser.iter -= 1
if len(self.nodes) % 2 == 0:
Error.parseError(parser, "Expecting ->")
parser.currentNode = self.owner
def parseLens(parser):
#parser.nextToken()
Scope.incrScope(parser)
#lensType = Types.parseType(parser)
Scope.decrScope(parser)
place = Tree.Place(parser)
lens = Tree.Lens(parser)
lens.place = place
parser.currentNode.addNode(lens)
parser.currentNode = lens
lens.addNode(place)
#parser.nextToken()
while not Parser.isEnd(parser):
parser.nextToken()
Parser.callToken(parser)
ExprParser.endExpr(parser)
parser.currentNode = lens.owner
B = Types.T("B", Types.All, "Lens")
def loop(n):
if type(n) in [Tree.PlaceHolder, Tree.Place]:
return B
elif type(n) is Tree.Field:
inner = loop(n.nodes[0])
return Types.Interface(False, {n.field: inner})
elif type(n) is Tree.ArrRead:
inner = loop(n.nodes[0])
return Types.Array(False, inner)
else:
n.error("unexpected token " + n.token.token)
lens_typ = loop(lens.nodes[0])
A = Types.T("A", lens_typ, "Lens")
self = Types.Interface(False, {
"query": Types.FuncPointer([A], B),
"set": Types.FuncPointer([A, B], A),
"toString": Types.FuncPointer([], Types.String(0)),
},
coll.OrderedDict([("Lens.A", A), ("Lens.B", B)]),
name="Lens")
Lens = Types.Interface(False, {
"query": Types.FuncPointer([A], B),
"set": Types.FuncPointer([A, B], A),
"toString": Types.FuncPointer([], Types.String(0)),
},
coll.OrderedDict([("Lens.A", A), ("Lens.B", B)]),
name="Lens")
#lens.type = Types.Interface(False, {
# # "query": Types.FuncPointer([i.lensType], i.nodes[0].type),
# "set": Types.FuncPointer([i.lensType, i.nodes[0].type], i.lensType),
#})
lens.type = Lens
def func(parser):
place = Tree.Lambda(parser)
parser.currentNode.addNode(place)
brace = Tree.FuncBraceOpen(parser)
place.addNode(brace)
parser.currentNode = brace
b = parser.nextToken()
count = -1
while parser.thisToken().token != "|":
count += 1
if b.type == "identifier":
VarParser.createParser(parser,
b,
typ=Types.Unknown(count, place),
check=False)
b = parser.nextToken()
continue
elif b.token == ",":
b = parser.nextToken()
continue
Parser.declareOnly(parser)
b = parser.Parser.nextToken(parser)
vars = [i.varType for i in brace]
typ = False
do = False
if parser.nextToken().token == "->":
typ = Types.parseType(parser)
body = Tree.FuncBody(parser)
place.addNode(body)
parser.currentNode = body
if parser.thisToken().token == "do":
do = True
parser.nextToken()
brace.do = do
brace.body = body
body.do = do
first = True
while not Parser.isEnd(parser):
Parser.callToken(parser, lam=first)
parser.nextToken()
first = False
ExprParser.endExpr(parser)
if typ:
place.type = Types.Lambda(place, vars, typ=typ, do=do)
else:
place.type = Types.Lambda(place, vars, do=do)
parser.currentNode = place.owner
def whileExpr(parser):
toplevel = Tree.While(parser)
parser.currentNode.addNode(toplevel)
parser.currentNode = toplevel
n = Tree.WhilePreCondition(parser)
cond = Tree.WhileCondition(parser)
parser.currentNode.addNode(n)
parser.currentNode.addNode(cond)
parser.currentNode = cond
assign = False
block = None
while not (Parser.isEnd(parser) and not parser.thisToken().token in ["!", "do", ":="]):
token = parser.nextToken()
if token.token == ":=" and not block:
assign = True
iter = parser.iter
if token.token == "do" :
ExprParser.endExpr(parser)
block = Tree.WhileBlock(parser)
cond.owner.addNode(block)
parser.currentNode = block
continue
Parser.callToken(parser)
if parser.thisToken().token == ":=":
assign = True
ExprParser.endExpr(parser)
parser.currentNode = n.owner.owner
if assign:
m = Tree.Match(cond.owner)
m.addNode(cond.nodes[1])
c = Tree.MatchCase(cond)
c.addNode(cond.nodes[0])
m.addNode(c)
new_block = Tree.Block(block)
new_block.nodes = block.nodes
for i in new_block.nodes:
i.owner = new_block
m.addNode(new_block)
c = Tree.MatchCase(cond)
u = Tree.Under(cond)
c.addNode(u)
m.addNode(c)
b = Tree.Block(cond.owner)
b.addNode(Tree.Break(cond))
m.addNode(b)
cond.nodes = [Tree.Bool("true", cond)]
cond.nodes[0].owner = cond
block.nodes = [m]
m.owner = block
b.ifexpr = m.owner
