pushfoo / eightdad Goto Github PK

At the moment, breakpoints are only implemented in the arcade frontend in the update method and constructor, and even then only hackily.

This should be moved or re-implemented in a better way. It's currently in the way of #63 , and will likely be partially torn out for the time being.

• 3xkk , Skip next instruction if Vx = kk.
• 4xkk, Skip next instruction if Vx != kk.
• 6xkk, Set Vx = kk
• 7xkk, Set Vx = Vx + kk.
• Cxkk, Set Vx = random byte AND kk.

One of the linters, maybe black. There are places where the code is ugly, and definitely places where PEP-8 is currently not met.

From rom doc:

E 12: 8XYE verify that VF is set to the MSB (most significant bit or most left) before the shift and VF does not take value 0 every time

From the pytest documentation:

To get all combinations of multiple parametrized arguments you can stack parametrize decorators:

Currently using product calls in multiple places. It works ok, but maybe it should be fixed. Get advice on this.

A BSD for now until I get something better figured out.

Need to decide where to put it as well. Is the logging functionality what I want to use? How much thought do I want to put into curses/urwid at the moment?

• Ex9E - Skip the next instruction if the key with the value in Vx is pressed
• ExA1 - Skip the next instruction if the key with value in VX ISN'T pressed
• Fx0A - LD Vx, K - wait until a key is pressed, then put its value in Vx. VM performs no instructions until a key has been received.

#24 added helpers to verify that registers were not altered from their initial zero state. There may be older tests that could use that to improve brevity and clarity.

Installing later library versions seems to have broken the tests. they can no longer find things placed in a subdirectory of tests. Most fixes seem to rely on conftest.py fixes and/or plugins.

This condition puts the interpreter past the end of memory, which needs some sort error handling to be implemented. Maybe set an error flag? raise exception?
this should probably be thought of in concert with debugger / UI. Asking the emudev discord suggests that it's rare in practice, so it might not be worth handling immediately.

• Fx55 - LD [I], Vx - Store V0 through Vx to mem, starting the write at position in I register
• Fx65 - LD Vx, [I] - Read mem into V0-VX, starting the read at the position in I register

It would allow centralizing showing errors instead of the mess at the end of each subtype function.

• 00EE - CLR, turn all pixels in the screen off
• Dxyn - DRW Vx, Vy, nibble - draw sprite of length n to the screen at position (VX, VY)

doesn't need to include CLI args, just enough to get the bestcoder & corax89 test roms working.

• 8xy1 - Set Vx = Vx OR Vy.
• 8xy2 - Set Vx = Vx AND Vy.
• 8xy3 - Set Vx = Vx XOR Vy.
• 8xy4 - Set Vx = Vx + Vy, set VF = 1 if sum greater than 255
• 8xy5 - Set Vx = Vx - Vy, VF = 1 if Vx > Vy, else VF = 0
• 8xy6 - shift right . If the least-significant bit of Vx is 1, then VF is set to 1, otherwise 0. Then Vx is divided by 2.
• 8xy7 - If Vy > Vx, then VF is set to 1, otherwise 0. Then Vx is subtracted from Vy, and the results stored in Vx.
• 8xyE - shift left - If the most-significant bit of Vx is 1, then VF is set to 1, otherwise to 0. Then Vx is multiplied by 2.

Magic numbers bit me and i forgot i wasn't using a 16 bit value array for my memory storage. Whoops.

• 5xy0 - Skip next instruction if Vx ==Vy
• 9xy0 - Skip next instruction if Vx != Vy.

Used "<" in the bytecode tests instead of ">" for big endan. Tests should use clearer language to specify endianness, and implementation needs to be fixed.

They are getting messy with a lot of tests under the test folder.

• 00EE, return from subroutine: pop location off of the stack and set pc to it
• 1nnn, jump to nnn: set pc to nnn
• 2nnn, call routine at nnn: push current location to stack, jump to nnn
• Annn, set I to nnn
• Bnnn, Jump to nnn + v0: set pc to nnn + v0

8xy0 - Set Vx = Vy

Use argparse or another better library rather than the hacky sys arg method.

Other Chip-8 implementations (Octo) run multiple instructions per frame. Arcade appears to be limited to screen refresh rate for the number of frames it can render at once, so getting good performance means skipping frames for redraw is a must.

Thedoc on enums outlines IntFlag and Flag types. It's worth checking if they're hashable & satisfy any other needs for use in the bytecode decoder.

The standard for the Program Counter across architectures is that it points to the next instruction to be executed. The current implementation runs correctly, but it doesn't follow this standard. This makes it confusing for other people to read and should be fixed.

This should apply to the instruction decoder and maybe a few fields on the VM. For the instruction decoder, there might be a subclass of clamped that uses a mask as a constructor argument when initializing the descriptor. A more complicated implementation might be able to use a bit-mask as the only argument and infer the min and max from there, if also given a negatives allowed or minimum argument.

Maybe something like the following?

class Instruction:
    x : int = MaskedField(mask=0x0F00, signed=False)
    
    def __init__(self, **kwargs):

The result should be shorter and cleaner code than the current property and clamping decorators used.

Use asterisks or pounds to start, maybe use tricks right away if simple tests of them work.

Keymapping needs to be added to get the full range of input from the frontends. The local arcade frontend is working again now that paths are fixed, so this shouldn't be too hard of an addition.

Right now, decode sniffs not only the type of instruction, but every variable that the class has. Variables are also created locally that may not be needed.

In the future, a lazier approach may be better. If a memoryview and/or bytearray are used to store the location of the passed bytestring, then changes can be written directly to the underlying bytes variables, and values can be read only as needed. No more _lo_byte or _hi_byte as discrete variables, just access to them through properties. The downside is that this might eliminate caching of variables that would be useful during execution.

Figuring out how to cache object properties efficiently in python may be worth looking into.

#9 adds setters to the bytecode instruction class. New tests will use that to be cleaner, but older tests should be fixed to use it as well so they are more legible.

This test appears to check whether integers wrap correctly:

#test 8xy4
y := 26
drawop im8 im4
i := imagefalse
v6 := 140
v7 := 140
v7 += v6
if v7 == 24 then i := imageok
sprite x2 y 4

It's probably broken clamping. It may also require altering tests.

Doesn't need to be efficient, just drawing shapes, maybe without a shapelist.

Currently fails, may be due to test breaking with spec rather than the code being broken as the corax rom has no issue with this.

wrapping bit ops in functions inside the tests isn't as elegant as things could be:

def prep_and_execute_ixii_instruction(
        vm: Chip8VirtualMachine,
        x_value: int,
        lo_byte: int,
        type_nibble: int = 0xF0,
        load_point=EXECUTION_START
):
    """
    Set a memory location to an ixii instruction & execute it
    This helper is useful for testing.
    :param vm: the vm to set memory on
    :param x_value: the x value that will specify the v-register targeted
    :param lo_byte: the last two hex digits of the instruction
    :param type_nibble: sets the type for this var
    :param load_point: where the instruction will be loaded into memory
    :return:
    """
    if load_point != EXECUTION_START:
        vm.program_counter = load_point

    vm.memory[load_point] = lo_byte
    vm.memory[load_point + 1] = type_nibble | x_value
    vm.tick(TWO_HUNDREDTH)

Code like this would be better encapsulated in setters on the instruction class in bytecode.py instead of clogging up test file space.

It probably got in there by accident when testing things.

• Fx07 - LD Vx, DT - Set Vx = DT
• Fx15 - LD DT, Vx - Set DT = vX
• Fx18 - LD ST, Vx - Set ST = Vx.
• Fx1e - I += VX
• Fx29 - LD F, Vx - Set I = location of sprite for digit Vx.
• Fx33 - LD B, Vx - Store BCD of Vx at I, I + 1, I + 2