def enumParser(parser, name, decl, generic):
const = parser.interfaces[parser.package][name].const
existing_generics = parser.interfaces[parser.package][name].generic
existing_generics.update(generic)
#const = coll.OrderedDict()
enum = Types.Enum(parser.package, name, const, existing_generics)
if decl:
parser.interfaces[parser.package][name] = enum
"""if parser.lookInfront().token == "\n":
parser.nextToken()
Parser.callToken(parser)
parser.nextToken()"" \
"""
while not Parser.isEnd(parser):
t = parser.nextToken()
if t.token == "\n" or t.type == "indent":
Parser.callToken(parser)
continue
if t.type != "identifier":
Error.parseError(parser, "expecting identifier")
varName = t.token
if varName[0].upper() != varName[0]:
Error.parseError(parser, "constructor type must be capitalized")
args = []
nextT = parser.nextToken()
#print(varName)
#print(nextT)
if nextT.token == "(":
args = Types.parseType(parser).list
const[varName] = args
if decl:
Scope.addVar(Tree.PlaceHolder(parser),
parser,
varName,
Scope.Type(
True,
Types.FuncPointer(args, enum, generic=generic)
if len(args) > 0 else enum),
_global=True)
t = parser.thisToken()
if t.token == "\n" or t.type == "indent":
Parser.callToken(parser)
parser.currentNode.addNode(Tree.Enum(const, name, parser, generic))
Scope.decrScope(parser)
def resolveGen(shouldBeTyp, normalTyp, generics, parser):
if type(shouldBeTyp) is Types.T:
if shouldBeTyp.normalName in generics:
return generics[shouldBeTyp.normalName]
else:
generics[shouldBeTyp.normalName] = normalTyp
return shouldBeTyp.type
elif type(shouldBeTyp) is Types.Array:
if type(normalTyp) != Types.Array:
return shouldBeTyp
t = Types.Array(False, resolveGen(shouldBeTyp.elemT, normalTyp.elemT, generics, parser))
return t
elif type(shouldBeTyp) is Types.FuncPointer:
args = []
if not type(normalTyp) is Types.FuncPointer:
return shouldBeTyp
if len(shouldBeTyp.args) != len(normalTyp.args):
return shouldBeTyp
if normalTyp.isLambda:
try:
shouldBeTyp = Types.replaceT(shouldBeTyp, generics)
shouldBeTyp.duckType(parser, normalTyp, Tree.PlaceHolder(parser), Tree.PlaceHolder(parser), 0)
except EOFError as e:
normalTyp.check(parser)
for (should, nor) in zip(shouldBeTyp.args, normalTyp.args):
args.append(resolveGen(should, nor, generics, parser))
resolveGen(shouldBeTyp.returnType, normalTyp.returnType, generics, parser)
return Types.replaceT(shouldBeTyp, generics)
elif type(shouldBeTyp) in [Types.Struct, Types.Enum]:
if not type(normalTyp) is Types.Struct:
return shouldBeTyp
self = shouldBeTyp
other = normalTyp
if self.package+"_"+self.normalName != other.package+"_"+other.normalName:
return shouldBeTyp
types = {}
shouldGeneric = shouldBeTyp.remainingGen
normalGeneric = normalTyp.gen
for i in shouldGeneric:
generics[i] = resolveGen(shouldGeneric[i], normalGeneric[i], generics, parser)
if type(shouldBeTyp) is Types.Enum:
return Types.Enum(self.package, self.normalName, self.const, generics)
else:
return Types.Struct(False, self.normalName, self.types, self.package, generics)
elif type(shouldBeTyp) is Types.Assign:
const = shouldBeTyp.const
return Types.Assign(Types.replaceT(const, generics))
elif type(shouldBeTyp) is Types.Interface:
types = {}
for i in shouldBeTyp.types:
try:
types[i] = resolveGen(shouldBeTyp.types[i], normalTyp.types[i], generics, parser)
except KeyError:
try:
meth = normalTyp.hasMethod(parser, i)
if type(meth) is Types.FuncPointer:
types[i] = resolveGen(shouldBeTyp.types[i], Types.FuncPointer(meth.args[1:], meth.returnType, generic= meth.generic, do= meth.do), generics, parser)
elif meth:
types[i] = meth
else:
types[i] = shouldBeTyp.types[i]
except AttributeError:
types[i] = shouldBeTyp.types[i]
return Types.Interface(False, types, generics)
else:
return shouldBeTyp
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 resolveGen(shouldBeTyp, normalTyp, generics, parser, myNode, other):
if type(shouldBeTyp) is Types.Unknown:
print("should be typ is unknown")
if type(normalTyp) is Types.T and not (
normalTyp.owner
in parser.func) and normalTyp.name != shouldBeTyp.name:
if normalTyp.normalName in generics:
normalTyp = generics[normalTyp.normalName]
else:
newTyp = Types.replaceT(shouldBeTyp, generics)
tmp = normalTyp
generics[normalTyp.normalName] = newTyp
normalTyp = newTyp
normalTyp = resolveGen(tmp.type, newTyp, generics, parser, myNode,
other)
normalTyp.duckType(parser, newTyp, myNode, other, 0)
normalTyp = newTyp
if type(shouldBeTyp) is Types.T:
if shouldBeTyp.normalName in generics:
tmp = generics[shouldBeTyp.normalName]
try:
tmp.duckType(parser, normalTyp, myNode, other, 0)
except EOFError as e:
normalTyp.duckType(parser, tmp, myNode, other, 0)
generics[shouldBeTyp.normalName] = normalTyp
return tmp
else:
generics[shouldBeTyp.normalName] = normalTyp
if normalTyp.name != shouldBeTyp.name:
tmp = shouldBeTyp.type
tmp = resolveGen(tmp, normalTyp, generics, parser, myNode,
other)
tmp.duckType(parser, normalTyp, myNode, other, 0)
else:
tmp = shouldBeTyp
#if Types.isGeneric(tmp):
# resolveGen(tmp, normalTyp, generics, parser, myNode, other)
#else:
return normalTyp
elif type(shouldBeTyp) is Types.Array:
if type(normalTyp) != Types.Array:
return shouldBeTyp
try:
t = Types.Array(
False,
resolveGen(shouldBeTyp.elemT, normalTyp.elemT, generics,
parser, myNode, other))
except EOFError as e:
Error.beforeError(e, "Element type in array: ")
return t
elif type(shouldBeTyp) is Types.FuncPointer:
args = []
if not type(normalTyp) is Types.FuncPointer:
return Types.replaceT(shouldBeTyp, generics)
if len(shouldBeTyp.args) != len(normalTyp.args):
return Types.replaceT(shouldBeTyp, generics)
for (count, (should,
nor)) in enumerate(zip(shouldBeTyp.args, normalTyp.args)):
try:
res = resolveGen(nor, should, generics, parser, myNode, other)
args.append(res)
except EOFError as e:
Error.beforeError(
e, "Function type argument " + str(count) + ": ")
try:
returnTyp = resolveGen(shouldBeTyp.returnType,
normalTyp.returnType, generics, parser,
myNode, other)
except EOFError as e:
Error.beforeError(e, "Function type return type: ")
return Types.FuncPointer(args, returnTyp, do=shouldBeTyp.do)
#return Types.replaceT(shouldBeTyp, generics)
#return Types.FuncPointer(args, returnTyp, Types.remainingT(returnTyp), do = shouldBeTyp.do)
elif type(shouldBeTyp) is Types.Tuple:
if not type(normalTyp) is Types.Tuple:
return shouldBeTyp
arr = []
for (key, (should,
nor)) in enumerate(zip(shouldBeTyp.list, normalTyp.list)):
try:
arr.append(
resolveGen(should, nor, generics, parser, myNode, other))
except EOFError as e:
Error.beforeError(e, "Tuple element #" + str(key) + ": ")
return Types.Tuple(arr)
elif type(shouldBeTyp) in [Types.Struct, Types.Enum, Types.Alias]:
gen = generics
if not type(normalTyp) is type(shouldBeTyp):
return shouldBeTyp
self = shouldBeTyp
other = normalTyp
if self.package + "_" + self.normalName != other.package + "_" + other.normalName:
return shouldBeTyp
types = {}
shouldGeneric = shouldBeTyp.remainingGen
if type(shouldBeTyp) in [Types.Enum, Types.Alias]:
normalGeneric = normalTyp.generic
else:
normalGeneric = normalTyp.gen
for i in shouldGeneric:
try:
generics[i] = resolveGen(shouldGeneric[i], normalGeneric[i],
generics, parser, myNode, other)
except EOFError as e:
Error.beforeError(
e, "Field '" + i + "' in " + str(shouldBeTyp) + ": ")
if type(shouldBeTyp) is Types.Enum:
return Types.Enum(self.package, self.normalName, self.const,
generics)
elif type(shouldBeTyp) is Types.Alias:
return Types.Alias(self.package, self.normalName,
Types.replaceT(self.typ, generics), generics)
else:
return Types.Struct(False, self.normalName, self.types,
self.package, generics)
elif type(shouldBeTyp) is Types.Assign:
const = shouldBeTyp.const
return Types.Assign(Types.replaceT(const, generics))
elif type(shouldBeTyp) is Types.Interface:
types = {}
for i in shouldBeTyp.types:
try:
types[i] = resolveGen(shouldBeTyp.types[i], normalTyp.types[i],
generics, parser, myNode, other)
except EOFError as e:
Error.beforeError(
e, "Field '" + i + "' in " + str(shouldBeTyp) + ": ")
except KeyError:
try:
meth = normalTyp.hasMethod(parser, i)
if type(meth) is Types.FuncPointer:
types[i] = resolveGen(
shouldBeTyp.types[i],
Types.FuncPointer(meth.args[1:],
meth.returnType,
generic=meth.generic,
do=meth.do), generics, parser,
myNode, other)
elif meth:
types[i] = meth
else:
types[i] = shouldBeTyp.types[i]
except AttributeError:
types[i] = shouldBeTyp.types[i]
gen = ODict()
for key in shouldBeTyp.generic:
gen[key] = Types.replaceT(shouldBeTyp.generic[key], generics)
#gen = {i: generics[i] for i in generics if ".".join(i.split(".")[:-1]) == shouldBeTyp.normalName}
r = Types.Interface(False, types, gen, shouldBeTyp.normalName)
return r
else:
return shouldBeTyp
