def typeParser(parser, decl= False):
name = parser.nextToken()
Scope.incrScope(parser)
if name.type != "identifier":
Error.parseError(parser, "type name must be an identifier")
name = name.token
if name[0].lower() == name[0]:
Error.parseError(parser, "struct name must be upper case")
import collections as coll
gen = coll.OrderedDict()
if parser.nextToken().token == "[":
gen = FuncParser.generics(parser, name)
if parser.thisToken().token != "=":
if parser.thisToken().token == "with":
tmp = parser.currentNode
parser.currentNode = Tree.PlaceHolder(parser)
Interface.traitParser(parser, name, decl, gen)
parser.currentNode = tmp
return
Error.parseError(parser, "expecting =")
tmp = parser.currentNode
typ = Tree.Type(parser.package, name, parser)
typ.package = parser.package
typ.normalName = name
tmp.addNode(typ)
parser.currentNode = typ
while not Parser.isEnd(parser):
parser.nextToken()
Parser.declareOnly(parser, noVar=True)
args = [i.varType for i in parser.currentNode]
fields = parser.currentNode.nodes
typ.fields = [i.name for i in typ]
typ.nodes = []
parser.currentNode = tmp
if decl:
meth = parser.structs[parser.package][name].methods
parser.structs[parser.package][name] = Struct(name, args, fields, gen)
parser.structs[parser.package][name].methods = meth
parser.structs[parser.package][name].package = parser.package
Scope.decrScope(parser)
def traitParser(parser, name, decl, generic):
interface = parser.interfaces[parser.package][name]
meth = {}
while not Parser.isEnd(parser):
parser.nextToken()
t = parser.thisToken()
if t.token == "def":
currentNode = parser.currentNode
p = PlaceHolder(parser)
parser.currentNode = p
(methodName, names, types, brace, returnType,
do) = FuncParser.funcHead(parser,
decl,
dontAdd=True,
interfaceMethod=True)
Scope.decrScope(parser)
if methodName in meth:
Error.parseError(parser,
"Method " + methodName + ", already defined")
meth[methodName] = brace.ftype
parser.currentNode = currentNode
parser.nextToken()
else:
Parser.declareOnly(parser, noVar=True)
if len(parser.currentNode.nodes) > 0 and type(
parser.currentNode.nodes[0]) is Tree.Create:
Error.parseError(
parser,
"Interfaces are abstract interfaces which is why only methods are supported"
)
names = {i.name: i.varType for i in parser.currentNode}
#args = [i.varType for i in parser.currentNode]
#fields = parser.currentNode.nodes
if decl:
i = interface.fromObj(
Types.Interface(False,
names,
generic,
parser.package + "." +
name if parser.package != "_global" else name,
methods=meth))
parser.interfaces[parser.package][name] = i
Scope.decrScope(parser)
def typeParser(parser, decl= False):
name = parser.nextToken()
Scope.incrScope(parser)
if name.type != "identifier":
Error.parseError(parser, "type name must be an identifier")
name = name.token
if name[0].lower() == name[0]:
Error.parseError(parser, "struct name must be upper case")
import collections as coll
gen = coll.OrderedDict()
if parser.nextToken().token == "[":
gen = FuncParser.generics(parser, name)
if parser.thisToken().token != "=":
if parser.thisToken().token in ["with", "either", "is"]:
tmp = parser.currentNode
if parser.thisToken().token == "either":
Enum.enumParser(parser, name, decl, gen)
elif parser.thisToken().token == "is":
Alias.aliasParser(parser, name, decl, gen)
else:
parser.currentNode = Tree.PlaceHolder(parser)
Interface.traitParser(parser, name, decl, gen)
parser.currentNode = tmp
return
Error.parseError(parser, "expecting =")
tmp = parser.currentNode
typ = Tree.Type(parser.package, name, parser)
typ.package = parser.package
typ.normalName = name
tmp.addNode(typ)
parser.currentNode = typ
while not Parser.isEnd(parser):
parser.nextToken()
Parser.declareOnly(parser, noVar=True)
args = [i.varType for i in parser.currentNode]
fields = parser.currentNode.nodes
typ.fields = [i.name for i in typ]
typ.nodes = []
parser.currentNode = tmp
if decl:
meth = parser.structs[parser.package][name].methods
_types = parser.structs[parser.package][name]._types
parser.structs[parser.package][name] = Struct(name, args, fields, gen, typ, parser.package)
tmp = parser.structs[parser.package][name]._types
parser.structs[parser.package][name].methods = meth
parser.structs[parser.package][name].package = parser.package
parser.structs[parser.package][name]._types = _types
_types.update(tmp)
Scope.changeType(parser, name, parser.structs[parser.package][name] )
typ.struct = parser.structs[parser.package][name]
Scope.decrScope(parser)
def funcHead(parser):
(name, names, types, header, returnType,
do) = FuncParser.funcHead(parser, True)
Scope.decrScope(parser)
def before():
if _package == "":
package = parser.package
else:
package = _package
gen = _gen
attachTyp = _attachTyp
mutable = _mutable
token = parser.thisToken().token
if token == "i32":
return I32()
elif token == "float":
return Float()
elif token == "string":
return String(0)
elif token == "int":
return I32()
elif token == "bool":
return Bool()
elif token == "(":
args = []
parser.nextToken()
while parser.thisToken().token != ")":
if parser.thisToken().token == ",":
if parser.lookBehind().token == ",":
parseError(parser, "unexpected ,")
parser.nextToken()
continue
args.append(parseType(parser))
parser.nextToken()
return Tuple(args)
elif token == "enum":
return EnumT()
elif token == "[" or parser.thisToken().type == "whiteOpenS":
incrScope(parser)
if parser.lookInfront().token != "]":
from TopCompiler import FuncParser
gen = FuncParser.generics(parser, "_")
if parser.thisToken().token != "|":
parseError(parser, "expecting |")
res = parseType(parser, package, mutable, attachTyp, gen)
decrScope(parser)
return res
else:
parser.nextToken()
parser.nextToken()
decrScope(parser)
return Array(False, parseType(parser, package))
elif token == "|":
parser.nextToken()
args = []
while not (parser.thisToken().token == "|"
and parser.lookInfront().token in ["->", "do"]):
if parser.thisToken().token == ",":
if parser.lookBehind().token == ",":
parseError(parser, "unexpected ,")
parser.nextToken()
continue
args.append(parseType(parser))
parser.nextToken()
ret = Null()
do = False
if parser.lookInfront().token == "->":
parser.nextToken()
parser.nextToken()
ret = parseType(parser, package)
if parser.lookInfront().token == "do":
parser.nextToken()
parser.nextToken()
ret = parseType(parser, package)
do = True
return FuncPointer(args, ret, gen, do)
elif token == "none":
return Null()
elif token in parser.imports:
if parser.lookInfront().token == ".":
parser.nextToken()
parser.nextToken()
return parseType(parser, token)
else:
parseError(parser, "expecting .")
elif token == "{" or parser.thisToken().type == "bracketOpenS":
args = {}
parser.nextToken()
while parser.thisToken().token != "}":
if parser.thisToken().token == ",":
pass
else:
name = parser.thisToken().token
if parser.thisToken().type != "identifier":
Error.parseError(parser, "expecting identifier")
if parser.nextToken().token != ":":
Error.parseError(parser, "expecting :")
parser.nextToken()
typ = parseType(parser)
args[name] = typ
parser.nextToken()
return Interface(False, args)
elif (token in parser.interfaces[package]) or (
token in parser.interfaces["_global"]
and parser.package == package):
if token in parser.interfaces["_global"]:
package = "_global"
if parser.interfaces[package][token].generic != coll.OrderedDict():
if parser.lookInfront().token != "[":
#parseError(parser, "must specify generic parameters for generic type")
pass
else:
parser.nextToken()
gen = parseGeneric(parser,
parser.interfaces[package][token])
return replaceT(parser.interfaces[package][token], gen)
return parser.interfaces[package][token]
elif token in parser.structs[package]:
gen = coll.OrderedDict()
if attachTyp:
return parser.structs[package][token]
if parser.structs[package][token].generic != {}:
if parser.nextToken().token != "[":
parseError(
parser,
"must specify generic parameters for generic type")
gen = parseGeneric(parser, parser.structs[package][token])
return Struct(mutable, token,
parser.structs[package][token]._types,
parser.structs[package][token].package, gen)
elif varExists(parser, package, token):
t = typeOfVar(Tree.PlaceHolder(parser), parser, package, token)
if type(t) is T:
return t
parseError(parser, "unkown type " + token)
elif token == "_":
return Underscore()
else:
parseError(parser, "unknown type " + token)
def _resolve(self, tokens, filename, passN=0):
target = self.global_target
if self.package != "main":
self.global_target = "full"
if self.hotswap and not ImportParser.shouldCompile(False, self.package,
self):
return
self.filename = filename
self.iter = 0
self.tokens = tokens
while self.iter < len(tokens) - 1:
b = self.thisToken().token
if passN == 2:
if b == "import":
ImportParser.importParser(self, True)
elif b == "from":
ImportParser.fromParser(self, True)
elif b == "def":
if self.indentLevel == 0:
nex = self.lookInfront()
Parser.addBookmark(self)
funcHead(self)
Parser.returnBookmark(self)
elif passN == 1:
if b == "import":
ImportParser.importParser(self, True)
elif b == "from":
ImportParser.fromParser(self, True)
elif b == "type":
Parser.addBookmark(self)
Struct.typeParser(self, decl=True)
Parser.returnBookmark(self)
elif passN == 0:
if b == "type":
name = self.nextToken().token
if name == "ext":
name = self.nextToken().token
ofType = None
gen = {}
if self.nextToken().token == "[":
Scope.incrScope(self)
gen = FuncParser.generics(self, name)
Scope.decrScope(self)
ofType = self.thisToken().token
else:
ofType = self.thisToken().token
Scope.addVar(Tree.Node(self), self, name,
Scope.Type(True, Types.StructInit(name)))
if ofType is None or ofType == "=":
#"""
self.structs[self.package][name] = Struct.Struct(
name, [], [], gen, self, self.package)
self.structs[self.package][name].methods = {}
#"""
elif ofType == "either":
self.interfaces[self.package][name] = Types.Enum(
self.package, name, coll.OrderedDict(), gen)
elif ofType == "with":
self.interfaces[self.package][name] = Types.Interface(
False, {}, name=self.package + "." + name)
elif ofType == "is":
self.interfaces[self.package][name] = Types.Alias(
self.package, name, Types.Null(), gen)
if b == "\n":
Parser.addBookmark(self)
Parser.newLine(self)
Parser.returnBookmark(self)
self.nextToken()
for i in self.imports:
if not i in self.allImports[self.package]:
self.allImports[self.package].append(i)
self.imports = []
self.lineNumber = 1
self.normalIndent = 0
self.global_target = target
def funcHead(parser):
(name, names, types, header, returnType, do) = FuncParser.funcHead(parser, True)
Scope.decrScope(parser)
def parseType(parser, package="", mutable=False, attachTyp=False, gen={}):
if package == "":
package = parser.package
token = parser.thisToken().token
if token == "i32":
return I32()
elif token == "float":
return Float()
elif token == "string":
return String(0)
elif token == "int":
return I32()
elif token == "bool":
return Bool()
elif token == "[":
if parser.lookInfront().token != "]":
from TopCompiler import FuncParser
gen = FuncParser.generics(parser, "anonymous")
if parser.thisToken().token != "|":
parseError(parser, "expecting |")
return parseType(parser, package, mutable, attachTyp, gen)
else:
parser.nextToken()
parser.nextToken()
return Array(False, parseType(parser, package))
elif token == "|":
parser.nextToken()
args = []
while parser.thisToken().token != "|":
if parser.thisToken().token == ",":
if parser.lookBehind().token == ",":
parseError(parser, "unexpected ,")
parser.nextToken()
continue
args.append(parseType(parser))
parser.nextToken()
ret = Null()
if parser.lookInfront().token == "->":
parser.nextToken()
parser.nextToken()
ret = parseType(parser, package)
return FuncPointer(args, ret, gen)
elif token == "none":
return Null()
elif token in parser.imports:
if parser.lookInfront().token == ".":
parser.nextToken()
parser.nextToken()
return parseType(parser, token)
else:
parseError(parser, "expecting .")
elif (token in parser.interfaces[package]) or (token in parser.interfaces["_global"] and parser.package == package):
if token in parser.interfaces["_global"]:
package = "_global"
if parser.interfaces[package][token].generic != coll.OrderedDict():
if parser.lookInfront().token != "[":
# parseError(parser, "must specify generic parameters for generic type")
pass
else:
parser.nextToken()
gen = parseGeneric(parser, parser.interfaces[package][token])
return replaceT(Interface(False, parser.interfaces[package][token].types), gen)
return Interface(False, parser.interfaces[package][token].types)
elif token in parser.structs[package]:
gen = coll.OrderedDict()
if attachTyp:
return parser.structs[package][token]
if parser.structs[package][token].generic != {}:
if parser.nextToken().token != "[":
parseError(parser, "must specify generic parameters for generic type")
gen = parseGeneric(parser, parser.structs[package][token])
return Struct(mutable, token, parser.structs[package][token].types, package, gen)
elif varExists(parser, package, token):
t = typeOfVar(Tree.PlaceHolder(parser), parser, package, token)
if type(t) is T:
return t
parseError(parser, "unkown type " + token)
elif token == "_":
return Underscore()
else:
parseError(parser, "unknown type " + token)
def typeParser(parser, decl=False):
name = parser.nextToken()
Scope.incrScope(parser)
if name.type != "identifier" and name.token != "ext":
Error.parseError(parser, "type name must be an identifier")
externalStruct = False
if name.token == "ext":
externalStruct = True
name = parser.nextToken()
if name.type != "identifier" and name.token != "ext":
Error.parseError(parser, "type name must be an identifier")
name = name.token
if name[0].lower() == name[0] and not externalStruct:
Error.parseError(parser, "struct name must be upper case")
import collections as coll
gen = coll.OrderedDict()
if parser.nextToken().token == "[":
if externalStruct:
Error.parseError(parser, "External structs cannot be generic")
gen = FuncParser.generics(parser, name)
if parser.thisToken().token != "=":
if parser.thisToken().token in ["with", "either", "is"]:
if externalStruct:
Error.parseError(
parser,
"Can only define external structs not interfaces, enums or aliases"
)
tmp = parser.currentNode
if parser.thisToken().token == "either":
Enum.enumParser(parser, name, decl, gen)
elif parser.thisToken().token == "is":
Alias.aliasParser(parser, name, decl, gen)
else:
parser.currentNode = Tree.PlaceHolder(parser)
Interface.traitParser(parser, name, decl, gen)
parser.currentNode = tmp
return
Error.parseError(parser, "expecting =")
tmp = parser.currentNode
typ = Tree.Type(parser.package, name, parser)
typ.package = parser.package
typ.normalName = name
typ.externalStruct = externalStruct
tmp.addNode(typ)
parser.currentNode = typ
while not Parser.isEnd(parser):
parser.nextToken()
Parser.declareOnly(parser, noVar=True)
args = [i.varType for i in parser.currentNode]
fields = parser.currentNode.nodes
if not decl:
using = parser.structs[parser.package][name].using
for i in parser.currentNode:
if type(i) is Tree.Using:
using.append(i.name)
typ.fields = [i.name for i in typ]
typ.args = args
typ.generics = gen
typ.nodes = []
parser.currentNode = tmp
if decl:
meth = parser.structs[parser.package][name].methods
_types = parser.structs[parser.package][name]._types
#if name == "Channel":
# print("Channel make")
# print(id(_types))
parser.structs[parser.package][name] = Struct(name, args, fields, gen,
typ, parser.package)
tmp = parser.structs[parser.package][name]._types
parser.structs[parser.package][name].methods = meth
parser.structs[parser.package][name].package = parser.package
parser.structs[parser.package][name]._types = _types
parser.structs[parser.package][name].externalStruct = externalStruct
_types.update(tmp)
Scope.changeType(parser, name, parser.structs[parser.package][name])
typ.struct = parser.structs[parser.package][name]
Scope.decrScope(parser)
