def __init__(self, sig, child, buf):
super(TranslateMPI, self).__init__()
self.sig = sig
self.child = child
self.buf = buf
self.indent = [INDENT]
self.blocker = Blocker(self, buf)
self.parent = None
def __init__(self, **params):
pb = {'blocksize': params['block_size'],
'hashtype': params['hash_algorithm'],
'archipelago_cfile': params['archipelago_cfile'],
}
self.blocker = Blocker(**pb)
pm = {'namelen': self.blocker.hashlen,
'archipelago_cfile': params['archipelago_cfile'],
}
self.mapper = Mapper(**pm)
class Store(object):
"""Store.
Required constructor parameters: path, block_size, hash_algorithm,
umask, blockpool, mappool.
"""
def __init__(self, **params):
umask = params['umask']
if umask is not None:
os.umask(umask)
path = params['path']
if path and not os.path.exists(path):
os.makedirs(path)
if not os.path.isdir(path):
raise RuntimeError("Cannot open path '%s'" % (path, ))
p = {
'blocksize': params['block_size'],
'blockpath': os.path.join(path + '/blocks'),
'hashtype': params['hash_algorithm'],
'blockpool': params['blockpool']
}
self.blocker = Blocker(**p)
p = {
'mappath': os.path.join(path + '/maps'),
'namelen': self.blocker.hashlen,
'mappool': params['mappool']
}
self.mapper = Mapper(**p)
def map_get(self, name):
return self.mapper.map_retr(name)
def map_put(self, name, map):
self.mapper.map_stor(name, map)
def map_delete(self, name):
pass
def block_get(self, hash):
blocks = self.blocker.block_retr((hash, ))
if not blocks:
return None
return blocks[0]
def block_put(self, data):
hashes, absent = self.blocker.block_stor((data, ))
return hashes[0]
def block_update(self, hash, offset, data):
h, e = self.blocker.block_delta(hash, offset, data)
return h
def block_search(self, map):
return self.blocker.block_ping(map)
class Store(object):
"""Store.
Required constructor parameters: path, block_size, hash_algorithm,
blockpool, mappool.
"""
def __init__(self, **params):
pb = {'blocksize': params['block_size'],
'hashtype': params['hash_algorithm'],
'archipelago_cfile': params['archipelago_cfile'],
}
self.blocker = Blocker(**pb)
pm = {'namelen': self.blocker.hashlen,
'hashtype': params['hash_algorithm'],
'archipelago_cfile': params['archipelago_cfile'],
}
self.mapper = Mapper(**pm)
def map_get(self, name, size):
return self.mapper.map_retr(name, size)
def map_put(self, name, map, size, block_size):
self.mapper.map_stor(name, map, size, block_size)
def map_delete(self, name):
pass
def map_copy(self, dst, src, size):
self.mapper.map_copy(dst, src, size)
def block_get(self, hash):
blocks = self.blocker.block_retr((hash,))
if not blocks:
return None
return blocks[0]
def block_get_archipelago(self, hash):
blocks = self.blocker.block_retr_archipelago((hash,))
if not blocks:
return None
return blocks[0]
def block_put(self, data):
hashes, absent = self.blocker.block_stor((data,))
return hashes[0]
def block_update(self, hash, offset, data):
h, e = self.blocker.block_delta(hash, offset, data)
return h
def block_search(self, map):
return self.blocker.block_ping(map)
class Store(object):
"""Store.
Required constructor parameters: path, block_size, hash_algorithm,
umask, blockpool, mappool.
"""
def __init__(self, **params):
umask = params['umask']
if umask is not None:
os.umask(umask)
path = params['path']
if path and not os.path.exists(path):
os.makedirs(path)
if not os.path.isdir(path):
raise RuntimeError("Cannot open path '%s'" % (path,))
p = {'blocksize': params['block_size'],
'blockpath': os.path.join(path + '/blocks'),
'hashtype': params['hash_algorithm'],
'blockpool': params['blockpool']}
self.blocker = Blocker(**p)
p = {'mappath': os.path.join(path + '/maps'),
'namelen': self.blocker.hashlen,
'mappool': params['mappool']}
self.mapper = Mapper(**p)
def map_get(self, name):
return self.mapper.map_retr(name)
def map_put(self, name, map):
self.mapper.map_stor(name, map)
def map_delete(self, name):
pass
def block_get(self, hash):
blocks = self.blocker.block_retr((hash,))
if not blocks:
return None
return blocks[0]
def block_put(self, data):
hashes, absent = self.blocker.block_stor((data,))
return hashes[0]
def block_update(self, hash, offset, data):
h, e = self.blocker.block_delta(hash, offset, data)
return h
def block_search(self, map):
return self.blocker.block_ping(map)
class Store(object):
"""Store.
Required constructor parameters: block_size, hash_algorithm,
archipelago_cfile, namelen
"""
def __init__(self, **params):
pb = {
'blocksize': params['block_size'],
'hashtype': params['hash_algorithm'],
'archipelago_cfile': params['archipelago_cfile'],
}
self.blocker = Blocker(**pb)
pm = {
'namelen': self.blocker.hashlen,
'archipelago_cfile': params['archipelago_cfile'],
}
self.mapper = Mapper(**pm)
def map_get(self, name, size):
return self.mapper.map_retr(name, size)
def map_put(self, name, map, size, block_size):
self.mapper.map_stor(name, map, size, block_size)
def map_delete(self, name):
pass
def block_get(self, hash):
blocks = self.blocker.block_retr((hash, ))
if not blocks:
return None
return blocks[0]
def block_get_archipelago(self, hash):
blocks = self.blocker.block_retr_archipelago((hash, ))
if not blocks:
return None
return blocks[0]
def block_put(self, data):
hashes, absent = self.blocker.block_stor((data, ))
return hashes[0]
def block_update(self, hash, offset, data):
h, e = self.blocker.block_delta(hash, offset, data)
return h
def block_search(self, map):
return self.blocker.block_ping(map)
def __init__(self, sig, child, buf): super(TranslateMPI, self).__init__() self.sig = sig self.child = child self.buf = buf self.indent = [INDENT] self.blocker = Blocker(self, buf) self.parent = None
def _add_features(self):
# TODO: factor this out into feature generator
for room in self._layout.rooms:
feature = random.choice([None, 'light', 'fountain', 'library'])
if feature == 'light':
coords = random.sample([
(room.x + 1, room.y + 1),
(room.x + room.grid.size_x - 2, room.y + 1),
(room.x + 1, room.y + room.grid.size_y - 2),
(room.x + room.grid.size_x - 2,
room.y + room.grid.size_y - 2),
], random.randint(1, 4))
for x, y in coords:
self.add_entity(
Entity(Renderable(light_anim, memorable=True),
Blocker(blocks_movement=True),
Description('Light'),
Position(x, y, Position.ORDER_FEATURES)))
elif feature == 'fountain':
self.add_entity(
Entity(
Renderable(fountain_anim, memorable=True),
Blocker(blocks_movement=True), Description('Fountain'),
Position(room.x + room.grid.size_x / 2,
room.y + room.grid.size_y / 2,
Position.ORDER_FEATURES)))
elif feature == 'library':
y = room.y + room.grid.size_y - 1
for x in xrange(room.x + 1, room.x + room.grid.size_x - 1):
if self._layout.grid[x, y] != LayoutGenerator.TILE_WALL:
continue
if x == room.x + 1 and self._layout.grid[
room.x, y - 1] != LayoutGenerator.TILE_WALL:
continue
if x == room.x + room.grid.size_x - 2 and self._layout.grid[
x + 1, y - 1] != LayoutGenerator.TILE_WALL:
continue
self.add_entity(
Entity(
Renderable(random.choice(library_texes),
memorable=True),
Blocker(blocks_movement=True),
Description('Bookshelf'),
Position(x, y - 1, Position.ORDER_FEATURES)))
def make_blockers(self, number):
blockerGroup = pygame.sprite.Group()
for row in range(4):
for column in range(9):
blocker = Blocker(10, sett.GREEN, row, column)
blocker.rect.x = 50 + (200 * number) + (column * blocker.width)
blocker.rect.y = sett.BLOCKERS_POSITION + (row *
blocker.height)
blockerGroup.add(blocker)
return blockerGroup
def create_barriers(ai_settings, screen, barriers):
for number in range(4):
for row in range(5):
for column in range(12):
blocker = Blocker(screen, 10, ai_settings.barrier_color, row,
column)
blocker.rect.x = 250 + (200 * number) + (column *
blocker.width)
blocker.rect.y = ai_settings.barrier_height + (row *
blocker.height)
barriers.add(blocker)
def compile_script(script):
first_tokenizer = FirstTokenizer(script)
OpFinder(first_tokenizer.tokens)
blocker = Blocker(first_tokenizer.tokens)
line_blocker = LineBlocker(blocker.block)
FncFinder(line_blocker.output_block.tokens)
shunter = Shunter(line_blocker.output_block)
GoToIfyer(shunter.output_block)
return shunter.output_block
def create_player(x, y):
return Entity(
Player(),
Position(x, y, Position.ORDER_PLAYER),
Actor(100, player_act),
FOV(10),
Movement(),
Renderable(player_tex),
Blocker(blocks_movement=True),
Health(100),
Fighter(1, 0),
Inventory(),
)
def create_random_monster(x, y):
name, tex = get_random_monster_params()
monster = Entity(
Actor(80, monster_act),
Position(x, y, Position.ORDER_CREATURES),
Movement(),
Renderable(tex),
Blocker(blocks_movement=True, bump_function=monster_bump),
Health(2),
Fighter(1, 0),
CorpseGenerator(),
InFOV(),
Description(name),
)
return monster
def __init__(self, **params):
umask = params['umask']
if umask is not None:
os.umask(umask)
path = params['path']
if path and not os.path.exists(path):
os.makedirs(path)
if not os.path.isdir(path):
raise RuntimeError("Cannot open path '%s'" % (path, ))
p = {
'blocksize': params['block_size'],
'blockpath': os.path.join(path + '/blocks'),
'hashtype': params['hash_algorithm'],
'blockpool': params['blockpool']
}
self.blocker = Blocker(**p)
p = {
'mappath': os.path.join(path + '/maps'),
'namelen': self.blocker.hashlen,
'mappool': params['mappool']
}
self.mapper = Mapper(**p)
class Store(object):
"""Store.
Required constructor parameters: path, block_size, hash_algorithm,
umask, blockpool, mappool.
"""
def __init__(self, **params):
(pb, pm) = bootstrap_backend_storage(**params)
self.blocker = Blocker(**pb)
self.mapper = Mapper(**pm)
def map_get(self, name):
return self.mapper.map_retr(name)
def map_put(self, name, map):
self.mapper.map_stor(name, map)
def map_delete(self, name):
pass
def block_get(self, hash):
blocks = self.blocker.block_retr((hash,))
if not blocks:
return None
return blocks[0]
def block_put(self, data):
hashes, absent = self.blocker.block_stor((data,))
return hashes[0]
def block_update(self, hash, offset, data):
h, e = self.blocker.block_delta(hash, offset, data)
return h
def block_search(self, map):
return self.blocker.block_ping(map)
def __init__(self, **params):
umask = params['umask']
if umask is not None:
os.umask(umask)
path = params['path']
if path and not os.path.exists(path):
os.makedirs(path)
if not os.path.isdir(path):
raise RuntimeError("Cannot open path '%s'" % (path,))
p = {'blocksize': params['block_size'],
'blockpath': os.path.join(path + '/blocks'),
'hashtype': params['hash_algorithm'],
'blockpool': params['blockpool']}
self.blocker = Blocker(**p)
p = {'mappath': os.path.join(path + '/maps'),
'namelen': self.blocker.hashlen,
'mappool': params['mappool']}
self.mapper = Mapper(**p)
def _process_layout(self):
grid = self._layout.grid
for x in xrange(grid.size_x):
for y in xrange(grid.size_y):
tile = grid[x, y]
if tile in (LayoutGenerator.TILE_DOOR_CLOSED,
LayoutGenerator.TILE_DOOR_OPEN):
self.add_entity(
create_door(x, y,
tile == LayoutGenerator.TILE_DOOR_OPEN))
self.add_entity(
Entity(Description('Floor'), LayoutRenderable(tile),
Position(x, y)))
elif tile == LayoutGenerator.TILE_WALL:
self.add_entity(
Entity(Description('Wall'), Blocker(True, True),
LayoutRenderable(tile),
Position(x, y, Position.ORDER_WALLS)))
elif tile == LayoutGenerator.TILE_FLOOR:
self.add_entity(
Entity(Description('Floor'), LayoutRenderable(tile),
Position(x, y)))
class TranslateXS1(NodeWalker):
"""
A walker class to pretty-print the AST in the langauge syntax.
"""
def __init__(self, sig, child, buf):
super(TranslateXS1, self).__init__()
self.sig = sig
self.child = child
self.buf = buf
self.indent = [INDENT]
self.blocker = Blocker(self, buf)
self.label_counter = 0
self.parent = None
def out(self, s):
"""
Write an indented line.
"""
self.blocker.insert(s)
def asm(self, template, outop=None, inops=None, clobber=None):
"""
Write an inline assembly statement.
"""
self.out('asm volatile("{}"{}{}{}{}{}{});'.format(
#template.replace('\n', ' ; '),
template,
':' if outop or inops or clobber else '',
'"=r"(' + outop + ')' if outop else '',
':' if inops or clobber else '',
', '.join(['"r"(' + x + ')' for x in inops]) if inops else '',
':' if clobber else '',
', '.join(['"' + x + '"' for x in clobber]) if clobber else ''))
def comment(self, s):
"""
Write a comment.
"""
self.out('// ' + s)
def stmt_block(self, stmt, chans):
"""
Decide whether the statement needs a block.
"""
if not (isinstance(stmt, ast.StmtSeq)
or isinstance(stmt, ast.StmtPar)):
self.blocker.begin()
self.stmt(stmt, chans)
self.blocker.end()
else:
self.stmt(stmt, chans)
def procedure_name(self, name):
"""
If a procedure name has a conversion, return it.
"""
return builtin_conversion[name] if name in builtin_conversion else name
def arguments(self, args):
"""
Build the list of arguments for a procedure call. If there is an array
reference proper, either directly or as a slice, it must be loaded
manually with an assembly inline which forces the compiler to reveal the
address.
"""
new = []
for x in args:
arg = None
# Single-element expressions
if isinstance(x, ast.ExprSingle):
# Whole arrays
if isinstance(x.elem, ast.ElemId):
if x.elem.symbol.type == T_VAR_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('mov %0, %1', outop=tmp, inops=[x.elem.name])
arg = tmp
# Array slices: either create or use a reference
elif isinstance(x.elem, ast.ElemSlice):
if x.elem.symbol.type == T_VAR_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('add %0, %1, %2',
outop=tmp,
inops=[
x.elem.name,
'({})*{}'.format(self.expr(x.elem.base),
defs.BYTES_PER_WORD)
])
arg = tmp
elif x.elem.symbol.type == T_REF_ARRAY:
arg = '{}+(({})*{})'.format(x.elem.name,
self.expr(x.elem.base),
defs.BYTES_PER_WORD)
new.append(self.expr(x) if not arg else arg)
return ', '.join(new)
def get_label(self):
"""
Get the next unique label.
"""
l = '_L{}'.format(self.label_counter)
self.label_counter += 1
return l
def header(self):
self.out('#include <xs1.h>')
self.out('#include <print.h>')
self.out('#include <syscall.h>')
self.out('#include "device.h"')
self.out('#include "system/definitions.h"')
self.out('#include "system/xs1/definitions.h"')
self.out('#include "runtime/xs1/globals.h"')
self.out('#include "runtime/xs1/source.h"')
self.out('#include "runtime/xs1/connect.h"')
self.out('#include "runtime/xs1/pointer.h"')
self.out('#include "runtime/xs1/system.h"')
self.out('#include "runtime/xs1/util.h"')
self.out('')
def jumptable(self, names):
self.out('/*')
self.out(' * Jump table')
self.out(' * ==========')
self.out(' *')
[self.out(' * cp[{}] {}'.format(i, x)) for (i, x) in enumerate(names)]
self.out('*/\n')
def builtins(self):
"""
Insert builtin code. We include builtin code directly here so that it
can be transformed in the build process to be made 'mobile'. This is in
contrast with the MPI implementation where there is only a single
binary.
"""
self.out(read_file(config.XS1_SYSTEM_PATH + '/builtins_fixedpoint.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH + '/builtins_printing.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH + '/builtins_fileio.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH + '/builtins_comm.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH + '/builtins_remotemem.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH + '/builtins_system.xc'))
# Program ============================================
def walk_program(self, node):
# List of names for the jump table
names = builtin.runtime_functions + self.sig.mobile_proc_names
# Walk the entire program
self.header()
self.jumptable(names)
self.builtins()
# Declarations
[self.out(self.decl(x, {})) for x in node.decls]
if len(node.decls) > 0:
self.out('')
# Prototypes and definitions
[self.prototype(p) for p in node.defs]
self.out('')
[self.definition(p, names) for p in node.defs]
# Output the buffered blocks
self.blocker.output()
# Variable declarations ===============================
def var_decl(self, node, chans):
if node.type == T_VAR_ARRAY:
return 'int {}[{}];'.format(node.name, self.expr(node.expr))
elif node.type == T_REF_ARRAY:
return 'unsigned ' + node.name + ';'
elif node.type == T_VAR_SINGLE:
return 'int ' + node.name + ';'
elif node.type == T_VAL_SINGLE:
return '#define {} ({})'.format(node.name, self.expr(node.expr))
elif node.type == T_CHANEND_SINGLE:
chans[node.name] = defs.CONNECT_MASTER
return 'unsigned ' + node.name + ';'
elif node.type == T_CHANEND_SERVER_SINGLE:
chans[node.name] = defs.CONNECT_SERVER
return 'unsigned ' + node.name + ';'
elif node.type == T_CHANEND_CLIENT_SINGLE:
chans[node.name] = defs.CONNECT_CLIENT
return 'unsigned ' + node.name + ';'
else:
print(node.type)
print(node.name)
assert 0
# Procedure definitions ===============================
def prototype(self, node):
s = ''
s += 'void' if node.type == T_PROC else 'int'
s += ' {}({});'.format(
self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]))
self.out(s)
def definition(self, node, names):
self.out('// cp[{}]'.format(names.index(node.name)))
self.out('#pragma unsafe arrays')
s = 'void' if node.type == T_PROC else 'int'
s += ' {}({}){}'.format(
self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]),
';' if not node.stmt else '')
self.parent = node.name
self.out(s)
if node.stmt:
chans = {}
self.blocker.begin()
self.stmt_block(node.stmt, chans)
self.blocker.end()
self.out('')
# Formals =============================================
def param(self, node):
if node.type == T_VAL_SINGLE:
return 'int ' + node.name
elif node.type == T_REF_SINGLE:
return 'int &' + node.name
elif node.type == T_REF_ARRAY:
return 'unsigned ' + node.name
elif node.type == T_CHANEND_SINGLE:
return 'unsigned &' + node.name
elif node.type == T_CHANEND_SERVER_SINGLE:
return 'unsigned &' + node.name
elif node.type == T_CHANEND_CLIENT_SINGLE:
return 'unsigned &' + node.name
else:
assert 0
# Statements ==========================================
# These output themselves and pass a map of chanend names to connection
# type (master, slave, server or client). This map is updated by connect
# statements which determine the type. This map is used by input and output
# statments to choose the correct operation.
def stmt_seq(self, node, chans):
self.blocker.begin()
[self.out(self.decl(x, chans)) for x in node.decls]
for x in node.children():
self.stmt(x, chans)
self.blocker.end()
def stmt_par(self, node, chans):
self.blocker.begin()
[self.out(self.decl(x, chans)) for x in node.decls]
gen_par(self, node, chans)
self.blocker.end()
def stmt_ass(self, node, chans):
# If the target is an array reference, then generate a store after
if node.left.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.out('{} = {};'.format(tmp, self.expr(node.expr)))
self.asm('stw %0, %1[%2]',
inops=[tmp, node.left.name,
self.expr(node.left.expr)])
# Otherwise, proceede normally
else:
self.out('{} = {};'.format(self.elem(node.left),
self.expr(node.expr)))
def stmt_out(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_OUTS({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_OUTS({}, {});'.format(left, expr))
else:
self.out('OUTS({}, {});'.format(left, expr))
def stmt_in(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_INS({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_INS({}, {});'.format(left, expr))
else:
self.out('INS({}, {});'.format(left, expr))
def stmt_out_tag(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_OUT_TAG({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_OUT_TAG({}, {});'.format(left, expr))
else:
self.out('OUT({}, {});'.format(left, expr))
def stmt_in_tag(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_IN_TAG({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_IN_TAG({}, {});'.format(left, expr))
else:
self.out('IN({}, {});'.format(left, expr))
def stmt_alias(self, node, chans):
"""
Generate an alias statement. If the slice target is an array we must use
some inline assembly to get xcc to load the address for us. Otherwise,
we can just perform arithmetic on the pointer.
"""
if node.slice.symbol.type == T_VAR_ARRAY:
self.asm('add %0, %1, %2',
outop=node.left.name,
inops=[
node.slice.name,
'({})*{}'.format(self.expr(node.slice.base),
defs.BYTES_PER_WORD)
])
elif node.slice.symbol.type == T_REF_ARRAY:
self.out('{} = {} + ({})*{};'.format(self.elem(node.left),
node.slice.name,
self.expr(node.slice.base),
defs.BYTES_PER_WORD))
def stmt_connect(self, node, chans):
if node.type == defs.CONNECT_MASTER:
self.out('{} = {}({}, {});'.format(self.elem(node.left),
defs.LABEL_CONNECT_MASTER,
self.expr(node.id),
self.expr(node.expr)))
elif node.type == defs.CONNECT_SLAVE:
self.out('{} = {}({}, {});'.format(self.elem(node.left),
defs.LABEL_CONNECT_SLAVE,
self.expr(node.id),
self.expr(node.expr)))
elif node.type == defs.CONNECT_SERVER:
self.out('{} = {}({});'.format(self.elem(node.left),
defs.LABEL_CONNECT_SERVER,
self.expr(node.id)))
elif node.type == defs.CONNECT_CLIENT:
self.out('{} = {}({}, {});'.format(self.elem(node.left),
defs.LABEL_CONNECT_CLIENT,
self.expr(node.id),
self.expr(node.expr)))
else:
assert 0
def stmt_if(self, node, chans):
self.out('if ({})'.format(self.expr(node.cond)))
self.stmt_block(node.thenstmt, chans)
if not isinstance(node.elsestmt, ast.StmtSkip):
self.out('else')
self.stmt_block(node.elsestmt, chans)
def stmt_while(self, node, chans):
self.out('while ({})'.format(self.expr(node.cond)))
self.stmt_block(node.stmt, chans)
def stmt_for(self, node, chans):
self.out('for ({0} = {1}; {0} < ({1}+{2}); {0}++)'.format(
node.index.name, self.expr(node.index.base),
self.expr(node.index.count)))
self.stmt_block(node.stmt, chans)
def stmt_on(self, node, chans):
gen_on(self, node, chans)
def stmt_pcall(self, node, chans):
self.out('{}({});'.format(self.procedure_name(node.name),
self.arguments(node.args)))
def stmt_assert(self, node, chans):
self.out('ASSERT({});'.format(self.expr(node.expr)))
def stmt_return(self, node, chans):
self.out('return {};'.format(self.expr(node.expr)))
def stmt_skip(self, node, chans):
pass
# Statements that have been reduced to a canonical form
def stmt_server(self, node, chans):
assert 0
def stmt_rep(self, node, chans):
assert 0
# Expressions =========================================
# Return their string representation
def expr_single(self, node):
# If the elem is an array reference subscript, generate a load
if isinstance(node.elem, ast.ElemSub):
if node.elem.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('ldw %0, %1[%2]',
outop=tmp,
inops=[node.elem.name,
self.expr(node.elem.expr)])
return tmp
# Otherwise, just return the regular syntax
return self.elem(node.elem)
def expr_unary(self, node):
# If the elem is an array reference subscript, generate a load
if isinstance(node.elem, ast.ElemSub):
if node.elem.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('ldw %0, %1[%2]',
outop=tmp,
inops=[node.elem.name,
self.expr(node.elem.expr)])
return '({}{})'.format(op_conversion[node.op], tmp)
else:
return '({}{})'.format(op_conversion[node.op],
self.elem(node.elem))
# Otherwise, just return the regular syntax
else:
return '({}{})'.format(op_conversion[node.op],
self.elem(node.elem))
def expr_binop(self, node):
# If the elem is an array reference subscript, generate a load
if isinstance(node.elem, ast.ElemSub):
if node.elem.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('ldw %0, %1[%2]',
outop=tmp,
inops=[node.elem.name,
self.expr(node.elem.expr)])
return '{} {} {}'.format(tmp, op_conversion[node.op],
self.expr(node.right))
else:
return '{} {} {}'.format(self.elem(node.elem),
op_conversion[node.op],
self.expr(node.right))
# Otherwise, just return the regular syntax
return '{} {} {}'.format(self.elem(node.elem), op_conversion[node.op],
self.expr(node.right))
# Elements ============================================
# Return their string representation
def elem_group(self, node):
return '({})'.format(self.expr(node.expr))
def elem_sub(self, node):
return '{}[{}]'.format(node.name, self.expr(node.expr))
def elem_slice(self, node):
# If source is an array take the address, if reference then just the value
address = '' + node.name
if node.symbol.type == T_VAR_ARRAY:
address = '(unsigned, ' + address + ')'
return '({} + ({})*{})'.format(address, self.expr(node.base),
defs.BYTES_PER_WORD)
def elem_fcall(self, node):
return '{}({})'.format(self.procedure_name(node.name),
self.arguments(node.args))
def elem_number(self, node):
return '{}'.format(node.value)
def elem_boolean(self, node):
return '{}'.format(node.value.upper())
def elem_string(self, node):
return '{}'.format(node.value)
def elem_char(self, node):
return '{}'.format(node.value)
def elem_id(self, node):
return node.name
class TranslateMPI(NodeWalker):
"""
A walker class to pretty-print the AST in the langauge syntax.
"""
def __init__(self, sig, child, buf):
super(TranslateMPI, self).__init__()
self.sig = sig
self.child = child
self.buf = buf
self.indent = [INDENT]
self.blocker = Blocker(self, buf)
self.parent = None
def out(self, s):
"""
Write an indented line.
"""
self.blocker.insert(s)
def comment(self, s):
"""
Write a comment.
"""
self.out('// '+s)
def stmt_block(self, stmt):
"""
Decide whether the statement needs a block.
"""
if not (isinstance(stmt, ast.StmtSeq)
or isinstance(stmt, ast.StmtPar)):
self.blocker.begin()
self.stmt(stmt)
self.blocker.end()
else:
self.stmt(stmt)
def procedure_name(self, name):
"""
If a procedure name has a conversion, return it.
"""
return builtin_conversion[name] if name in builtin_conversion else name
def arguments(self, name, args):
"""
Build the list of arguments.
- Take the address of variables for reference parameters.
- Don't dereference references for reference parameters.
- Take the address of array elements whether var or ref.
"""
new = []
for (i, x) in enumerate(args):
arg = None
t = self.sig.lookup_param_type(name, i)
if t == T_REF_SINGLE:
assert isinstance(x, ast.ExprSingle)
# For single variables, take the address if they are not ref
if isinstance(x.elem, ast.ElemId):
if x.elem.symbol.type == T_VAR_SINGLE:
arg = '&'+x.elem.name
elif x.elem.symbol.type == T_REF_SINGLE:
arg = x.elem.name
# For subscripts, take their address
elif isinstance(x.elem, ast.ElemSub):
if x.elem.symbol.type == T_VAR_ARRAY:
arg = '&{}'.format(self.elem(x))
elif x.elem.symbol.type == T_REF_ARRAY:
arg = '&{}'.format(self.elem(x))
else:
assert 0
new.append(arg if arg else self.expr(x))
return ', '.join(new)
def header(self):
"""
Insert inclusions.
"""
self.out('#include <mpi.h>')
#self.out('#include <stdlib.h>')
self.out('#include <stdio.h>')
self.out('#include <syscall.h>')
self.out('#include "device.h"')
self.out('#include "runtime/mpi/system.h"')
self.out('#include "runtime/mpi/source.h"')
self.out('#include "system/definitions.h"')
self.out('#include "system/mpi/definitions.h"')
self.out('#include "system/mpi/builtins.h"')
self.out('')
def create_main(self):
self.out(MAIN_FUNCTION)
# Program ============================================
def walk_program(self, node):
# Walk the entire program
self.header()
# Declarations
[self.out(self.decl(x)) for x in node.decls]
if len(node.decls) > 0:
self.out('')
# Definitions
[self.prototype(p) for p in node.defs]
self.out('')
[self.definition(p) for p in node.defs]
# Output the buffered blocks
self.blocker.output()
# Variable declarations ===============================
def decl(self, node):
if node.type == T_VAR_ARRAY:
return 'int {}[{}];'.format(node.name, self.expr(node.expr))
elif node.type == T_REF_ARRAY:
return 'int *'+node.name+';'
elif node.type == T_VAR_SINGLE:
return 'int '+node.name+';'
elif node.type == T_VAL_SINGLE:
return '#define '+node.name+' {}'.format(self.expr(node.expr))
elif node.type == T_CHANEND_SINGLE:
return 'chanend'
elif node.type == T_CHAN_SINGLE:
return 'chan'
elif node.type == T_CHAN_ARRAY:
return 'chanarray'
else:
assert 0
# Procedure declarations ==============================
def prototype(self, node):
s = ''
s += 'void' if node.type == T_PROC else 'int'
s += ' {}({});'.format(self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]))
self.out(s)
def definition(self, node):
s = ''
s += 'void' if node.type == T_PROC else 'int'
s += ' {}({}){}'.format(self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]),
';' if not node.stmt else '')
self.parent = node.name
self.out(s)
if node.stmt:
self.blocker.begin()
[self.out(self.decl(x)) for x in node.decls]
self.stmt_block(node.stmt)
self.blocker.end()
self.out('')
# Formals =============================================
def param(self, node):
if node.type == T_VAL_SINGLE:
return 'int '+node.name
elif node.type == T_REF_SINGLE:
return 'int *'+node.name
elif node.type == T_REF_ARRAY:
return 'int '+node.name+'[]'
elif node.type == T_CHANEND_SINGLE:
return 'unsigned '+node.name
else:
assert 0
# Statements ==========================================
def stmt_seq(self, node):
self.blocker.begin()
for x in node.children():
self.stmt(x)
self.blocker.end()
def stmt_par(self, node):
"""
Generate a parallel block.
"""
self.blocker.begin()
self.comment('Parallel block')
for (i, x) in enumerate(node.children()):
self.comment('Thread {}'.format(i))
self.stmt(x)
self.blocker.end()
def stmt_skip(self, node):
pass
def stmt_pcall(self, node):
self.out('{}({});'.format(
self.procedure_name(node.name),
self.arguments(node.name, node.args)))
def stmt_ass(self, node):
self.out('{} = {};'.format(
self.elem(node.left), self.expr(node.expr)))
def stmt_in(self, node):
self.out('{} ? {};'.format(
self.elem(node.left), self.expr(node.expr)))
def stmt_out(self, node):
self.out('{} ! {};'.format(
self.elem(node.left), self.expr(node.expr)))
def stmt_alias(self, node):
self.out('{} = {};'.format(
self.elem(node.left), self.elem(node.slice)))
def stmt_connect(self, node):
if node.core:
self.out('connect master')
else:
self.out('connect slave')
def stmt_if(self, node):
self.out('if ({})'.format(self.expr(node.cond)))
self.stmt_block(node.thenstmt)
if not isinstance(node.elsestmt, ast.StmtSkip):
self.out('else')
self.stmt_block(node.elsestmt)
def stmt_while(self, node):
self.out('while ({})'.format(self.expr(node.cond)))
self.stmt_block(node.stmt)
def stmt_for(self, node):
self.out('for ({0} = {1}; {0} < ({1}+{2}); {0}++)'.format(
node.index.name, self.expr(node.index.base),
self.expr(node.index.count)))
self.stmt_block(node.stmt)
def stmt_rep(self, node):
pass
def stmt_on(self, node):
"""
Generate an on statement.
"""
self.out('on statement')
def stmt_return(self, node):
self.out('return {};'.format(self.expr(node.expr)))
# Expressions =========================================
def expr_single(self, node):
return self.elem(node.elem)
def expr_unary(self, node):
return '({}{})'.format(
op_conversion[node.op], self.elem(node.elem))
def expr_binop(self, node):
return '{} {} {}'.format(self.elem(node.elem),
op_conversion[node.op], self.expr(node.right))
# Elements= ===========================================
def elem_group(self, node):
return '({})'.format(self.expr(node.expr))
def elem_sub(self, node):
return '{}[{}]'.format(node.name, self.expr(node.expr))
def elem_slice(self, node):
# If source is an array take the address, if a reference then just the value
address = ''+node.name
if node.symbol.type == T_VAR_ARRAY:
address = '&'+address
return '({} + {})'.format(address, self.expr(node.base))
def elem_fcall(self, node):
return '{}({})'.format(self.procedure_name(node.name),
self.arguments(node.name, node.args))
def elem_number(self, node):
return '{}'.format(node.value)
def elem_boolean(self, node):
return '{}'.format(node.value.upper())
def elem_string(self, node):
return '{}'.format(node.value)
def elem_char(self, node):
return '{}'.format(node.value)
def elem_id(self, node):
#print('{} {}'.format(node.symbol.type, node.name))
if node.symbol.type == T_REF_SINGLE:
return '*'+node.name
else:
return node.name
class TranslateMPI(NodeWalker):
"""
A walker class to pretty-print the AST in the langauge syntax.
"""
def __init__(self, sig, child, buf):
super(TranslateMPI, self).__init__()
self.sig = sig
self.child = child
self.buf = buf
self.indent = [INDENT]
self.blocker = Blocker(self, buf)
self.parent = None
def out(self, s):
"""
Write an indented line.
"""
self.blocker.insert(s)
def comment(self, s):
"""
Write a comment.
"""
self.out('// ' + s)
def stmt_block(self, stmt):
"""
Decide whether the statement needs a block.
"""
if not (isinstance(stmt, ast.StmtSeq)
or isinstance(stmt, ast.StmtPar)):
self.blocker.begin()
self.stmt(stmt)
self.blocker.end()
else:
self.stmt(stmt)
def procedure_name(self, name):
"""
If a procedure name has a conversion, return it.
"""
return builtin_conversion[name] if name in builtin_conversion else name
def arguments(self, name, args):
"""
Build the list of arguments.
- Take the address of variables for reference parameters.
- Don't dereference references for reference parameters.
- Take the address of array elements whether var or ref.
"""
new = []
for (i, x) in enumerate(args):
arg = None
t = self.sig.lookup_param_type(name, i)
if t == T_REF_SINGLE:
assert isinstance(x, ast.ExprSingle)
# For single variables, take the address if they are not ref
if isinstance(x.elem, ast.ElemId):
if x.elem.symbol.type == T_VAR_SINGLE:
arg = '&' + x.elem.name
elif x.elem.symbol.type == T_REF_SINGLE:
arg = x.elem.name
# For subscripts, take their address
elif isinstance(x.elem, ast.ElemSub):
if x.elem.symbol.type == T_VAR_ARRAY:
arg = '&{}'.format(self.elem(x))
elif x.elem.symbol.type == T_REF_ARRAY:
arg = '&{}'.format(self.elem(x))
else:
assert 0
new.append(arg if arg else self.expr(x))
return ', '.join(new)
def header(self):
"""
Insert inclusions.
"""
self.out('#include <mpi.h>')
#self.out('#include <stdlib.h>')
self.out('#include <stdio.h>')
self.out('#include <syscall.h>')
self.out('#include "device.h"')
self.out('#include "runtime/mpi/system.h"')
self.out('#include "runtime/mpi/source.h"')
self.out('#include "system/definitions.h"')
self.out('#include "system/mpi/definitions.h"')
self.out('#include "system/mpi/builtins.h"')
self.out('')
def create_main(self):
self.out(MAIN_FUNCTION)
# Program ============================================
def walk_program(self, node):
# Walk the entire program
self.header()
# Declarations
[self.out(self.decl(x)) for x in node.decls]
if len(node.decls) > 0:
self.out('')
# Definitions
[self.prototype(p) for p in node.defs]
self.out('')
[self.definition(p) for p in node.defs]
# Output the buffered blocks
self.blocker.output()
# Variable declarations ===============================
def decl(self, node):
if node.type == T_VAR_ARRAY:
return 'int {}[{}];'.format(node.name, self.expr(node.expr))
elif node.type == T_REF_ARRAY:
return 'int *' + node.name + ';'
elif node.type == T_VAR_SINGLE:
return 'int ' + node.name + ';'
elif node.type == T_VAL_SINGLE:
return '#define ' + node.name + ' {}'.format(self.expr(node.expr))
elif node.type == T_CHANEND_SINGLE:
return 'chanend'
elif node.type == T_CHAN_SINGLE:
return 'chan'
elif node.type == T_CHAN_ARRAY:
return 'chanarray'
else:
assert 0
# Procedure declarations ==============================
def prototype(self, node):
s = ''
s += 'void' if node.type == T_PROC else 'int'
s += ' {}({});'.format(
self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]))
self.out(s)
def definition(self, node):
s = ''
s += 'void' if node.type == T_PROC else 'int'
s += ' {}({}){}'.format(
self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]),
';' if not node.stmt else '')
self.parent = node.name
self.out(s)
if node.stmt:
self.blocker.begin()
[self.out(self.decl(x)) for x in node.decls]
self.stmt_block(node.stmt)
self.blocker.end()
self.out('')
# Formals =============================================
def param(self, node):
if node.type == T_VAL_SINGLE:
return 'int ' + node.name
elif node.type == T_REF_SINGLE:
return 'int *' + node.name
elif node.type == T_REF_ARRAY:
return 'int ' + node.name + '[]'
elif node.type == T_CHANEND_SINGLE:
return 'unsigned ' + node.name
else:
assert 0
# Statements ==========================================
def stmt_seq(self, node):
self.blocker.begin()
for x in node.children():
self.stmt(x)
self.blocker.end()
def stmt_par(self, node):
"""
Generate a parallel block.
"""
self.blocker.begin()
self.comment('Parallel block')
for (i, x) in enumerate(node.children()):
self.comment('Thread {}'.format(i))
self.stmt(x)
self.blocker.end()
def stmt_skip(self, node):
pass
def stmt_pcall(self, node):
self.out('{}({});'.format(self.procedure_name(node.name),
self.arguments(node.name, node.args)))
def stmt_ass(self, node):
self.out('{} = {};'.format(self.elem(node.left), self.expr(node.expr)))
def stmt_in(self, node):
self.out('{} ? {};'.format(self.elem(node.left), self.expr(node.expr)))
def stmt_out(self, node):
self.out('{} ! {};'.format(self.elem(node.left), self.expr(node.expr)))
def stmt_alias(self, node):
self.out('{} = {};'.format(self.elem(node.left),
self.elem(node.slice)))
def stmt_connect(self, node):
if node.core:
self.out('connect master')
else:
self.out('connect slave')
def stmt_if(self, node):
self.out('if ({})'.format(self.expr(node.cond)))
self.stmt_block(node.thenstmt)
if not isinstance(node.elsestmt, ast.StmtSkip):
self.out('else')
self.stmt_block(node.elsestmt)
def stmt_while(self, node):
self.out('while ({})'.format(self.expr(node.cond)))
self.stmt_block(node.stmt)
def stmt_for(self, node):
self.out('for ({0} = {1}; {0} < ({1}+{2}); {0}++)'.format(
node.index.name, self.expr(node.index.base),
self.expr(node.index.count)))
self.stmt_block(node.stmt)
def stmt_rep(self, node):
pass
def stmt_on(self, node):
"""
Generate an on statement.
"""
self.out('on statement')
def stmt_return(self, node):
self.out('return {};'.format(self.expr(node.expr)))
# Expressions =========================================
def expr_single(self, node):
return self.elem(node.elem)
def expr_unary(self, node):
return '({}{})'.format(op_conversion[node.op], self.elem(node.elem))
def expr_binop(self, node):
return '{} {} {}'.format(self.elem(node.elem), op_conversion[node.op],
self.expr(node.right))
# Elements= ===========================================
def elem_group(self, node):
return '({})'.format(self.expr(node.expr))
def elem_sub(self, node):
return '{}[{}]'.format(node.name, self.expr(node.expr))
def elem_slice(self, node):
# If source is an array take the address, if a reference then just the value
address = '' + node.name
if node.symbol.type == T_VAR_ARRAY:
address = '&' + address
return '({} + {})'.format(address, self.expr(node.base))
def elem_fcall(self, node):
return '{}({})'.format(self.procedure_name(node.name),
self.arguments(node.name, node.args))
def elem_number(self, node):
return '{}'.format(node.value)
def elem_boolean(self, node):
return '{}'.format(node.value.upper())
def elem_string(self, node):
return '{}'.format(node.value)
def elem_char(self, node):
return '{}'.format(node.value)
def elem_id(self, node):
#print('{} {}'.format(node.symbol.type, node.name))
if node.symbol.type == T_REF_SINGLE:
return '*' + node.name
else:
return node.name
def runGame(display):
code = getInputData()
IC = IntcodeComputer(code)
# game = PILScreen()
if display:
game = Blocker(841, 600)
count = 0
paddlePos = 0
# Set memory position 0 to 2, to play for free
# IC.writeMem(0,2)
##################
step = 0
inp = [] #input??
IC._output = [] # Clear the output list
terminate = False
stoppedAtInput = False
HiScore = 0
while not terminate:
length = 0
while length < 3 and not terminate:
terminate, stoppedAtInput = IC.perform_one_operation(
input=inp, stopAtInput=True)
length = len(IC._output)
# print(f'OutPut: {IC._output}')
# print(f'Terminate: {terminate}')
# print(f'stoppedAtInput: {stoppedAtInput}')
# print(f'count: {count}')
# print(f'Next instr: {IC._intCodeProgramDict[IC._memoryPosition]}')
# print(f'Next memPos:{IC._memoryPosition}')
if terminate: break
try:
x = IC._output[0]
y = IC._output[1]
t = IC._output[2]
IC._output = []
except Exception:
print('EXCEPTION')
break
#game.show()
######## TILES
#
# 0 is an empty tile. No game object appears in this tile.
# 1 is a wall tile. Walls are indestructible barriers.
# 2 is a block tile. Blocks can be broken by the ball.
# 3 is a horizontal paddle tile. The paddle is indestructible.
# 4 is a ball tile. The ball moves diagonally and bounces off objects.
if t == 3:
paddlePos = x
if t == 4:
if paddlePos < x: inp = [1]
elif paddlePos > x: inp = [-1]
else: inp = [0]
if x == -1 and y == 0: # -1, 0, t gives SCORE
if t > HiScore: HiScore = t
if display: game.draw_text(str(HiScore))
else:
if t == 2: count += 1
#if t != 0:
if display: game.drawBrick(x, y, t)
if display: game.screen_update()
return count, HiScore
import os
from blocker import Blocker
if __name__ == '__main__':
blockbot = Blocker()
blockbot.run()
#!/usr/bin/env python
import time
import schedule
from blocker import Blocker
from config import SitesAvailabilityConfig
from hosts import HostsFileFacade
SCHEDULER_TICK_INTERVAL_IN_SEC = 30
hosts_file_facade = HostsFileFacade()
config = SitesAvailabilityConfig()
blocker = Blocker(hosts_file_facade, config)
def main():
configure_scheduler()
do_infinite_schedule_loop()
def configure_scheduler():
schedule.every(1).minutes.do(update_state)
def do_infinite_schedule_loop():
while True:
schedule.run_pending()
time.sleep(SCHEDULER_TICK_INTERVAL_IN_SEC)
def __init__(self, **params):
(pb, pm) = bootstrap_backend_storage(**params)
self.blocker = Blocker(**pb)
self.mapper = Mapper(**pm)
class TranslateXS1(NodeWalker):
"""
A walker class to pretty-print the AST in the langauge syntax.
"""
def __init__(self, sig, child, buf):
super(TranslateXS1, self).__init__()
self.sig = sig
self.child = child
self.buf = buf
self.indent = [INDENT]
self.blocker = Blocker(self, buf)
self.label_counter = 0
self.parent = None
def out(self, s):
"""
Write an indented line.
"""
self.blocker.insert(s)
def asm(self, template, outop=None, inops=None, clobber=None):
"""
Write an inline assembly statement.
"""
self.out('asm volatile("{}"{}{}{}{}{}{});'.format(
#template.replace('\n', ' ; '),
template,
':' if outop or inops or clobber else '',
'"=r"('+outop+')' if outop else '',
':' if inops or clobber else '',
', '.join(['"r"('+x+')' for x in inops]) if inops else '',
':' if clobber else '',
', '.join(['"'+x+'"' for x in clobber]) if clobber else ''
))
def comment(self, s):
"""
Write a comment.
"""
self.out('// '+s)
def stmt_block(self, stmt, chans):
"""
Decide whether the statement needs a block.
"""
if not (isinstance(stmt, ast.StmtSeq)
or isinstance(stmt, ast.StmtPar)):
self.blocker.begin()
self.stmt(stmt, chans)
self.blocker.end()
else:
self.stmt(stmt, chans)
def procedure_name(self, name):
"""
If a procedure name has a conversion, return it.
"""
return builtin_conversion[name] if name in builtin_conversion else name
def arguments(self, args):
"""
Build the list of arguments for a procedure call. If there is an array
reference proper, either directly or as a slice, it must be loaded
manually with an assembly inline which forces the compiler to reveal the
address.
"""
new = []
for x in args:
arg = None
# Single-element expressions
if isinstance(x, ast.ExprSingle):
# Whole arrays
if isinstance(x.elem, ast.ElemId):
if x.elem.symbol.type == T_VAR_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('mov %0, %1', outop=tmp,
inops=[x.elem.name])
arg = tmp
# Array slices: either create or use a reference
elif isinstance(x.elem, ast.ElemSlice):
if x.elem.symbol.type == T_VAR_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('add %0, %1, %2', outop=tmp,
inops=[x.elem.name, '({})*{}'.format(
self.expr(x.elem.base), defs.BYTES_PER_WORD)])
arg = tmp
elif x.elem.symbol.type == T_REF_ARRAY:
arg = '{}+(({})*{})'.format(
x.elem.name, self.expr(x.elem.base),
defs.BYTES_PER_WORD)
new.append(self.expr(x) if not arg else arg)
return ', '.join(new)
def get_label(self):
"""
Get the next unique label.
"""
l = '_L{}'.format(self.label_counter)
self.label_counter += 1
return l
def header(self):
self.out('#include <xs1.h>')
self.out('#include <print.h>')
self.out('#include <syscall.h>')
self.out('#include "device.h"')
self.out('#include "system/definitions.h"')
self.out('#include "system/xs1/definitions.h"')
self.out('#include "runtime/xs1/globals.h"')
self.out('#include "runtime/xs1/source.h"')
self.out('#include "runtime/xs1/connect.h"')
self.out('#include "runtime/xs1/pointer.h"')
self.out('#include "runtime/xs1/system.h"')
self.out('#include "runtime/xs1/util.h"')
self.out('')
def jumptable(self, names):
self.out('/*')
self.out(' * Jump table')
self.out(' * ==========')
self.out(' *')
[self.out(' * cp[{}] {}'.format(i, x)) for (i, x) in enumerate(names)]
self.out('*/\n')
def builtins(self):
"""
Insert builtin code. We include builtin code directly here so that it
can be transformed in the build process to be made 'mobile'. This is in
contrast with the MPI implementation where there is only a single
binary.
"""
self.out(read_file(config.XS1_SYSTEM_PATH+'/builtins_fixedpoint.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH+'/builtins_printing.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH+'/builtins_fileio.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH+'/builtins_comm.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH+'/builtins_remotemem.xc'))
self.out(read_file(config.XS1_SYSTEM_PATH+'/builtins_system.xc'))
# Program ============================================
def walk_program(self, node):
# List of names for the jump table
names = builtin.runtime_functions + self.sig.mobile_proc_names
# Walk the entire program
self.header()
self.jumptable(names)
self.builtins()
# Declarations
[self.out(self.decl(x, {})) for x in node.decls]
if len(node.decls) > 0:
self.out('')
# Prototypes and definitions
[self.prototype(p) for p in node.defs]
self.out('')
[self.definition(p, names) for p in node.defs]
# Output the buffered blocks
self.blocker.output()
# Variable declarations ===============================
def var_decl(self, node, chans):
if node.type == T_VAR_ARRAY:
return 'int {}[{}];'.format(node.name, self.expr(node.expr))
elif node.type == T_REF_ARRAY:
return 'unsigned '+node.name+';'
elif node.type == T_VAR_SINGLE:
return 'int '+node.name+';'
elif node.type == T_VAL_SINGLE:
return '#define {} ({})'.format(node.name, self.expr(node.expr))
elif node.type == T_CHANEND_SINGLE:
chans[node.name] = defs.CONNECT_MASTER
return 'unsigned '+node.name+';'
elif node.type == T_CHANEND_SERVER_SINGLE:
chans[node.name] = defs.CONNECT_SERVER
return 'unsigned '+node.name+';'
elif node.type == T_CHANEND_CLIENT_SINGLE:
chans[node.name] = defs.CONNECT_CLIENT
return 'unsigned '+node.name+';'
else:
print(node.type)
print(node.name)
assert 0
# Procedure definitions ===============================
def prototype(self, node):
s = ''
s += 'void' if node.type == T_PROC else 'int'
s += ' {}({});'.format(self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]))
self.out(s)
def definition(self, node, names):
self.out('// cp[{}]'.format(names.index(node.name)))
self.out('#pragma unsafe arrays')
s = 'void' if node.type == T_PROC else 'int'
s += ' {}({}){}'.format(self.procedure_name(node.name),
', '.join([self.param(x) for x in node.formals]),
';' if not node.stmt else '')
self.parent = node.name
self.out(s)
if node.stmt:
chans = {}
self.blocker.begin()
self.stmt_block(node.stmt, chans)
self.blocker.end()
self.out('')
# Formals =============================================
def param(self, node):
if node.type == T_VAL_SINGLE:
return 'int '+node.name
elif node.type == T_REF_SINGLE:
return 'int &'+node.name
elif node.type == T_REF_ARRAY:
return 'unsigned '+node.name
elif node.type == T_CHANEND_SINGLE:
return 'unsigned &'+node.name
elif node.type == T_CHANEND_SERVER_SINGLE:
return 'unsigned &'+node.name
elif node.type == T_CHANEND_CLIENT_SINGLE:
return 'unsigned &'+node.name
else:
assert 0
# Statements ==========================================
# These output themselves and pass a map of chanend names to connection
# type (master, slave, server or client). This map is updated by connect
# statements which determine the type. This map is used by input and output
# statments to choose the correct operation.
def stmt_seq(self, node, chans):
self.blocker.begin()
[self.out(self.decl(x, chans)) for x in node.decls]
for x in node.children():
self.stmt(x, chans)
self.blocker.end()
def stmt_par(self, node, chans):
self.blocker.begin()
[self.out(self.decl(x, chans)) for x in node.decls]
gen_par(self, node, chans)
self.blocker.end()
def stmt_ass(self, node, chans):
# If the target is an array reference, then generate a store after
if node.left.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.out('{} = {};'.format(tmp, self.expr(node.expr)))
self.asm('stw %0, %1[%2]',
inops=[tmp, node.left.name, self.expr(node.left.expr)])
# Otherwise, proceede normally
else:
self.out('{} = {};'.format(
self.elem(node.left), self.expr(node.expr)))
def stmt_out(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_OUTS({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_OUTS({}, {});'.format(left, expr))
else:
self.out('OUTS({}, {});'.format(left, expr))
def stmt_in(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_INS({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_INS({}, {});'.format(left, expr))
else:
self.out('INS({}, {});'.format(left, expr))
def stmt_out_tag(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_OUT_TAG({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_OUT_TAG({}, {});'.format(left, expr))
else:
self.out('OUT({}, {});'.format(left, expr))
def stmt_in_tag(self, node, chans):
left = self.elem(node.left)
expr = self.expr(node.expr)
if chans[node.left.name] == defs.CONNECT_SERVER:
self.out('SERVER_IN_TAG({}, {});'.format(left, expr))
elif chans[node.left.name] == defs.CONNECT_CLIENT:
self.out('CLIENT_IN_TAG({}, {});'.format(left, expr))
else:
self.out('IN({}, {});'.format(left, expr))
def stmt_alias(self, node, chans):
"""
Generate an alias statement. If the slice target is an array we must use
some inline assembly to get xcc to load the address for us. Otherwise,
we can just perform arithmetic on the pointer.
"""
if node.slice.symbol.type == T_VAR_ARRAY:
self.asm('add %0, %1, %2', outop=node.left.name,
inops=[node.slice.name, '({})*{}'.format(
self.expr(node.slice.base), defs.BYTES_PER_WORD)])
elif node.slice.symbol.type == T_REF_ARRAY:
self.out('{} = {} + ({})*{};'.format(self.elem(node.left), node.slice.name,
self.expr(node.slice.base), defs.BYTES_PER_WORD))
def stmt_connect(self, node, chans):
if node.type == defs.CONNECT_MASTER:
self.out('{} = {}({}, {});'.format(self.elem(node.left),
defs.LABEL_CONNECT_MASTER, self.expr(node.id), self.expr(node.expr)))
elif node.type == defs.CONNECT_SLAVE:
self.out('{} = {}({}, {});'.format(self.elem(node.left),
defs.LABEL_CONNECT_SLAVE, self.expr(node.id), self.expr(node.expr)))
elif node.type == defs.CONNECT_SERVER:
self.out('{} = {}({});'.format(self.elem(node.left),
defs.LABEL_CONNECT_SERVER, self.expr(node.id)))
elif node.type == defs.CONNECT_CLIENT:
self.out('{} = {}({}, {});'.format(self.elem(node.left),
defs.LABEL_CONNECT_CLIENT, self.expr(node.id), self.expr(node.expr)))
else:
assert 0
def stmt_if(self, node, chans):
self.out('if ({})'.format(self.expr(node.cond)))
self.stmt_block(node.thenstmt, chans)
if not isinstance(node.elsestmt, ast.StmtSkip):
self.out('else')
self.stmt_block(node.elsestmt, chans)
def stmt_while(self, node, chans):
self.out('while ({})'.format(self.expr(node.cond)))
self.stmt_block(node.stmt, chans)
def stmt_for(self, node, chans):
self.out('for ({0} = {1}; {0} < ({1}+{2}); {0}++)'.format(
node.index.name, self.expr(node.index.base),
self.expr(node.index.count)))
self.stmt_block(node.stmt, chans)
def stmt_on(self, node, chans):
gen_on(self, node, chans)
def stmt_pcall(self, node, chans):
self.out('{}({});'.format(
self.procedure_name(node.name), self.arguments(node.args)))
def stmt_assert(self, node, chans):
self.out('ASSERT({});'.format(self.expr(node.expr)))
def stmt_return(self, node, chans):
self.out('return {};'.format(self.expr(node.expr)))
def stmt_skip(self, node, chans):
pass
# Statements that have been reduced to a canonical form
def stmt_server(self, node, chans):
assert 0
def stmt_rep(self, node, chans):
assert 0
# Expressions =========================================
# Return their string representation
def expr_single(self, node):
# If the elem is an array reference subscript, generate a load
if isinstance(node.elem, ast.ElemSub):
if node.elem.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('ldw %0, %1[%2]', outop=tmp,
inops=[node.elem.name, self.expr(node.elem.expr)])
return tmp
# Otherwise, just return the regular syntax
return self.elem(node.elem)
def expr_unary(self, node):
# If the elem is an array reference subscript, generate a load
if isinstance(node.elem, ast.ElemSub):
if node.elem.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('ldw %0, %1[%2]', outop=tmp,
inops=[node.elem.name, self.expr(node.elem.expr)])
return '({}{})'.format(op_conversion[node.op], tmp)
else:
return '({}{})'.format(op_conversion[node.op], self.elem(node.elem))
# Otherwise, just return the regular syntax
else:
return '({}{})'.format(op_conversion[node.op], self.elem(node.elem))
def expr_binop(self, node):
# If the elem is an array reference subscript, generate a load
if isinstance(node.elem, ast.ElemSub):
if node.elem.symbol.type == T_REF_ARRAY:
tmp = self.blocker.get_tmp()
self.asm('ldw %0, %1[%2]', outop=tmp,
inops=[node.elem.name, self.expr(node.elem.expr)])
return '{} {} {}'.format(tmp,
op_conversion[node.op], self.expr(node.right))
else:
return '{} {} {}'.format(self.elem(node.elem),
op_conversion[node.op], self.expr(node.right))
# Otherwise, just return the regular syntax
return '{} {} {}'.format(self.elem(node.elem),
op_conversion[node.op], self.expr(node.right))
# Elements ============================================
# Return their string representation
def elem_group(self, node):
return '({})'.format(self.expr(node.expr))
def elem_sub(self, node):
return '{}[{}]'.format(node.name, self.expr(node.expr))
def elem_slice(self, node):
# If source is an array take the address, if reference then just the value
address = ''+node.name
if node.symbol.type == T_VAR_ARRAY:
address = '(unsigned, '+address+')'
return '({} + ({})*{})'.format(address, self.expr(node.base),
defs.BYTES_PER_WORD)
def elem_fcall(self, node):
return '{}({})'.format(self.procedure_name(node.name), self.arguments(node.args))
def elem_number(self, node):
return '{}'.format(node.value)
def elem_boolean(self, node):
return '{}'.format(node.value.upper())
def elem_string(self, node):
return '{}'.format(node.value)
def elem_char(self, node):
return '{}'.format(node.value)
def elem_id(self, node):
return node.name
metavar='URL')
group.add_argument('-u',
help='Unblocking Mode',
type=str,
dest='urlU',
metavar='URL')
group.add_argument('-i',
help='Check Mode',
type=str,
dest='urlI',
metavar='URL')
group.add_argument('-g', help='Get Blocked URL list', action='store_true')
args = parser.parse_args()
b = Blocker()
if args.urlB == None and args.urlU == None and args.urlI == None and args.g == False:
parser.print_help()
elif args.g:
url_list = b.get_blocked()
print('\n==================={ Blox }===================\n')
print('[!] Blocked URL list\n')
for url in url_list:
print(f' [+] {url}')
print('\n==================={ Blox }===================\n')
