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 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)