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