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