def parseOsm(osmFilename, bilFilename): osmfile = ET.parse(osmFilename) rootofTree = osmfile.getroot() elevations = extractElevations(bilFilename) elevation2D = elevationArray(elevations) # start extracting 'ways' and 'nodes' mapNodes = [] paths = [] pathname = "" for eachItem in rootofTree: isAPath = False if eachItem.tag == 'node': latitude = (float)(eachItem.get('lat')) longitude = (float)(eachItem.get('lon')) nodeId = (int)(eachItem.get('id')) # map the elevation data to the node in osm file elevation = elevation2D[(int)(44 - latitude) * (numberofRows)][(int)(longitude + 79) * (numberofColumns)] mapNodes.append(DT.Node(latitude, longitude, elevation, nodeId)) elif eachItem.tag == 'way': pathList = [] pathNodes = [] pathName = "No Name" alreadyExists = False for subItem in eachItem: if subItem.tag == 'tag' and subItem.get('k') == 'highway': isAPath = True if subItem.tag == 'tag' and subItem.get('k') == 'access': isAPath = False if isAPath == True: for subItem in eachItem: if subItem.tag == 'tag' and subItem.get('k') == 'name': pathName = subItem.get('v') if subItem.tag == 'nd': for point in mapNodes: if point.id == (int)(subItem.get('ref')): pathNodes.append(point) pathList.append((int)(subItem.get('ref'))) for walkPath in pathList: for aNode in mapNodes: if aNode.id == walkPath: aNode.paths.append( DT.Path((int)(eachItem.get('id')), pathName, pathNodes)) paths.append( DT.Path((int)(eachItem.get('id')), pathName, pathNodes)) return mapNodes, paths
def scan_identifier(self, delim): if self.current() == '$': stage = 0 direction = 1 char = '$' else: assert self.current() == '@' stage = -1 direction = -1 char = '@' self.advance() while self.has_more() and self.current() == char: stage += direction self.advance() start = self.cursor while self.has_more() and (self.is_word_char(self.current()) or self.current() == ':'): self.advance() end = self.cursor combined = self.slice(start, end) if len(combined) == 0: return Token.quote(stage, delim) else: value = data.Path(combined.split(':')) return Token.identifier(data.Identifier(stage, value), delim)
def parse_atomic_expression(self): if self.at_type(Token.LITERAL): value = self.expect_type(Token.LITERAL) result = ast.Literal(value) if isinstance(value, data.DecimalFraction): # While the infrastructure is not in place to create floats without # magic we insert a new_float invocation in the parser. result = ast.Invocation([ ast.Argument(data._SUBJECT, ast.Variable(data.Identifier(-1, data.Path(["ctrino"])))), ast.Argument(data._SELECTOR, ast.Literal(data.Operation.infix("new_float_32"))), ast.Argument(data._TRANSPORT, ast.Literal(data._SYNC)), ast.Argument(0, result) ]) return result elif self.at_type(Token.IDENTIFIER): return self.parse_variable() elif self.at_punctuation('('): self.expect_punctuation('(') result = self.parse_expression(False) self.expect_punctuation(')') return result elif self.at_punctuation('['): return self.parse_array_expression() elif self.at_punctuation('{'): return self.parse_sequence_expression() elif self.at_word('null'): self.expect_word('null') return ast.Literal(None) elif self.at_word('true'): self.expect_word('true') return ast.Literal(True) elif self.at_word('false'): self.expect_word('false') return ast.Literal(False) elif self.at_word('subject'): self.expect_word('subject') return ast.Literal(data._SUBJECT) elif self.at_word('selector'): self.expect_word('selector') return ast.Literal(data._SELECTOR) elif self.at_word('transport'): self.expect_word('transport') return ast.Literal(data._TRANSPORT) elif self.at_word('async'): self.expect_word('async') return ast.Literal(data._ASYNC) elif self.at_word('sync'): self.expect_word('sync') return ast.Literal(data._SYNC) elif self.at_word('module'): self.expect_word('module') return ast.CurrentModule() elif self.at_type(Token.QUOTE): return self.parse_quote() else: raise self.new_syntax_error()
def parse_signature(self): prefix = [ self.name_as_subject(data.Identifier(0, data.Path(['self']))), self.name_as_selector(Parser._SAUSAGES), ast.Parameter(None, [data._TRANSPORT], ast.Guard.eq(ast.Literal(data._SYNC))) ] (params, operation, allow_extra, reified) = self.parse_parameters(None) if params is None: params = [] return ast.Signature(prefix + params, allow_extra, reified)
def parse_field_declaration(self): self.expect_word('field') subject = self.parse_subject() (op, is_async) = self.expect_type(Token.OPERATION) prop = data.Operation.infix(op) getter = self.name_as_selector(prop) setter = self.name_as_selector(data.Operation.assign(prop)) self.expect_statement_delimiter(True) key_name = data.Path([op]) return ast.FieldDeclaration(subject, key_name, getter, setter)
def run_parse_input(self, inputs, parse_thunk): for expr in inputs: tokens = token.tokenize(expr) unit = parse_thunk(tokens) # Implicitly import the core module into the oldest stage. There needs to # better model for this but for now it helps make builtin methods slightly # less magic. unit.get_oldest_stage().add_import(data.Path(['core'])) self.schedule_for_compile(unit) self.schedule_for_output(unit)
def ensure_function_declared(self, name): if name in self.functions: return self.functions.add(name) value = Invocation([ Argument(data._SUBJECT, Variable(data.Identifier(-1, data.Path(["ctrino"])))), Argument(data._SELECTOR, Literal(data.Operation.infix("new_function"))), Argument(data._TRANSPORT, Literal(data._SYNC)), Argument(0, Literal(name.path)) ]) self.add_element(NamespaceDeclaration([], name, value))
def parse_for_expression(self, expect_delim): self.expect_word('for') sig = self.parse_signature() self.expect_word('in') elms = self.parse_expression(False) self.expect_word('do') body = self.parse_expression(expect_delim) thunk = ast.Lambda([ast.Method(sig, body)]) return ast.Invocation([ ast.Argument(data._SUBJECT, ast.Variable(data.Identifier(-1, data.Path(["core", "for"])))), ast.Argument(data._SELECTOR, ast.Literal(Parser._SAUSAGES)), ast.Argument(data._TRANSPORT, ast.Literal(data._SYNC)), ast.Argument(0, elms), ast.Argument(1, thunk), ])
def parse_while_expression(self, expect_delim): self.expect_word('while') cond = self.parse_expression(False) self.expect_word('do') body = self.parse_expression(expect_delim) methods = [ ast.Lambda.method(cond, data.Operation.infix('keep_running?')), ast.Lambda.method(body, data.Operation.infix('run!')) ] return ast.Invocation([ ast.Argument(data._SUBJECT, ast.Variable(data.Identifier(-1, data.Path(["core", "while"])))), ast.Argument(data._SELECTOR, ast.Literal(Parser._SAUSAGES)), ast.Argument(data._TRANSPORT, ast.Literal(data._SYNC)), ast.Argument(0, ast.Lambda(methods)), ])
def parse_when_expression(self, expect_delim): self.expect_word('when') self.expect_word('def') sig = self.parse_signature() self.expect_punctuation(':=') value = self.parse_expression(False) self.expect_word('do') body = self.parse_expression(expect_delim) thunk = ast.Lambda([ast.Method(sig, body)]) return ast.Invocation([ ast.Argument(data._SUBJECT, ast.Variable(data.Identifier(-1, data.Path(["core", "when_def"])))), ast.Argument(data._SELECTOR, ast.Literal(Parser._SAUSAGES)), ast.Argument(data._TRANSPORT, ast.Literal(data._SYNC)), ast.Argument(0, value), ast.Argument(1, thunk), ])
def apply(self, module): # TODO: this field shouldn't be accessible through the namespace. key_ident = data.Identifier(-1, self.key_name) key_access = Variable(key_ident) not_async = Parameter(None, [data._TRANSPORT], Guard.eq(Literal(data._SYNC))) key_decl = NamespaceDeclaration( [], key_ident, Invocation([ Argument(data._SUBJECT, CurrentModule()), Argument(data._SELECTOR, Literal(FieldDeclaration._NEW_GLOBAL_FIELD)), Argument(data._TRANSPORT, Literal(data._SYNC)), Argument(0, Literal(self.key_name)), ])) key_decl.apply(module) getter = MethodDeclaration( 0, [], Method( Signature([self.subject, self.getter, not_async], False, None), Invocation([ Argument(data._SUBJECT, key_access), Argument(data._SELECTOR, Literal(FieldDeclaration._SQUARE_SAUSAGES)), Argument(data._TRANSPORT, Literal(data._SYNC)), Argument(0, Variable(self.subject.ident)) ]))) value = value = Parameter(data.Identifier(0, data.Path(['value'])), [0], Guard.any()) setter = MethodDeclaration( 0, [], Method( Signature([self.subject, self.setter, not_async, value], False, None), Invocation([ Argument(data._SUBJECT, key_access), Argument(data._SELECTOR, Literal(FieldDeclaration._SQUARE_SAUSAGE_ASSIGN)), Argument(data._TRANSPORT, Literal(data._SYNC)), Argument(0, Variable(self.subject.ident)), Argument(1, Variable(value.ident)) ]))) getter.apply(module) setter.apply(module)
def bfs(matrix, word_list, start, end): for word in word_list: word.level = 0 word.parent = None q = data.Queue(10000) q.enqueue(word_list[start]) visited = [False for _ in range(len(word_list))] visited[start] = True while not q.is_empty(): dequed = q.dequeue() v = dequed result = string_compare(word_list[end].word, v.word) if result: path = data.Path([None for _ in range(v.level + 1)], v.level + 1, v.level) j = v.level while v is not None: path.path[j] = get_index(word_list, v.word) v = v.parent j -= 1 return path index = get_index(word_list, v.word) for i in range(len(word_list)): if matrix[index][i] and visited[i] is False: visited[i] = True word_list[i].level = v.level + 1 word_list[i].parent = v q.enqueue(word_list[i]) return None
def parse_if_expression(self, expect_delim): self.expect_word('if') cond = self.parse_expression(False) self.expect_word('then') then_part = self.parse_expression(expect_delim) if self.at_word('else'): self.expect_word('else') else_part = self.parse_expression(expect_delim) else: else_part = ast.Literal(None) methods = [ ast.Lambda.method(then_part, data.Operation.infix('then!')), ast.Lambda.method(else_part, data.Operation.infix('else!')) ] args = [ ast.Argument(data._SUBJECT, ast.Variable(data.Identifier(-1, data.Path(["core", "if"])))), ast.Argument(data._SELECTOR, ast.Literal(Parser._SAUSAGES)), ast.Argument(data._TRANSPORT, ast.Literal(data._SYNC)), ast.Argument(0, cond), ast.Argument(1, ast.Lambda(methods)) ] result = ast.Invocation(args) return result
def as_unbound_module(self): fragments = [] for (index, fragment) in self.stages.iteritems(): fragments.append(fragment) return UnboundModule(data.Path([self.module_name]), fragments)
def get_functino_subject(self): return self.name_as_subject(data.Identifier(0, data.Path(['self'])))