Пример #1
0
    def draw(self, screen):
        if self.data[TILE_TYPE] == TILE_GOLD:
            self.image = pg.image.load('gold_get.png')
        elif self.data[TILE_TYPE] == TILE_MONSTER:
            try:
                self.image = pg.image.load(
                    # show image of the first monster in the list as tile image
                    os.path.join(MONSTER_IMG_FILE_PATH, self.data[TILE_MONSTER_DATA][0][0][MONSTER_IMG_FILE]))
            except RuntimeError as e:
                DEBUG.log(e, level=1)
                self.image = pg.image.load('smile.png')
        elif self.data[TILE_TYPE] == TILE_WEAPON_SHOP:
            self.image = pg.image.load('weapon_shop.png')
        elif self.data[TILE_TYPE] == TILE_ARMOR_SHOP:
            self.image = pg.image.load('armor_shop.png')
        elif self.data[TILE_TYPE] == TILE_RESPAWN:
            self.image = pg.image.load('respawn.png')
        elif self.data[TILE_TYPE] == TILE_HEAL:
            self.image = pg.image.load('heal.png')
        elif self.data[TILE_TYPE] == TILE_OTHER_EVENT:
            self.image = pg.image.load('smile.png')

        self.image = pg.transform.scale(self.image, (self.width, self.height))
        DEBUG.log("received image, image={}".format(self.image), level=3)
        screen.blit(self.image, (self.x_pos, self.y_pos))
Пример #2
0
    def win(self, fight_scene_surface, data):
        DEBUG.log("Fight won", level=1)
        msg = "{} has gained {} exp and {} gold!"\
            .format(self.player_name, 10*data[MONSTER_LEVEL], 10*data[MONSTER_LEVEL])
        self.show_textbox_at_centre(fight_scene_surface, msg, 2000)

        # For now, loot is 10*(monster's level)
        self.exp += 10*data[MONSTER_LEVEL]
        self.gold += 10*data[MONSTER_LEVEL]

        if self.exp >= EXP_REQUIRED[self.level]:
            DEBUG.log("Level up", level=1)
            if self.level >= 15:
                raise NotImplementedError("Level higher than 15 not implemented yet.")

            self.level += 1
            self.full_health += 15
            self.current_health += 15
            self.base_attack += 2
            self.current_attack += 2

            levelup_msg = "{} level up! Lv.{}".format(self.player_name, self.level)
            self.show_textbox_at_centre(fight_scene_surface, levelup_msg, 2000)

        self.action_result = ACTION_RESULT_WIN
Пример #3
0
    def on_init(self):
        pygame.init()
        if gc.GUI["Debugger"]:
            width = self.width + self.height
        else:
            width = self.width
        self._display_surf = pygame.display.set_mode((width, self.height),
                                                     pygame.DOUBLEBUF)
        self._game_display = pygame.Surface(self.size)
        self.ppcm = 3  #TODO: variable window size
        self.center = [
            self._game_display.get_height() / (2 * self.ppcm),
            self._game_display.get_width() / (2 * self.ppcm)
        ]
        self._display_surf.set_alpha(None)
        self._running = True
        game_display_data = {
            "display": self._game_display,
            "ppcm": self.ppcm,
            "center": self.center
        }
        self.game = Game(game_display_data)

        if gc.GUI["Debugger"]:
            self.debugger = Debugger(self._display_surf,
                                     self.game.robotProgramHandlers)
            self.debugger.setFocusedRobot(self.focusedrobot)

        if gc.GUI["Logger"]:
            self.logger = Logger(self.game)
            self.logger.startLogging()

        pygame.mixer.quit()
Пример #4
0
def main():

    debug = Debugger()
    chrono = Chrono()
    universe = Universe(debug)
    source = Source(debug).get_source()
    bucket_chain = BucketChain(debug, chrono, universe, source)
    clusters = Clusters(debug, chrono, universe)
    algorithm = OnlineClustering(debug, universe, bucket_chain, clusters)

    while True:
        operation_time = time.time()
        if bucket_chain.is_updated():
            universe.compute_log_n_df()
            bucket_chain.compute_universal_counts()
            bucket_chain.compute_universal_tfidf()
            clusters.update_centroid_counts()
            clusters.update_centroid_tfidf()
            algorithm.pre_clustering_work()
            algorithm.online_clustering()
            clusters.remove_old_clusters()
            universe.prune_terms(clusters)
            debug.log("BUCKET FINISHED IN: " +
                      str(time.time() - operation_time))
            clusters.debug_active_clusters()
            clusters.save_active_clusters()
Пример #5
0
class Emu(object):
    def __init__(self, debug, graphicsScale):
        self.rom = Rom()
        self.gpu = Gpu(graphicsScale)
        self.cpu = Cpu(self.gpu)
        self.gpu.setCpu(self.cpu)
        self.debugger = None
        self.debugger = Debugger(self.cpu)
        if True == debug:
            self.debugger.activate()

    def run(self, binPath):
        self.rom.load(binPath)
        self.cpu.execProg(self.rom.romData, self.debugger)
        self.pyGameMainLoop()

    def pyGameMainLoop(self):
        while 1:
            event = pygame.event.wait()
            if event.type == pygame.KEYDOWN:
                keysPressed = pygame.key.get_pressed()
                self.cpu.keyboard.keyPressedIndication(keysPressed)
                if keysPressed[pygame.K_q]:
                    self.cpu.stop()
            if event.type == pygame.QUIT:
                self.cpu.stop()

            if False == self.cpu.running:
                raise SystemExit
Пример #6
0
    def test_attachDetachLogger_detaches_logger_when_ther_is_not_Empty(self):
        debugger = Debugger()
        cpu = FakeCpu()
        cpu.logger = Logger(cpu)
        debugger.attachDetachLogger(cpu)

        self.assertTrue(type(cpu.logger) is EmptyLogger)
Пример #7
0
    def test_attachDetachLogger_detaches_logger_when_ther_is_not_Empty(self):
        debugger = Debugger()
        cpu = FakeCpu()
        cpu.logger = Logger(cpu)
        debugger.attachDetachLogger(cpu)

        self.assertTrue(type(cpu.logger) is EmptyLogger)
Пример #8
0
    def __init__(self, index, data):
        self.index = index
        self.data = data

        self.width = TILE_WIDTH
        self.height = TILE_HEIGHT

        # set the position of tile, which goes round the window
        if self.index < NUM_TILES_WIDTH - 1:
            # upper row (excluding top right)
            self.x_pos = self.index * self.width
            self.y_pos = 0
        elif self.index < NUM_TILES_WIDTH + NUM_TILES_HEIGHT - 2:
            # right column (excluding bottom right)
            self.x_pos = WINDOW_WIDTH - self.width
            self.y_pos = (self.index - NUM_TILES_WIDTH + 1) * self.height
        elif self.index < 2*NUM_TILES_WIDTH + NUM_TILES_HEIGHT - 3:
            # lower row (excluding bottom left)
            self.x_pos = WINDOW_WIDTH - ((self.index - (NUM_TILES_WIDTH + NUM_TILES_HEIGHT - 2)) + 1) * self.width
            self.y_pos = WINDOW_HEIGHT - self.height
        elif self.index < 2*NUM_TILES_WIDTH + 2*NUM_TILES_HEIGHT - 4:
            # left column (excluding top left)
            self.x_pos = 0
            self.y_pos = WINDOW_HEIGHT - (self.index - (2*NUM_TILES_WIDTH + NUM_TILES_HEIGHT - 3) + 1) * self.height
        else:
            raise IndexError("Tile index out of range: {}".format(self.index))

        DEBUG.log("initialized tile, index={}, pos=({},{})".format(self.index, self.x_pos, self.y_pos), level=2)
Пример #9
0
 def get(self, url, timeout = _config.SOCKET_TIMEOUT):
     try:
         res = urllib2.urlopen(url, timeout = timeout)
         ret = res.read()
         return _defcode.RPC_GET_OK, ret
     except Exception, e:
         _debugger.exc(e)
         return _defcode.RPC_GET_FAILED, e
Пример #10
0
 def dispatch(self, e, **args):
     for c in self.__ecCather:
         try:
             c(e, **args)
         #pragma: no cover 1    
         except Exception,e:
             _debugger.out(e)
             if DEBUG:raise
Пример #11
0
 def __init__(self, debug, graphicsScale):
     self.rom = Rom()
     self.gpu = Gpu(graphicsScale)
     self.cpu = Cpu(self.gpu)
     self.gpu.setCpu(self.cpu)
     self.debugger = None
     self.debugger = Debugger(self.cpu)
     if True == debug:
         self.debugger.activate()
Пример #12
0
 def post(self, url, data, header, timeout = _config.SOCKET_TIMEOUT):
     try:
         req = urllib2.Request(url, data, header)
         res = urllib2.urlopen(req, timeout = timeout)
         ret = res.read()
         return _defcode.RPC_POST_OK, ret
     except Exception, e:
         _debugger.exc(e)
         return _defcode.RPC_POST_FAILED, e
Пример #13
0
    def draw_monster_card(centre_screen, data):
        """
        :param centre_screen: screen excluding the tiles area
        :param data: monster's data
        :return: the surface that the card is drawn
        """
        centre_screen.fill(BACKGROUND_COLOUR)
        try:
            image = pg.image.load(os.path.join(MONSTER_IMG_FILE_PATH, data[MONSTER_IMG_FILE]))
        except RuntimeError as e:
            DEBUG.log(e, level=1)
            try:
                image = pg.image.load('smile.png')
            except:
                raise Exception
        finally:
            image = pg.transform.scale(image, (centre_screen.get_height(), centre_screen.get_height()))
        DEBUG.log("received image, image={}".format(image), level=3)

        card_surface = centre_screen.subsurface(0, 0, image.get_height(), image.get_height())
        card_surface.blit(image, (0, 0))

        monster_level_textbox = eztext.Input(
            font=pg.font.Font(None, 40),
            maxlength=0,
            prompt="Lv.{}".format(data[MONSTER_LEVEL]),
            x=10, y=10,
        )
        monster_level_textbox.draw(card_surface)

        monster_hp_textbox = eztext.Input(
            font=pg.font.Font(None, 40),
            maxlength=0,
            prompt="HP:{}".format(data[MONSTER_HEALTH]),
            x=10, y=10+monster_level_textbox.get_size()[1],
        )
        monster_hp_textbox.draw(card_surface)

        monster_attack_textbox = eztext.Input(
            font=pg.font.Font(None, 40),
            maxlength=0,
            prompt="ATT:{}".format(data[MONSTER_ATTACK]),
            x=10, y=10+monster_level_textbox.get_size()[1]+monster_hp_textbox.get_size()[1],
        )
        monster_attack_textbox.draw(card_surface)

        monster_defence_textbox = eztext.Input(
            font=pg.font.Font(None, 40),
            maxlength=0,
            prompt="DEF:{}".format(data[MONSTER_DEFENCE]),
            x=10, y=10+monster_level_textbox.get_size()[1]+monster_hp_textbox.get_size()[1]+monster_attack_textbox.get_size()[1],
        )
        monster_defence_textbox.draw(card_surface)

        pg.display.update(centre_screen.get_rect(topleft=(TILE_WIDTH, TILE_HEIGHT)))
        return card_surface
Пример #14
0
 def __init__(self, plugin, parent=None):
     """Constructor."""
     super(RemoteDebugDialog, self).__init__(parent)
     # Set up the user interface from Designer.
     # After setupUI you can access any designer object by doing
     # self.<objectname>, and you can use autoconnect slots - see
     # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html#widgets-and-dialogs-with-auto-connect
     self.setupUi(self)
     self._plugin = plugin
     self._debugger = Debugger()
Пример #15
0
 def update_state(self, eventObj):
     if eventObj.type not in (MOUSEMOTION, MOUSEBUTTONUP, MOUSEBUTTONDOWN) or not self._visible:
         return
     
     if eventObj.type == pg.MOUSEBUTTONDOWN:
         self._mouseDown = True
     if eventObj.type == pg.MOUSEBUTTONUP and self._mouseDown:
         mouse_pos = pg.mouse.get_pos()
         if self._topLeft[0] <= mouse_pos[0]-self._pos_offset[0] <= self._topLeft[0]+self._rect.width \
            and self._topLeft[1] <= mouse_pos[1]-self._pos_offset[1] <= self._topLeft[1]+self._rect.height:
             DEBUG.log("Button {} pressed".format(self.text), level=3)
             self.buttonPressed = True
Пример #16
0
def run() -> None:
    """
    launches all tasks for debugger
    """
    parameters = get_parameters()
    analyzer = Analyzer(parameters.binary,
                        logs=vars(parameters).get("output-file"))
    analyzer.run()
    binary_infos = analyzer.get()
    check_elf(binary_infos)
    debugger = Debugger(binary_infos)
    debugger.run()
Пример #17
0
        def exist(state):
            def key(y):
                dxy = np.fabs(y.state[:-1] - s[:-1])
                da = ((y.state[-1] + np.pi) %
                      (2 * np.pi) - np.pi) - ((s[-1] + np.pi) %
                                              (2 * np.pi) - np.pi)
                return dxy[0] < self.exist_res and dxy[
                    1] < self.exist_res and da < self.exist_res

            s = np.array(state)
            result = filter(key, self.vertices)
            Debugger.breaker('sample exclusive: {}'.format(result == []),
                             switch=self.debug)
            return result
Пример #18
0
 def show_textbox_at_centre(centre_screen, prompt, time):
     centre_screen.fill(BACKGROUND_COLOUR)
     textbox = eztext.Input(
         font=pg.font.Font(None, 30),
         color=BLACK,
         maxlength=0,
         prompt=prompt,
         x=0,
         y=0,
     )
     textbox.draw(textbox.get_centre_surface(centre_screen))
     #textbox.update(pg.event.get())
     DEBUG.log("Displaying textbox with message '{}'".format(prompt), level=2)
     pg.display.flip()
     pg.time.delay(time)
Пример #19
0
def TestBench(steps, *args):
    # useful values
    # clock
    clk = Signal(bool(0))
    clkDriver = ClkDriver(clk=clk,
                          period=2)

    # counter
    cnt = Signal(intbv(0, min=0, max=steps+2))
    counter = Counter(clk=clk,
                      cnt=cnt)

    # Template
    template = Template(clk=clk)

    # debugger
    debugger = Debugger(period=1,
                        funcs={"cnt":lambda c: str(int(c)),
                               "clk":lambda c: str(int(c)),
                              },
                        cnt=cnt,
                        clk=clk,
                       )

    @instance
    def tests():
        for i in range(steps):
            yield delay(1)

    return instances()
Пример #20
0
def test_get_analysis_calls_correct_things():
    ''' ensure that getAnalysis() calls getStackTrace()/getRawAnalysis() '''
    with unittest.mock.patch('debugger.Debugger.getStackTrace') as gst:
        with unittest.mock.patch('debugger.Debugger.getRawAnalysis') as gra:
            assert Debugger('', '').getAnalysis()
            gra.assert_called_once()
            gst.assert_called_once()
Пример #21
0
def main(experiment_meta_data, data_info):
    print(
        f'Parsing the {experiment_meta_data} to obtain model and parameters.')
    experiments_data = json.load(open(experiment_meta_data, 'r'))
    dataset_meta = json.load(open(data_info, 'r'))
    debugger = Debugger(experiments_data[DEBUG_STATUS])

    print(experiments_data)
    print(dataset_meta)

    data_frame = InputOutputFrame(debugger, dataset_meta[INPUT_LOCATION], dataset_meta[OUTPUT_LOCATION], dataset_meta[FOLDS_LOCATION], \
        dataset_meta[MAX_SENTENCES_PER_AUTHOR], dataset_meta[MIN_PADDING_PER_AUTHOR], nrows=get_optional(dataset_meta, NUMBER_OF_ROWS))

    models_name = experiments_data[MODELS_NAME]
    output_directory = get_output_directory_name(
        experiments_data[OUTPUT_DIRECTORYS_LOCATION], models_name)
    if (not os.path.isdir(output_directory)):
        os.makedirs(output_directory)

    print("Starting the experiments.")
    experiment = Experiment(debugger, output_directory,get_optional(experiments_data,RESULTS_IMPORT_LOCATION), data_frame, experiments_data[BALANCE_DATA], experiments_data[EXPERIMENTS_NAME], models_name,\
         experiments_data[RUN_IDENTIFICATOR], experiments_data[FOLDS], experiments_data[PREDICTION_TYPE], experiments_data[TARGETS], experiments_data[OPTIMIZATION_PARAMETERS],\
             experiments_data[PRINT_BATCH_STATUS], experiments_data[MAX_CONSTANT_F1], experiments_data[NUMBER_OF_EPOCHS], experiments_data[DECAY_RATE], experiments_data[DECAY_EPOCH],\
             experiments_data[VALIDATION_SET_PERCENTAGE], experiments_data[CUDA_DEVICE], experiments_data[USE_GPU], experiments_data[RANDOM_STATE])

    experiment.start()
    print("Experiment finished!")
Пример #22
0
    def __init__(self):
        QtGui.QMainWindow.__init__(self)
        self.init_ui()
        self.save_restore_state(False)
        self.cfg_window = RunConfigWindow()
        self.about_dialog = AboutDialog()
        self.pty_stdout = PtyView(self.ui.commander)
        stdout_path = self.pty_stdout.get_file_path()

        self.debugger = Debugger(stdout_path, stdout_path, self.cfg_window.working_dir)
        self.ui.commander.set_tab_comp_handler(self.debugger.complete_tab)
        self.last_highlighted_editor = None
        self.my_listener = MyListeningThread(self.debugger.dbg, self.FocusLine)
        self.FocusLine.connect(self.do_focus_line)
        self.my_listener.StateChanged.connect(self.on_state_changed)
        self.my_listener.BPChanged.connect(self.on_bp_changed)
        self.debugger.listener = self.my_listener
        self.my_listener.start()
        self.opened_files = {}
        self.bp_locations = {}

        args = Qt.qApp.arguments()
        self.cfg_window.working_dir = os.getcwd()
        if len(args) > 1:
            self.do_exe_file_open(args[1])
        if len(args) > 2:
            self.cfg_window.arglist = [str(x) for x in args[2:]]

        logging.info('Ready')
Пример #23
0
def debugger_init(debug=0):
    global debugger

    # get needed vim variables

    # port that the engine will connect on
    port = int(vim.eval('debuggerPort'))
    if port == 0:
        port = 9000

    # the max_depth variable to set in the engine
    max_children = vim.eval('debuggerMaxChildren')
    if max_children == '':
        max_children = '32'

    max_data = vim.eval('debuggerMaxData')
    if max_data == '':
        max_data = '1024'

    max_depth = vim.eval('debuggerMaxDepth')
    if max_depth == '':
        max_depth = '1'

    minibufexpl = int(vim.eval('debuggerMiniBufExpl'))
    if minibufexpl == 0:
        minibufexpl = 0

    debugger = Debugger(port, max_children, max_data, max_depth, minibufexpl,
                        debug)
Пример #24
0
 def collision_free(self, x_from,
                    x_to):  # type: (StateNode, StateNode) -> bool
     """check if the path from one state to another state collides with any obstacles or not."""
     # making contours of the curve
     states = reeds_shepp.path_sample(x_from.state, x_to.state,
                                      1. / self.maximum_curvature, 0.3)
     # states.append(tuple(x_to.state))  # include the end point
     contours = [
         self.transform(self.check_poly, s[0], s[1], s[2]) for s in states
     ]
     contours = [
         np.floor(con / self.grid_res +
                  self.grid_map.shape[0] / 2.).astype(int)
         for con in contours
     ]
     # making mask
     mask = np.zeros_like(self.grid_map, dtype=np.uint8)
     [cv2.fillPoly(mask, [con], 255) for con in contours]
     # checking
     result = np.bitwise_and(mask, self.grid_map)
     Debugger().debug_collision_checking(states,
                                         self.check_poly,
                                         np.all(result < self.obstacle),
                                         switch=self.debug)
     return np.all(result < self.obstacle)
Пример #25
0
 def recheck(x):
     available, cost = self.collision_free(x_new,
                                           x), self.cost(x_new, x)
     if available and x.g > x_new.g + cost:
         Debugger().debug_rewiring(x, x_new.g + cost, switch=self.debug)
         x.g = x_new.g + cost
         x.fu, x.fl = x.g + x.hu, x.g + x.hl
         x.rematch(x_new)
Пример #26
0
def main():
    opt = parse_command_line_args()

    if opt.disassemble is not None:
        if opt.disassemble == "boot":
            opt.disassemble = opt.boot_rom

        binary = load_binary(opt.disassemble)
        print("Disassembly of %s\n" % os.path.relpath(opt.disassemble))
        disassemble(binary, opt.start_address)
        sys.exit(0)

    if opt.cartridge is not None:
        log("Loading boot ROM from %s" % os.path.relpath(opt.boot_rom))
        boot = load_binary(opt.boot_rom)

        log("Loading cartridge from %s" % os.path.relpath(opt.cartridge))
        binary = load_binary(opt.cartridge)
        cartridge = Cartridge(binary)
        log(cartridge)

        log("Booting Gameboy")
        gameboy = Gameboy(cartridge,
                          boot,
                          no_display=opt.no_display,
                          zoom=opt.zoom)

        if opt.skip_boot:
            set_boot(gameboy)
            gameboy.memory.boot_rom_active = False

        if opt.debug:
            Debugger(gameboy).run()
            sys.exit(0)
        else:
            try:
                gameboy.cpu.run()
            except EmulatorError as e:
                log("\n** Exception: %s" % str(e).strip())
                Debugger(gameboy).run()
            except Exception as e:
                log("\n** Exception: %s" % str(e).strip())
                gameboy.cpu.print_registers()
                log("")
                raise
Пример #27
0
 def planning(self, times, repeat=10, optimize=False, debug=False):
     """main flow."""
     self.debug = debug
     past = time.time()
     for i in range(times):
         x_new = self.sample_free(i, repeat)
         x_nearest = self.nearest(x_new) if not optimize else self.least(
             x_new)
         if x_nearest and self.benefit(x_new) and self.collision_free(
                 x_nearest, x_new):
             self.attach(x_nearest, x_new)
             self.rewire(x_new)
             self.x_best = self.best()
             self.branch_and_bound()
         Debugger().debug_planned_path(self, i, switch=self.debug)
         Debugger().debug_planning_hist(self,
                                        i, (time.time() - past),
                                        switch=True)
Пример #28
0
    def branch_and_bound(self, space=None):
        def out(x):
            vertices.remove(x)
            x.remove()

        vertices = space if space else self.vertices
        vs = filter(lambda x: x.fl > self.x_best.fu + self.epsilon, vertices)
        map(out, vs)
        Debugger().debug_branch_and_bound(vs, switch=self.debug)
Пример #29
0
    def __init__(self):
        super(MainWindow, self).__init__()
        self.debugger = Debugger(DummyCpu())
        self.ui = uic.loadUi('gui.ui', self)

        self.ui.editor.setReadOnly(True)

        # nearly (all) connects are done via qtdesigner
        self.ui.editor.breakpointSet.connect(self.breakpointSet)
        self.ui.editor.breakpointRemoved.connect(self.breakpointRemoved)

        #TODO register on registerlabels
        for i in ['Z', 'N', 'C', 'V']:
            getattr(self.ui, i).toggled.connect(
                partial(
                    lambda flag, state: setattr(self.debugger, flag, state),
                    i))

        self.updateDisplay()
 def __init__(self, plugin, parent=None):
     """Constructor."""
     super(RemoteDebugDialog, self).__init__(parent)
     # Set up the user interface from Designer.
     # After setupUI you can access any designer object by doing
     # self.<objectname>, and you can use autoconnect slots - see
     # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html#widgets-and-dialogs-with-auto-connect
     self.setupUi(self)
     self._plugin = plugin
     self._debugger = Debugger()
Пример #31
0
 def swap(self, i):
     self.branch_and_bound(self.g_vertices)
     self.branch_and_bound(self.s_vertices)
     if self.root is self.start:
         self.root = self.goal
         self.gain = self.start
         self.vertices = self.g_vertices
         n = -((i / 2) % len(self.heuristic)) - 1 if self.heuristic else i
         Debugger.breaker('swap: goal -> start, {}, {}'.format(i, n),
                          self.debug)
         return n
     else:
         self.root = self.start
         self.gain = self.goal
         self.vertices = self.s_vertices
         n = (i / 2) % len(self.heuristic) if self.heuristic else i
         Debugger.breaker('swap: start -> goal, {}, {}'.format(i, n),
                          self.debug)
         return n
Пример #32
0
 def is_free(state):
     contour = self.transform(self.check_poly, state[0], state[1],
                              state[2])
     contour = np.floor(contour / self.grid_res +
                        self.grid_map.shape[0] / 2.).astype(int)
     mask = np.zeros_like(self.grid_map, dtype=np.uint8)
     cv2.fillPoly(mask, [contour], 255)
     result = np.bitwise_and(mask, self.grid_map)
     Debugger().breaker(
         'sample free: {}'.format(np.all(result < self.obstacle)),
         self.debug)
     return np.all(result < self.obstacle)
Пример #33
0
    def setDebugMode(self):
        """Set the debug mode, creating a debugger an setting it up as a proxy."""
        self.debugMode = True
        self.debugger = Debugger(self, self.interpreter)
        # Set the debugger as a proxy.
        self.interpreter = self.debugger

        # Create a logging handler for debugging messages.
        debugHandler = logging.StreamHandler(sys.stdout)
        debugHandler.setFormatter(logging.Formatter(self.formatStr))
        debugHandler.setLevel(logging.DEBUG)
        self.logger.addHandler(debugHandler)
Пример #34
0
    def roll_dice(self, centre_screen, event_type):
        """
        :param centre_screen: (Surface) centre screen area
        :param event_type: (int) EVENT_GO_FORWARD, EVENT_GOLD, or EVENT_MONSTER_FIGHT
        :return: random number from 1~6
        """
        centre_screen.fill(BACKGROUND_COLOUR)

        # set up textbox for rolling dice
        dice_roll_textbox = self.get_dice_roll_textbox(event_type)
        centre_of_centre = dice_roll_textbox.get_centre_surface(centre_screen)
        dice_roll_textbox.draw(centre_of_centre)
        pg.display.update(centre_screen.get_rect(topleft=(TILE_WIDTH, TILE_HEIGHT)))

        # dice rolling loop
        while True:
            DEBUG.log("Waiting for player to roll dice", level=3)
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    sys.exit()
                elif event.type == pg.MOUSEBUTTONDOWN:
                    DEBUG.log("Mouse pressed to roll dice", level=2)
                    dice_number = Player.get_dice_number()
                    if not SKIP_DICE_GRAPHICS:
                        Player.show_dice_graphics(centre_screen, dice_number)
                    return dice_number
                elif event.type == pg.KEYDOWN and event.key == pg.K_RETURN:
                    DEBUG.log("Pressed enter to show status", level=2)
                    self.show_status(centre_screen)

                    # go back to dice roll / status show UI
                    dice_roll_textbox.draw(centre_of_centre)
                    pg.display.update(centre_screen.get_rect(topleft=(TILE_WIDTH, TILE_HEIGHT)))
Пример #35
0
def main(argv=None):
    """Popuplate options on the class from sys.argv"""
    if not argv:
        argv = sys.argv[1:]

    parser = make_parser()
    args = parser.parse_args(argv)

    Debugger(project=args.project,
             host=args.host,
             port=args.port,
             setup_project=setup_project,
             project_options=args.options).run()
Пример #36
0
 def test_zexdoc(self):
     print(">>> RUNNING ZEXDOC")
     debugger = Debugger()
     debugger.stopOnError = False
     debugger.setHook(0x5, self.systemFunction)
     debugger.setHook(0x0, self.stop)
     rom = ROM(mapAt=0x100)
     rom.loadFrom('./zexdoc.com', False)
     cpu = CPU(rom=rom, debugger=debugger)
     cpu.SP = 0xF000
     cpu.run(0x100)
     self.assertTrue(True)
Пример #37
0
 def openNewFile(self):
     filename = QFileDialog.getOpenFileName(
         self,
         'Open File',
         filter=
         "Compiled/Debug Files (*.out.dbg *.s.out) (*.out.dbg *.out);;All Files (*)"
     )
     if filename != '':
         self.debugger = Debugger.loadFromFile(str(filename),
                                               memorysize=1024 * 1024)
         self.ui.ram.setData(''.join(map(chr, self.debugger.ram)))
         self.ui.editor.setText(self.debugger.fileContent())
         self.ui.editor.resetMarker()
     self.updateDisplay()
Пример #38
0
 def attach(self, x_nearest, x_new):  # type: (StateNode, StateNode) -> None
     """add the new state to the tree and complement other values.
     And fill the hu and fu properties of x_new.
     """
     x_new.match(x_nearest)
     available = self.collision_free(x_new, self.gain)
     x_new.hu = x_new.hl if available else np.inf
     x_new.fu = x_new.g + x_new.hu
     x_new.status = 0 if available else 1
     self.vertices.append(x_new)
     Debugger().debug_attaching(x_nearest,
                                x_new,
                                1. / self.maximum_curvature,
                                switch=self.debug)
Пример #39
0
    def rewire(self, x_new, gamma=0.2):  # type: (StateNode, float) -> None
        """rewiring tree by the new state."""
        def recheck(x):
            available, cost = self.collision_free(x_new,
                                                  x), self.cost(x_new, x)
            if available and x.g > x_new.g + cost:
                Debugger().debug_rewiring(x, x_new.g + cost, switch=self.debug)
                x.g = x_new.g + cost
                x.fu, x.fl = x.g + x.hu, x.g + x.hl
                x.rematch(x_new)

        xs = filter(lambda x: x.g > x_new.g + gamma, self.vertices)
        Debugger().debug_rewiring_check(xs, x_new, switch=self.debug)
        map(recheck, xs)
Пример #40
0
    def process_monster_fight(self, fight_scene_surface, data, fight_condition_num):
        monster_fight_scene_textbox = eztext.Input(
            font=pg.font.Font(None, 25),
            maxlength=0,
        )
        monster_current_hp = data[MONSTER_HEALTH]
        # monster attacks first
        MONSTER_TURN = 0
        PLAYER_TURN = 1

        turn = 0
        while True:
            fight_scene_surface.fill(BACKGROUND_COLOUR)
            monster_fight_scene_textbox.set_prompt("{}:{}/{}, {}:{}/{}".format(
                self.player_name, max(self.current_health, 0), self.full_health,
                data[MONSTER_NAME], max(monster_current_hp, 0), data[MONSTER_HEALTH]
            ))
            monster_fight_scene_textbox.draw(fight_scene_surface)
            pg.display.flip()
            DEBUG.log("Fighting with monster, {}:{}/{}    {}:{}/{}".format(
                self.player_name, max(self.current_health, 0), self.full_health,
                data[MONSTER_NAME], max(monster_current_hp, 0), data[MONSTER_HEALTH]), level=2)
            pg.time.delay(300)

            if self.current_health <= 0:
                self.die(fight_scene_surface)
                break
            elif monster_current_hp <= 0:
                self.win(fight_scene_surface, data)
                break

            if turn % 2 == MONSTER_TURN:
                self.current_health -= (data[MONSTER_ATTACK] - self.current_defence)
            elif turn % 2 == PLAYER_TURN:
                monster_current_hp -= (int(self.current_attack*(9+fight_condition_num)/10) - data[MONSTER_DEFENCE])

            turn += 1
Пример #41
0
    def start(self):
        DEBUG.log("Game started", level=1)
        self.board.draw(self.whole_screen)

        self.update_player_pos()
        # main loop (one turn per iteration)
        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    sys.exit()

            # determine who plays this turn
            which_player_turn = self.turn % self.num_players
            player = self.players[which_player_turn]

            # process dice rolling
            dice_result = player.roll_dice(self.centre_screen, EVENT_GO_FORWARD)

            # clear the centre screen and the tile that the player was in, because the player's not there anymore
            self.centre_screen.fill(BACKGROUND_COLOUR)
            self.board.tiles[player.position].draw(self.whole_screen)

            player.position += dice_result
            DEBUG.log("Player {}, moving to position {}".format(which_player_turn+1, player.position), level=1)
            if player.position >= len(self.board.tiles):
                break

            self.update_player_pos()
            action_result = player.invoke_tile_action(self.centre_screen, tile_data[player.position])
            if action_result == ACTION_RESULT_DIE:
                # if died, clear the player token from the tile
                self.board.tiles[player.died_position].draw(self.whole_screen)
                self.update_player_pos()

            self.turn += 1
Пример #42
0
    def nearest(self, x_rand):  # type: (StateNode) -> StateNode
        """find the state in the tree which is nearest to the sampled state.
        And fill the g, hl and fl properties of the sampled state.
        """
        def replenish(x_n, x_r):
            x_r.g, x_r.hl = x_n.g + self.cost(x_n, x_r), self.cost(
                x_r, self.gain)
            x_r.fl = x_r.g + x_r.hl

        # quick shot
        if self.collision_free(self.root, x_rand):
            x_nearest = self.root
        else:
            costs = list(map(lambda x: self.cost(x, x_rand), self.vertices))
            x_nearest = self.vertices[int(np.argmin(costs))]
        replenish(x_nearest, x_rand)
        Debugger().debug_nearest_searching(x_nearest.state, switch=self.debug)
        return x_nearest
Пример #43
0
 def connect_graphs(self, x_new):
     if self.root is self.start:
         vs = self.g_vertices
     else:
         vs = self.s_vertices
     costs = map(lambda x: self.cost(x_new, x), vs)
     x_nearest, cost = vs[int(np.argmin(costs))], np.min(costs)
     Debugger().debug_connect_graphs(x_nearest.state,
                                     x_new.g + cost + x_nearest.g,
                                     self.x_best.fu,
                                     switch=self.debug)
     if x_new.g + cost + x_nearest.g < self.x_best.fu:
         if self.collision_free(x_new, x_nearest):
             x_nearest.fu = x_new.fu = x_new.g + cost + x_nearest.g
             x_new.hu = x_new.fu - x_new.g
             x_nearest.hu = x_nearest.fu - x_nearest.g
             x_new.neighbor = x_nearest
             x_nearest.neighbor = x_new
             self.x_best = x_new
Пример #44
0
    def shop_initial_dialog(self, centre_screen, tile_value):
        centre_screen.fill(BACKGROUND_COLOUR)

        button_rect = pg.Rect(0, 0, 240, 60)
        buy_button = Button(
            centre_screen,
            (centre_screen.get_width()/2, centre_screen.get_height()/2 - button_rect.height),
            "Buy", 20, rect=button_rect, pos_offset=(TILE_WIDTH, TILE_HEIGHT))
        sell_button = Button(
            centre_screen,
            (centre_screen.get_width()/2, centre_screen.get_height()/2),
            "Sell", 20, rect=button_rect, pos_offset=(TILE_WIDTH, TILE_HEIGHT))
        leave_button = Button(
            centre_screen, (centre_screen.get_width()/2, centre_screen.get_height()/2 + button_rect.height),
            "Leave", 20, rect=button_rect, pos_offset=(TILE_WIDTH, TILE_HEIGHT))
        buy_button.update()
        sell_button.update()
        leave_button.update()
        pg.display.update(centre_screen.get_rect(topleft=(TILE_WIDTH, TILE_HEIGHT)))

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    sys.exit()

                buy_button.update_state(event)
                sell_button.update_state(event)
                leave_button.update_state(event)

            if buy_button.buttonPressed:
                DEBUG.log("Buy button pressed", level=2)
                centre_screen.fill(BACKGROUND_COLOUR)
                self.shop_action_buy(centre_screen, tile_value)
                break
            elif sell_button.buttonPressed:
                DEBUG.log("Sell button pressed", level=2)
                centre_screen.fill(BACKGROUND_COLOUR)
                self.shop_action_sell(centre_screen)
                break
            elif leave_button.buttonPressed:
                DEBUG.log("Leave button pressed", level=2)
                self.action_result = ACTION_RESULT_SHOP_LEAVE
                # escape recursion if leaving
                return

        # recursive process for buying/selling
        self.shop_initial_dialog(centre_screen, tile_value)
Пример #45
0
 def emerge():
     if self.heuristic:
         i = n % len(self.heuristic)
         state, biasing = self.heuristic[i]
         rand = [state[0], state[1], state[2]]  # [x_o, y_o, a_o]
         (x_mu, x_sigma), (y_mu, y_sigma), (a_mu, a_sigma) = biasing
         rand[0] += np.random.normal(x_mu, x_sigma)
         rand[1] += np.random.normal(y_mu, y_sigma)
         rand[2] += np.random.normal(a_mu, a_sigma)
         return rand
     else:
         Debugger().debug_no_heuristic(vertex.state, default,
                                       self.debug)
         rand = [vertex.state[0], vertex.state[1], vertex.state[2]]
         (r_mu, r_sigma), (t_mu, t_sigma), (a_mu, a_sigma) = default
         r, theta = np.random.normal(
             r_mu, r_sigma), np.random.normal(t_mu, t_sigma) + rand[2]
         rand[0] += r * np.cos(theta)
         rand[1] += r * np.sin(theta)
         rand[2] += np.random.normal(a_mu, a_sigma)
         return rand
Пример #46
0
def detect_video(yolo, video_path, output_path=""):
    debug = Debugger()
    vid = cv2.VideoCapture(video_path)
    if not vid.isOpened():
        raise IOError("Couldn't open webcam or video")
    video_FourCC    = int(vid.get(cv2.CAP_PROP_FOURCC))
    video_fps       = vid.get(cv2.CAP_PROP_FPS)
    video_size      = (int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)),
                        int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)))
    isOutput = True if output_path != "" else False
    if isOutput:
        print("!!! TYPE:", type(output_path), type(video_FourCC), type(video_fps), type(video_size))
        out = cv2.VideoWriter(output_path, video_FourCC, video_fps, video_size)
    accum_time = 0
    curr_fps = 0
    fps = "FPS: ??"
    frm_num = 0
    prev_time = timer()
    while True:
        return_value, frame = vid.read()
        if frame is None:
            break
        image = Image.fromarray(frame)
        image,boxes,confidence,classID = yolo.detect_image(image)
        result = np.asarray(image)
        curr_time = timer()
        exec_time = curr_time - prev_time
        prev_time = curr_time
        accum_time = accum_time + exec_time
        curr_fps = curr_fps + 1
        if accum_time > 1:
            accum_time = accum_time - 1
            fps = "FPS: " + str(curr_fps)
            curr_fps = 0
        cv2.putText(result, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
                    fontScale=0.50, color=(255, 0, 0), thickness=2)
        cv2.namedWindow("result", cv2.WINDOW_NORMAL)
        cv2.imshow("result", result)
        if isOutput:
            out.write(result)
            debug.store_detected_bounding_boxes(boxes,confidence,classID,frm_num)#detections are stored per frame slicing
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
        frm_num += 1
    debug.write_detection()
    print("Finished Detection on Video, total frames detected:", frm_num)
    yolo.close_session()
Пример #47
0
    async def __debugger_create_worker(self):
        app_dir = os.getcwd()
        log_dir = self.__log_dir or app_dir
        log_level = self.__log_level
        debugger = f"{app_dir}\\debugger.exe" if platform.system(
        ) == "Windows" else f"{app_dir}/debugger"

        cmd = f"{debugger} --log_level {log_level} --log_dir {log_dir} --mode debug"

        while self.__proc_idle is None:
            try:
                debugger = Debugger(
                    self.__loop,
                    self.__server,
                )
                await debugger.create_process(cmd)
                self.__proc_idle = debugger
                loggers.get(MODUE_NAME).info(
                    f"Subprocess({debugger.pid}) is created.")
            except Exception as e:
                self.__proc_idle = None
                loggers.get(MODUE_NAME).exception(e)
Пример #48
0
class VM:
    """This class encapsulates all the VM processing."""

    def __init__(self):
        self.setUpLogging()

        # Program counter: position of the next instruction to execute.
        self.PC = 0
        self.endAddress = 0

        # Structure of the stores used in the vm.
        self.variables = {}
        self.code = []
        self.rulesCode = []
        self.macrosCode = []
        self.preprocessCode = []
        self.trie = SystemTrie()

        # Current code section in execution (a macro, a rule, ...).
        self.currentCodeSection = self.code

        # Execution state of the vm.
        self.status = VM_STATUS.HALTED

        # Transfer stage (chunker, interchunk or postchunk).
        self.transferStage = None
        # Chunker mode to process in shallow mode or advanced transfer.
        self.chunkerMode = None

        # Input will be divided in words with their patterns information.
        self.words = []
        self.superblanks = []
        self.lastSuperblank = -1
        self.currentWords = []
        self.nextPattern = 0

        # Components used by the vm.
        self.tokenizer = None
        self.callStack = CallStack(self)
        self.stack = SystemStack()
        self.loader = None
        self.interpreter = Interpreter(self)

        # Components used only in debug mode.
        self.debugger = None
        self.debugMode = False

        self.input = sys.stdin
        # We use 'buffer' to get a stream of bytes, not str, because we want to
        # encode it using utf-8 (just for safety).
        self.output = sys.stdout.buffer

    def setUpLogging(self):
        """Set at least an error through stderr logger"""

        self.formatStr = "%(levelname)s: %(filename)s[%(lineno)d]:\t%(message)s"
        self.logger = logging.getLogger("vm")

        errorHandler = logging.StreamHandler(sys.stderr)
        errorHandler.setFormatter(logging.Formatter(self.formatStr))
        errorHandler.setLevel(logging.ERROR)
        self.logger.addHandler(errorHandler)

    def setDebugMode(self):
        """Set the debug mode, creating a debugger an setting it up as a proxy."""
        self.debugMode = True
        self.debugger = Debugger(self, self.interpreter)
        # Set the debugger as a proxy.
        self.interpreter = self.debugger

        # Create a logging handler for debugging messages.
        debugHandler = logging.StreamHandler(sys.stdout)
        debugHandler.setFormatter(logging.Formatter(self.formatStr))
        debugHandler.setLevel(logging.DEBUG)
        self.logger.addHandler(debugHandler)

    def setLoader(self, header, t1xFile):
        """Set the loader to use depending on the header of the code file."""

        if "assembly" in header:
            self.loader = AssemblyLoader(self, t1xFile)
        else:
            return False
        return True

    def setTransferStage(self, transferHeader):
        """Set the transfer stage to process by the vm."""

        if "transfer" in transferHeader:
            self.transferStage = TRANSFER_STAGE.CHUNKER
            self.tokenizer = TransferWordTokenizer()
            # Set chunker mode, by default 'lu'.
            if "chunk" in transferHeader:
                self.chunkerMode = CHUNKER_MODE.CHUNK
            else:
                self.chunkerMode = CHUNKER_MODE.LU
        elif "interchunk" in transferHeader:
            self.transferStage = TRANSFER_STAGE.INTERCHUNK
            self.tokenizer = ChunkWordTokenizer()
        elif "postchunk" in transferHeader:
            self.transferStage = TRANSFER_STAGE.POSTCHUNK
            self.tokenizer = ChunkWordTokenizer(solveRefs=True, parseContent=True)

    def tokenizeInput(self):
        """Call to the tokenizer to divide the input in tokens."""

        self.words, self.superblanks = self.tokenizer.tokenize(self.input)

    def initializeVM(self):
        """Execute code to initialize the VM, e.g. default values for vars."""

        self.PC = 0
        self.status = VM_STATUS.RUNNING
        while self.status == VM_STATUS.RUNNING and self.PC < len(self.code):
            self.interpreter.execute(self.code[self.PC])

    def getSourceWord(self, pos):
        """Get the part of a source word needed for pattern matching, depending
           on the transfer stage."""

        if self.transferStage == TRANSFER_STAGE.CHUNKER:
            return self.words[pos].source.lu
        elif self.transferStage == TRANSFER_STAGE.INTERCHUNK:
            word = self.words[pos].chunk
            return word.attrs["lem"] + word.attrs["tags"]
        else:
            return self.words[pos].chunk.attrs["lem"]

    def getNextInputPattern(self):
        """Get the next input pattern to analyze, lowering the lemma first."""

        try:
            pattern = self.getSourceWord(self.nextPattern)
            tag = pattern.find("<")
            pattern = pattern[:tag].lower() + pattern[tag:]
            self.nextPattern += 1
        except IndexError:
            return None

        return pattern

    def getUniqueSuperblank(self, pos):
        """Get the superblank at pos avoiding duplicates."""

        try:
            if pos != self.lastSuperblank:
                self.lastSuperblank = pos
                return self.superblanks[pos]
        except IndexError:
            pass

        return ""

    def selectNextRule(self):
        """Select the next rule to execute depending on the transfer stage."""

        if self.transferStage == TRANSFER_STAGE.POSTCHUNK:
            self.selectNextRulePostChunk()
        else:
            self.selectNextRuleLRLM()

    def selectNextRulePostChunk(self):
        """Select the next rule trying to match patterns one by one."""

        # Go through all the patterns until one matches a rule.
        while self.nextPattern < len(self.words):
            startPatternPos = self.nextPattern
            pattern = self.getNextInputPattern()
            ruleNumber = self.trie.getRuleNumber(pattern)
            if ruleNumber is not None:
                #                print('Pattern "{}" match rule: {}'.format(pattern, ruleNumber))
                self.setRuleSelected(ruleNumber, startPatternPos, pattern)
                return
            else:
                self.processUnmatchedPattern(self.words[startPatternPos])

        # if there isn't any rule at all to execute, stop the vm.
        self.status = VM_STATUS.HALTED

    def selectNextRuleLRLM(self):
        """Select the next rule to execute matching the LRLM pattern."""

        longestMatch = None
        nextPatternToProcess = self.nextPattern

        # Go through all the patterns until one matches a rule.
        while self.nextPattern < len(self.words):
            startPatternPos = self.nextPattern
            # Get the next pattern to process
            pattern = self.getNextInputPattern()
            curNodes = self.trie.getPatternNodes(pattern)
            nextPatternToProcess += 1

            # Get the longest match, left to right
            fullPattern = pattern
            while len(curNodes) > 0:
                # Update the longest match if needed.
                ruleNumber = self.trie.getRuleNumber(fullPattern)
                if ruleNumber is not None:
                    longestMatch = ruleNumber
                    nextPatternToProcess = self.nextPattern

                # Continue trying to match current pattern + the next one.
                pattern = self.getNextInputPattern()
                if pattern:
                    fullPattern += pattern
                nextNodes = []
                for node in curNodes:
                    nextNodes.extend(self.trie.getPatternNodes(pattern, node))
                curNodes = nextNodes

            # If the pattern doesn't match, we will continue with the next one.
            # If there is a match of a group of patterns, we will continue with
            # the last unmatched pattern.
            self.nextPattern = nextPatternToProcess

            # Get the full pattern matched by the rule.
            if self.nextPattern < len(self.words):
                end = fullPattern.find(self.getSourceWord(self.nextPattern))
                if end > 0:
                    fullPattern = fullPattern[:end]

            # If there is a longest match, set the rule to process
            if longestMatch is not None:
                #                print('Pattern "{}" match rule: {}'.format(fullPattern, longestMatch))
                self.setRuleSelected(longestMatch, startPatternPos, fullPattern)
                return
            # Otherwise, process the unmatched pattern.
            else:
                self.processUnmatchedPattern(self.words[self.nextPattern - 1])

            longestMatch = None

        # if there isn't any rule at all to execute, stop the vm.
        self.status = VM_STATUS.HALTED

    def setRuleSelected(self, ruleNumber, startPos, pattern):
        """Set a rule and its words as current ones."""

        # Output the leading superblank of the matched pattern.
        self.writeOutput(self.getUniqueSuperblank(startPos))

        # Add only a reference to the index pos of words, to avoid copying them.
        wordsIndex = []
        while startPos != self.nextPattern:
            wordsIndex.append(startPos)
            startPos += 1

        # Create an entry in the call stack with the rule to execute.
        self.callStack.push("rules", ruleNumber, wordsIndex)

        if self.debugMode:
            self.debugger.ruleSelected(pattern, ruleNumber)

    def processRuleEnd(self):
        """Do all the processing needed when rule ends."""

        # Output the trailing superblank of the matched pattern.
        self.writeOutput(self.getUniqueSuperblank(self.nextPattern))

    def processUnmatchedPattern(self, word):
        """Output unmatched patterns as the default form."""
        default = ""

        # Output the leading superblank of the unmatched pattern.
        default += self.getUniqueSuperblank(self.nextPattern - 1)

        # For the chunker, output the default version of the unmatched pattern.
        if self.transferStage == TRANSFER_STAGE.CHUNKER:
            # If the target word is empty, we don't need to output anything.
            if word.target.lu != "":
                wordTL = "^" + word.target.lu + "$"
                if self.chunkerMode == CHUNKER_MODE.CHUNK:
                    if wordTL[1] == "*":
                        default += "^unknown<unknown>{" + wordTL + "}$"
                    else:
                        default += "^default<default>{" + wordTL + "}$"
                else:
                    default += wordTL

        # For the interchunk stage only need to output the complete chunk.
        elif self.transferStage == TRANSFER_STAGE.INTERCHUNK:
            default += "^" + word.chunk.lu + "$"

        # Lastly, for the postchunk stage output the lexical units inside chunks
        # with the case of the chunk pseudolemma.
        else:
            default += word.chunk.attrs["chcontent"][1:-1]

        # Output the trailing superblank of the matched pattern.
        default += self.getUniqueSuperblank(self.nextPattern)

        self.writeOutput(default)

    def terminateVM(self):
        """Do all the processing needed when the vm is being turned off."""

        pass

    def writeOutput(self, string):
        """A single entry point to write strings to the output."""

        self.output.write(string.encode("utf-8"))

    def run(self):
        """Load, preprocess and execute the contents of the files."""

        try:
            self.loader.load()
            self.interpreter.preprocess()
            self.initializeVM()
            self.tokenizeInput()

            if self.debugMode:
                self.debugger.start()

            # Select the first rule. If there isn't one, the vm work has ended.
            if self.status == VM_STATUS.RUNNING:
                self.selectNextRule()
            while self.status == VM_STATUS.RUNNING:
                # Execute the rule selected until it ends.
                while self.status == VM_STATUS.RUNNING and self.PC < self.endAddress:
                    self.interpreter.execute(self.currentCodeSection[self.PC])

                self.processRuleEnd()
                # Select the next rule to execute.
                if self.status == VM_STATUS.RUNNING:
                    self.selectNextRule()

        except (Exception) as e:
            self.logger.exception(e)
            exit(1)

        self.terminateVM()

    def printCodeSections(self):
        """Print all the code sections for information or debugging purposes."""

        self.loader.printSection(self.code, "Code")
        self.loader.printSection(self.preprocessCode, "Preprocess")
        self.loader.printSection(self.rulesCode, "Rules", enum=True)
        self.loader.printSection(self.macrosCode, "Macros", enum=True)
Пример #49
0
    def shop_action_buy(self, centre_screen, tile_value):
        shop_type = tile_value[TILE_ITEM_TYPE]
        data = tile_value[TILE_ITEM_DATA]

        item_count = len(data) + 1  # last item is "Cancel" button
        DEBUG.log("Number of items in this shop: {}".format(item_count-1), level=1)
        button_rect = pg.Rect(0, 0, 300, 40)

        centre_screen.fill(BACKGROUND_COLOUR)
        item_button_list = []
        for item_index in range(item_count):
            y_pos = centre_screen.get_height()/2 - ((item_count/2-item_index) * button_rect.height)
            if item_index == item_count-1:
                item_name = "Cancel"
            else:
                item_name = data[item_index][ITEM_NAME]
                if shop_type is TILE_WEAPON_SHOP:
                    item_name += "   ATT:" + str(data[item_index][ITEM_POINT])
                elif shop_type is TILE_ARMOR_SHOP:
                    item_name += "   DEF:" + str(data[item_index][ITEM_POINT])
                item_name += "    " + str(data[item_index][ITEM_PRICE]) + "G"
            DEBUG.log("Item name: {}".format(item_name), level=2)
            item_button = Button(
                centre_screen, (centre_screen.get_width()/2, y_pos),
                item_name, 14, rect=button_rect, pos_offset=(TILE_WIDTH, TILE_HEIGHT))
            if item_name != "Cancel":
                try:
                    item_button.insert_picture((0, 0), os.path.join(ITEM_IMG_FILE_PATH, data[item_index][ITEM_FILENAME]))
                except RuntimeError as e:
                    DEBUG.log(e, level=1)
                    try:
                        item_button.insert_picture((0, 0), 'smile.png')
                    except:
                        raise Exception

            item_button.update()
            item_button_list.append(item_button)
        pg.display.update(centre_screen.get_rect(topleft=(TILE_WIDTH, TILE_HEIGHT)))

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    sys.exit()
                for button in item_button_list:
                    button.update_state(event)

            bought_item = None
            for button_index in range(len(item_button_list)):
                if item_button_list[button_index].buttonPressed:
                    DEBUG.log("{}'th button pressed".format(button_index+1), level=2)
                    if item_button_list[button_index].text == "Cancel":
                        DEBUG.log("Cancel clicked", level=2)
                        return
                    else:
                        bought_item = data[button_index]
                        DEBUG.log("Item {} clicked".format(bought_item[ITEM_NAME]), level=2)
                        break
            if bought_item:
                if bought_item[ITEM_PRICE] >= self.gold:
                    DEBUG.log("Item too expensive.", level=1)
                    self.show_textbox_at_centre(
                        centre_screen, "You don't have enough gold.", 1500)
                    self.shop_action_buy(centre_screen, data)
                elif shop_type is TILE_WEAPON_SHOP:
                    DEBUG.log("Buying weapon", level=1)
                    if self.weapon:
                        DEBUG.log("Already have weapon", level=2)
                        self.show_textbox_at_centre(
                            centre_screen, "You're already equipping a weapon. Sell it first.", 1500)
                        # recursion to go back to buy menu
                        self.shop_action_buy(centre_screen, tile_value)
                    else:
                        DEBUG.log("Bought weapon {}".format(bought_item[ITEM_NAME]))
                        self.weapon = bought_item
                        self.current_attack += bought_item[ITEM_POINT]
                        self.gold -= bought_item[ITEM_PRICE]
                        self.show_textbox_at_centre(
                            centre_screen, "You purchased {}!".format(bought_item[ITEM_NAME]), 1500)

                        self.action_result = ACTION_RESULT_SHOP_BUY
                elif shop_type is TILE_ARMOR_SHOP:
                    DEBUG.log("Buying armor", level=1)
                    if self.armor:
                        DEBUG.log("Already have armor", level=2)
                        self.show_textbox_at_centre(
                            centre_screen, "You're already equipping an armor. Sell it first.", 1500)
                        # recursion to go back to buy menu
                        self.shop_action_buy(centre_screen, tile_value)
                    else:
                        DEBUG.log("Bought weapon {}".format(bought_item[ITEM_NAME]))
                        self.armor = bought_item
                        self.current_defence += bought_item[ITEM_POINT]
                        self.gold -= bought_item[ITEM_PRICE]
                        self.show_textbox_at_centre(
                            centre_screen, "You purchased {}!".format(bought_item[ITEM_NAME]), 1500)

                        self.action_result = ACTION_RESULT_SHOP_BUY
                else:
                    raise TypeError("Invalid type of item")
                return
Пример #50
0
    def shop_action_sell(self, centre_screen):
        item_count = len(self.inventory) + 3  # weapon, armor, inventory, and cancel
        DEBUG.log("Number of items to sell: {}".format(item_count-1), level=1)
        button_rect = pg.Rect(0, 0, 300, 40)

        centre_screen.fill(BACKGROUND_COLOUR)
        item_button_list = []
        for item_index in range(item_count):
            y_pos = centre_screen.get_height()/2 - ((item_count/2-item_index) * button_rect.height)
            if item_index == item_count-1:
                item_name = "Cancel"
            elif item_index == 0:  # weapon
                if not self.weapon:
                    item_name = "Empty"
                else:
                    item_name = self.weapon[ITEM_NAME]
                    item_name += "   ATT:" + str(self.weapon[ITEM_POINT])
                    item_name += "    " + str(self.weapon[ITEM_PRICE]/4) + "G"
            elif item_index == 1:
                if not self.armor:
                    item_name = "Empty"
                else:
                    item_name = self.armor[ITEM_NAME]
                    item_name += "   DEF:" + str(self.armor[ITEM_POINT])
                    item_name += "    " + str(self.armor[ITEM_PRICE]/4) + "G"
            else:
                if not self.inventory[item_index-2]:
                    item_name = "Empty"
                else:
                    item_name = self.inventory[item_index-2][ITEM_NAME]
                    item_name += "    " + str(self.inventory[item_index-2][ITEM_PRICE]/4) + "G"
            DEBUG.log("Item name: {}".format(item_name), level=2)
            item_button = Button(
                centre_screen, (centre_screen.get_width()/2, y_pos),
                item_name, 14, rect=button_rect, pos_offset=(TILE_WIDTH, TILE_HEIGHT))
            if item_name is not "Cancel" and item_name is not "Empty":
                try:
                    if item_index == 0:
                        item_button.insert_picture((0, 0), os.path.join(ITEM_IMG_FILE_PATH, self.weapon[ITEM_FILENAME]))
                    elif item_index == 1:
                        item_button.insert_picture((0, 0), os.path.join(ITEM_IMG_FILE_PATH, self.armor[ITEM_FILENAME]))
                except RuntimeError as e:
                    DEBUG.log(e, level=1)
                    try:
                        item_button.insert_picture((0, 0), 'smile.png')
                    except:
                        raise Exception

            item_button.update()
            item_button_list.append(item_button)
        pg.display.update(centre_screen.get_rect(topleft=(TILE_WIDTH, TILE_HEIGHT)))

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    sys.exit()
                for button in item_button_list:
                    button.update_state(event)

            sold_item = None
            for button_index in range(len(item_button_list)):
                if item_button_list[button_index].buttonPressed:
                    DEBUG.log("{}'th button pressed".format(button_index+1), level=2)
                    if item_button_list[button_index].text == "Cancel":
                        DEBUG.log("Cancel clicked", level=2)
                        return
                    elif button_index == 0 and self.weapon:
                        sold_item = self.weapon
                        DEBUG.log("Item {} clicked".format(sold_item[ITEM_NAME]), level=2)
                        break
                    elif button_index == 1 and self.armor:
                        sold_item = self.armor
                        DEBUG.log("Item {} clicked".format(sold_item[ITEM_NAME]), level=2)
                        break
                    else:
                        #TODO: Implement other items
                        pass

            if sold_item:
                if sold_item is self.weapon:
                    DEBUG.log("Selling weapon {}".format(sold_item[ITEM_NAME]))
                    self.weapon = None
                    self.current_attack -= sold_item[ITEM_POINT]
                elif sold_item is self.armor:
                    DEBUG.log("Selling armor {}".format(sold_item[ITEM_NAME]))
                    self.armor = None
                    self.current_defence -= sold_item[ITEM_POINT]

                self.gold += sold_item[ITEM_PRICE]/4
                self.show_textbox_at_centre(
                    centre_screen, "You sold {}!".format(sold_item[ITEM_NAME]), 1500)

                self.action_result = ACTION_RESULT_SHOP_SELL
                return
Пример #51
0
def showOpCodes():
    print('{:<10}\t{:>10}\t{:>20}'.format('OpCode', 'Hex', 'Bin'))
    for name, member in OpCode.__members__.items():
        print('{:<10}\t{:>10}\t{:>20}'.format(name, hex(member.value), bin(member.value)))


if __name__ == '__main__':
    #showOpCodes()
    #showExampleEncodings()
    #print()
    #asm = Assembler('examples/factorial.asm')
    #asm = Assembler('examples/misc.asm')
    #asm = Assembler('examples/mul.asm')
    #asm = Assembler('examples/int.asm')
    asm = Assembler('examples/mov.asm')
    #asm = Assembler('examples/br.asm')
    #print('generated code:')

    program_memory = asm.parse()
    #for i in program_memory:
    #    print('0x{0:04X}\t0b{0:016b}'.format(i))

    cpu = Cpu(program_memory)
    seq = Seq(MPM, cpu)
#TODO: intreruperi
    dbg = Debugger(seq)
    dbg.attach()

    # print(cpu.__dict__)
    # print(seq.__dict__)
class RemoteDebugDialog(QtGui.QDialog, FORM_CLASS):
    def __init__(self, plugin, parent=None):
        """Constructor."""
        super(RemoteDebugDialog, self).__init__(parent)
        # Set up the user interface from Designer.
        # After setupUI you can access any designer object by doing
        # self.<objectname>, and you can use autoconnect slots - see
        # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html#widgets-and-dialogs-with-auto-connect
        self.setupUi(self)
        self._plugin = plugin
        self._debugger = Debugger()

    @pyqtSlot()
    def on_pydevd_path_but_clicked(self):
        pydevd_path = QFileDialog.getExistingDirectory(
            None, "Select pydev directory containing pydevd.py", self.pydev_path_ledit.text()
        )
        if not pydevd_path:
            return  # dialog canceled
        self.pydev_path_ledit.setText(pydevd_path)

    @pyqtSlot()
    def on_connect_but_clicked(self):
        self.setCursor(Qt.WaitCursor)
        try:
            self.start_debugging()
        finally:
            self.unsetCursor()

    @pyqtSlot()
    def on_exception_but_clicked(self):
        # Local vars for testing value display in debugger
        t01 = QgsApplication.pluginPath()
        t02 = QgsApplication.svgPaths()
        # t03 = QChar('x')
        t04 = QPoint(4, 5)
        t05 = QPointF(4.1, 5.1)
        t06 = QDate()
        t07 = QTime()
        t08 = QDir()
        t09 = QFile()
        t10 = QUrl()

        x01 = 42
        x02 = "fortytwo"

        raise Exception("Exception raised. Check local variables in your debugger.")

    def start_debugging(self):
        debugger = self._debugger.client(self.debugger_cbox.currentIndex())
        self._plugin.statusBar().showMessage(u"Connecting to remote debugger...")
        active = debugger.start_debugging(self._debugger_config())
        self._plugin.statusBar().showMessage("")
        if active:
            self.accept()
            self._plugin.push_message(u"Debugging connection activated", duration=2)
        else:
            self._plugin.push_message(u"Debugging connection failed", level=1, duration=2)

    def _debugger_config(self):
        return {"pydev_path": self.pydev_path_ledit.text()}
Пример #53
0
class MainWindow(QtGui.QMainWindow):
    """ Main window of the debugger"""
    FocusLine = pyqtSignal(str, int, name='FocusLine')
    def __init__(self):
        QtGui.QMainWindow.__init__(self)
        self.init_ui()
        self.save_restore_state(False)
        self.cfg_window = RunConfigWindow()
        self.about_dialog = AboutDialog()
        self.pty_stdout = PtyView(self.ui.commander)
        stdout_path = self.pty_stdout.get_file_path()

        self.debugger = Debugger(stdout_path, stdout_path, self.cfg_window.working_dir)
        self.ui.commander.set_tab_comp_handler(self.debugger.complete_tab)
        self.last_highlighted_editor = None
        self.my_listener = MyListeningThread(self.debugger.dbg, self.FocusLine)
        self.FocusLine.connect(self.do_focus_line)
        self.my_listener.StateChanged.connect(self.on_state_changed)
        self.my_listener.BPChanged.connect(self.on_bp_changed)
        self.debugger.listener = self.my_listener
        self.my_listener.start()
        self.opened_files = {}
        self.bp_locations = {}

        args = Qt.qApp.arguments()
        self.cfg_window.working_dir = os.getcwd()
        if len(args) > 1:
            self.do_exe_file_open(args[1])
        if len(args) > 2:
            self.cfg_window.arglist = [str(x) for x in args[2:]]

        logging.info('Ready')

    def init_ui(self):
        """initialize UI"""
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.ui.tabCodeEditor.clear()
        self.ui.tabCodeEditor.setTabsClosable(True)
        self.ui.tabCodeEditor.setTabShape(QtGui.QTabWidget.Triangular)

        # setup frame viewer dock
        action_frames = self.ui.frame_dock.toggleViewAction()
        self.ui.menuView.addAction(action_frames)
        action_frames.setCheckable(True)
        action_frames.setIcon(QIcon(":/icons/icons/frame.png"))
        self.ui.frame_viewer.set_focus_signal(self.FocusLine)

        self.tabifyDockWidget(self.ui.frame_dock, self.ui.value_dock)
        self.tabifyDockWidget(self.ui.value_dock, self.ui.bp_dock)
        self.ui.frame_dock.raise_()


        # setup source file tree dock
        action_source_tree = self.ui.file_tree_dock.toggleViewAction()
        self.ui.menuView.addAction(action_source_tree)
        action_source_tree.setCheckable(True)
        action_source_tree.setIcon(QIcon(":/icons/icons/directory.png"))
        self.ui.source_tree.set_open_file_signal(self.FocusLine)

        self.connect(self.ui.action_Open, QtCore.SIGNAL('triggered()'), self.do_exe_file_open)
        self.connect(self.ui.action_Run, QtCore.SIGNAL('triggered()'), self.do_run)
        self.connect(self.ui.action_StepOver, QtCore.SIGNAL('triggered()'), self.do_step_over)
        self.connect(self.ui.action_StepInto, QtCore.SIGNAL('triggered()'), self.do_step_into)
        self.connect(self.ui.action_StepOut, QtCore.SIGNAL('triggered()'), self.do_step_out)
        self.connect(self.ui.btn_frame_up, QtCore.SIGNAL('clicked()'), self.ui.frame_viewer.frame_up)
        self.connect(self.ui.btn_frame_down, QtCore.SIGNAL('clicked()'), self.ui.frame_viewer.frame_down)
        self.ui.frame_viewer.set_show_args(self.ui.chk_show_args)

        self.connect(self.ui.tabCodeEditor, QtCore.SIGNAL('tabCloseRequested(int)'),
                     self.close_tab)
        self.connect(self.ui.tabCodeEditor, QtCore.SIGNAL('currentChanged(int)'),
                     self.ui.source_tree.set_file_selected)
        self.connect(self.ui.tabCodeEditor, QtCore.SIGNAL('customContextMenuRequested(QPoint)'),
                     self.show_tab_context_menu)

        self.ui.action_Exit.triggered.connect(Qt.qApp.quit)
        self.ui.commander.commandEntered.connect(self.do_command)
        self.connect(self.ui.action_Run_Config, QtCore.SIGNAL('triggered()'), self.do_config)
        self.connect(self.ui.action_About, QtCore.SIGNAL('triggered()'), self.show_about)

        self.ui.frame_viewer.frame_changed.connect(self.ui.value_viewer.show_variables)

    def show_tab_context_menu(self, point):
        """ show context menu for tabs"""
        if point.isNull():
            return
        tab_bar = self.ui.tabCodeEditor.tabBar()
        idx = tab_bar.tabAt(point)
        if idx < 0:
            return
        editor = self.ui.tabCodeEditor.widget(idx)
        menu = QMenu(tab_bar)
        save_action = menu.addAction(QIcon(":/icons/icons/save.png"), 'Save', editor.save)
        save_action.setEnabled(editor.document().isModified())
        menu.exec_(tab_bar.mapToGlobal(point))

    def save_restore_state(self, is_save):
        """ save/restore state to/from config file"""
        if is_save:
            SETTINGS.setValue('geometry', self.saveGeometry())
            SETTINGS.setValue('windowState', self.saveState())
        else:
            self.restoreState(SETTINGS.value('windowState').toByteArray())
            self.restoreGeometry(SETTINGS.value('geometry').toByteArray())

    def closeEvent(self, event):
        """overrided. when close event is triggered"""
        self.save_restore_state(True)
        if not (self.debugger.curr_process and
                self.debugger.curr_process.is_alive):
            event.accept()
            return
        reply = QtGui.QMessageBox.question(self, 'Message', 'Quit?', \
                                           QMessageBox.Yes, QMessageBox.No)
        if reply == QtGui.QMessageBox.Yes:
            self.my_listener.quit()
            event.accept()
        else:
            event.ignore()

    def close_tab(self, idx):
        """ close a tab"""
        editor = self.ui.tabCodeEditor.widget(idx)
        if editor.document().isModified():
            reply = QtGui.QMessageBox.question(self, 'Message', \
                    editor.source_file + ' has been modified', \
                    QMessageBox.Save, QMessageBox.Discard, QMessageBox.Cancel)
            if reply == QtGui.QMessageBox.Cancel:
                return
            if reply == QMessageBox.Save:
                editor.save()

        #self.opened_files.remove()
        #editor.close
        self.close_src_file(editor.source_file)
        self.ui.tabCodeEditor.removeTab(idx)

    def show_about(self):
        """ show "About" window"""
        self.about_dialog.show()

    def do_config(self):
        """show run-config window"""
        self.cfg_window.show()

    def do_exe_file_open(self, exe_filename=None):
        """open executable"""
        if not exe_filename:
            exe_filename = QtGui.QFileDialog.getOpenFileName(self, \
                                                             self.tr('Open Executable'), \
                                                             '', self.tr('Executable Files (*)'))
        if exe_filename is None:
            return
        main_file, line = self.debugger.open_file(exe_filename)
        if main_file is not None:
            self.open_src_file(main_file.fullpath, line)
            self.ui.action_Run.setEnabled(True)
            self.my_listener.add_target_broadcaster(self.debugger.target.GetBroadcaster())
            self.ui.source_tree.set_root(main_file.GetDirectory(), False)
            self.exe_filename = exe_filename
        elif line == 0:
            logging.info('cannot find entry function')
        else:
            logging.info('error opening executable: %s', exe_filename)

    def do_focus_line(self, filename, line_no):
        """ slot for focusing line event"""
        # if line_no is 0, just focus the tab
        if not filename:
            editor = None
        else:
            filename = str(filename)
            logging.debug('Focusing [%s]:%d', filename, line_no)
            if filename not in self.opened_files:
                self.open_src_file(filename)
            editor = self.opened_files[filename]

        if editor is not None:
            self.ui.tabCodeEditor.setCurrentWidget(editor)
            if line_no:
                if self.last_highlighted_editor and self.last_highlighted_editor != editor:
                    # clear previous highlight
                    self.last_highlighted_editor.setExtraSelections([])
                editor.focus_line(line_no)
                self.last_highlighted_editor = editor

    def on_state_changed(self, state):
        """slot for state change event"""
        self.ui.statusBar.update_state(SBDebugger.StateAsCString(state))
        process = self.debugger.curr_process
        steppable = process is not None and process.is_alive and state == lldb.eStateStopped
        if steppable:
            self.ui.frame_viewer.show_frame_info(process)
        else:
            self.ui.frame_viewer.clear()

        if process is not None:
            self.ui.action_StepOver.setEnabled(steppable)
            self.ui.action_StepInto.setEnabled(steppable)
            self.ui.action_StepOut.setEnabled(steppable)
        self.ui.action_Run.setEnabled(state != lldb.eStateRunning)

        if state == lldb.eStateExited or state == lldb.eStateCrashed \
           or state == lldb.eStateSuspended:
            self.do_focus_line(None, -1)
        if state == lldb.eStateExited:
            if process is not None:
                logging.info('process exited: [%d]:%s', process.GetExitStatus(),
                             process.GetExitDescription())
            self.ui.frame_viewer.clear()
            return

    def on_bp_changed(self, breakpoint, bp_type):
        """ handler of breakpoing changing"""
        self.ui.bp_viewer.update_bp_info(self.debugger.dbg.GetSelectedTarget())
        # TODO: might be multiple locations for a BP
        filename, line_no = self.debugger.getBPLocationFromDesc(breakpoint)
        if not filename or not line_no:
            logging.warning('Cannot find location from BP')
            return

        if filename not in self.bp_locations:
            self.bp_locations[filename] = []

        if bp_type == lldb.eBreakpointEventTypeAdded:
            self.bp_locations[filename].append(line_no)

        elif bp_type == lldb.eBreakpointEventTypeRemoved:
            if line_no in self.bp_locations[filename]:
                self.bp_locations[filename].remove(line_no)
            else:
                logging.warning('removing non-existed BP ' + filename + ':' + str(line_no))
                # TODO: trigger a rescan of all BPs?
                return
        else:
            logging.debug('Unhandled BP event:' + str(bp_type))
            return

        if filename in self.opened_files:
            lna = self.opened_files[filename].line_number_area
            lna.breakpoints = self.bp_locations[filename]
            lna.repaint()

    def close_src_file(self, name):
        """ close a source file"""
        editor = self.opened_files[name]
        editor.setParent(None)
        del self.opened_files[name]

    def open_src_file(self, src_filename, line=0):
        """show the source file in editor"""
        if not os.path.isfile(src_filename) or not os.access(src_filename, os.R_OK):
            logging.warn('Unable to access ' + src_filename)
            return
        if src_filename in self.opened_files:
            return

        editor = CodeEditor(self.ui.tabCodeEditor)
        idx = self.ui.tabCodeEditor.addTab(editor, os.path.basename(src_filename))
        self.ui.tabCodeEditor.setTabToolTip(idx, src_filename)
        editor.open_source_file(src_filename)
        self.opened_files[str(src_filename)] = editor
        editor.line_number_area.BPToggled.connect(self.toggle_breakpoint)
        if line > 0:
            self.do_focus_line(src_filename, line)
        self.ui.source_tree.set_root(os.path.dirname(src_filename))
        #self.debugger.disassemble(src_filename)

    def toggle_breakpoint(self, line_no):
        """ control the bp toggling"""
        sender = self.sender()
        filename = sender.filename
        # it should trigger BPChanged signal.
        self.debugger.toggle_breakpoint(filename, line_no)


    def do_command(self, cmd):
        """ on command entered"""
        cmd = str(cmd)
        cmds = cmd.split()
        cmd0 = cmds[0].lower()
        cmd1 = ''

        if len(cmds) > 1:
            cmd1 = cmds[1].lower()
        if cmd0 == 'r' or cmd0 == 'run' or (cmd0 == 'process' and cmd1 == 'launch'):
            if cmd0[0] == 'r' or cmd0 == 'run':
                args = cmds[1:]
            else:
                args = cmds[2:]
            self.do_run(args, True)
            return
        msg = self.debugger.execute(cmd0, cmd)
        self.ui.commander.append(msg)

    def do_run(self, args=None, from_cmd=False):
        """ on run command entered"""
        util.save_run_config(self.exe_filename, self.cfg_window.arglist, self.cfg_window.working_dir)
        process = self.debugger.run(args, from_cmd, self.cfg_window.arglist)
        if process is not None:
            self.my_listener.add_process_broadcaster(process.GetBroadcaster())

    def do_step_over(self):
        """ on step over clicked"""
        self.debugger.next(True)

    def do_step_into(self):
        """ on step into clicked"""
        self.debugger.next(False)

    def do_step_out(self):
        """ on step out of frame"""
        self.debugger.step_out()
Пример #54
0
import os
import sys

from debugger import Debugger

if __name__ == '__main__':
    if os.getuid() != 0:
        print "Run as root"
        print "sudo python -m python-cheat.run <pid> [<pid> ...]"
        sys.exit(-1)

    if len(sys.argv) < 2:
        print "sudo python -m python-cheat.run <pid> [<pid> ...]"
        sys.exit(-1)

    cheater = Debugger()

    for pid in sys.argv[1:]:
        try:
            pid = int(pid)
            print "Adding %d" % pid
            cheater.addProcess(pid, False)
        except Exception as e:
            print "Invalid pid %s" % pid
            print e
            sys.exit(-1)
    try:
        import rlcompleter
        import atexit

        home = os.path.expanduser('~')
Пример #55
0
    def test_state_returns_flag_name_if_bit_is_set(self):
        debugger = Debugger()

        self.assertEqual("C", debugger.state(1 << CF, CF, "C"))
Пример #56
0
    def test_disableBreakpoint_sets_breakpoint_to_false(self):
        debugger = Debugger()
        debugger.setBreakpoint(0x2222)

        debugger.disableBreakpoint(0x2222)
        self.assertFalse(debugger.breakpoints[0x2222])
Пример #57
0
 def test_getAddr_correctly_parses_address(self):
     debugger = Debugger()
     addr = debugger.getAddr("0x1234")
     self.assertEqual(0x1234, addr)
Пример #58
0
    def test_clearBreakpoint_sets_breakpoint_to_false(self):
        debugger = Debugger()
        debugger.setBreakpoint(0x2222)

        debugger.clearBreakpoint(0x2222)
        self.assertTrue(0x2222 not in debugger.breakpoints)
Пример #59
0
    def show_status(self, centre_screen):
        centre_screen.fill(BACKGROUND_COLOUR)

        status_rect = pg.Rect(
            centre_screen.get_width()/3,
            centre_screen.get_height()/16,
            centre_screen.get_width()/3,
            centre_screen.get_height()*7/8
        )
        status_surface = centre_screen.subsurface(status_rect)
        status_surface.fill(GRAY)

        token_image = pg.transform.scale(self.token_image, (status_rect.width/3, status_rect.width/3))
        status_surface.blit(token_image, (status_rect.width/3, status_rect.height/12))

        current_height = 50+token_image.get_height()
        name_text_surf = pg.font.Font('freesansbold.ttf', 15)\
            .render(self.player_name, True, BLACK)
        status_surface.blit(name_text_surf, name_text_surf.get_rect().move(8, current_height))

        current_height += name_text_surf.get_height()+10
        level_text_surf = pg.font.Font('freesansbold.ttf', 15)\
            .render("Lv: {}".format(self.level), True, BLACK)
        status_surface.blit(level_text_surf, level_text_surf.get_rect().move(8, current_height))

        current_height += level_text_surf.get_height()+10
        health_text_surf = pg.font.Font('freesansbold.ttf', 15)\
            .render("HP: {}/{}".format(self.current_health, self.full_health), True, BLACK)
        status_surface.blit(health_text_surf, health_text_surf.get_rect().move(8, current_height))

        current_height += health_text_surf.get_height()+10
        attack_text_surf = pg.font.Font('freesansbold.ttf', 15)\
            .render("ATT: {} + {}".format(self.base_attack, self.current_attack-self.base_attack), True, BLACK)
        status_surface.blit(attack_text_surf, attack_text_surf.get_rect().move(8, current_height))

        current_height += attack_text_surf.get_height()+10
        defence_text_surf = pg.font.Font('freesansbold.ttf', 15)\
            .render("DEF: {} + {}".format(self.base_defence, self.current_defence-self.base_defence), True, BLACK)
        status_surface.blit(defence_text_surf, defence_text_surf.get_rect().move(8, current_height))

        current_height += defence_text_surf.get_height()+10
        weapon_text_surf = pg.font.Font('freesansbold.ttf', 15)\
            .render("Weapon:      {}".format(self.weapon[ITEM_NAME] if self.weapon else "None"), True, BLACK)
        status_surface.blit(weapon_text_surf, weapon_text_surf.get_rect().move(8, current_height))
        if self.weapon:
            try:
                weapon_image = pg.image.load(os.path.join(MONSTER_IMG_FILE_PATH, self.weapon[ITEM_FILENAME]))
            except RuntimeError as e:
                DEBUG.log(e, level=1)
                try:
                    weapon_image = pg.image.load('smile.png')
                except:
                    raise Exception
            finally:
                weapon_image = pg.transform.scale(weapon_image, (weapon_text_surf.get_height(), weapon_text_surf.get_height()))
                status_surface.blit(weapon_image, weapon_image.get_rect().move(80, current_height))

        current_height += weapon_text_surf.get_height()+10
        armor_text_surf = pg.font.Font('freesansbold.ttf', 15)\
            .render("Armor   :      {}".format(self.armor[ITEM_NAME] if self.armor else "None"), True, BLACK)
        status_surface.blit(armor_text_surf, armor_text_surf.get_rect().move(
            10, current_height))
        if self.armor:
            try:
                armor_image = pg.image.load(os.path.join(MONSTER_IMG_FILE_PATH, self.armor[ITEM_FILENAME]))
            except RuntimeError as e:
                DEBUG.log(e, level=1)
                try:
                    armor_image = pg.image.load('smile.png')
                except:
                    raise Exception
            finally:
                armor_image = pg.transform.scale(armor_image, (armor_text_surf.get_height(), armor_text_surf.get_height()))
                status_surface.blit(armor_image, armor_image.get_rect().move(80, current_height))

        pg.display.update(centre_screen.get_rect(topleft=(TILE_WIDTH, TILE_HEIGHT)))

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    sys.exit()
                elif event.type == pg.MOUSEBUTTONDOWN or (event.type == pg.KEYDOWN and event.key == pg.K_RETURN):
                    DEBUG.log("Exiting player status", level=2)
                    centre_screen.fill(BACKGROUND_COLOUR)
                    return
Пример #60
0
 def test_setBrakpoint_adds_a_breakpoint(self):
     debugger = Debugger()
     debugger.setBreakpoint(0x1111)
     self.assertTrue(debugger.breakpoints[0x1111])