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