yasp / yasp Goto Github PK

Debugger:

• Hide debugger-tabs (=> 100% height of breadboard)
• Remove margin of debugger-dialog
• Resize buttons

Editor:

• swipe for label-list
• quickhelp

General:

• see if we're fast enough

Currently the help-search is full-text. There should be an option to search for an command-name only.

Depends on #9.

Implement a LED-Matrix which can be controlled via an 2 or 3 pin bus.

        MOV     b0, 1
        CALL    someSub   ; stopped here
        MOV     w0, 5

1. Debugger is stopped at CALL.
2. "Step over"
3. Temporary breakpoint is set at MOV w0, 5
4. Continue emulation
5. Remove breakpoint

CALL someSub
MOV w0, 1
BREAK

someSub:
MOV b0, 43  ; stopped here
MOV b1, 42
RET

1. debugger is stopped at MOV b0, 43
2. "Step out"
3. emulation continues until RET, so it stops at MOV w0, 1

The indentation is not forced when pasting in code from the clipboard which can lead to inconsistent formatting which has to be fixed by hand.

When hovering a register in the source-listing of the debugger, the current value should be shown.

Class in CodeMirror: cm-variable

Fix: da6aa6a

Depends on #9.

UI-Mockup: http://jsbin.com/celofuxiho/7/edit

Implement the user-interface of conditional breakpoints. The backend-code in the emulator is already finished, tested and documented.

Currently step-back only works with previous states which have been executed by stepping. If the emulator runs, is stopped and then a step-back is attempted, nothing happens.
To achieve this, yasp must remember the state of the last 20 (?) ticks. Since this must happen in realtime, this state must be kept in the emulator or emulator_backend and cannot go through the communicator each tick.

Values that need to be saved:

• rom
• ram
• pc
• sp
• pin states
• pin pwm states
• interrupt mask
• tick counter
• flags

See this for copying the typed arrays (ram, rom): http://stackoverflow.com/a/10101213/2486196

Just like step saves the current emulator-state, there should be a "Save State"-button. The new state gets added to an list from which the user can load it again.

Currently all the breakpoint-changes are sent to the emulator twice. This is because yasp.debugger.breakpoints.offsetBreakpointsChanged() is called twice by the CodeMirror-change-event. Most likely because there are 2 editors in yasp (one main and one in the debugger).

Go into single-stepping-mode (break or step).

1. step over a normal instruction (e.g. MOV)
   • step refreshes ROM/RAM/registers view
   • no gray overlay is shown (expected)
2. step over a jump-instruction (e.g. JMP)
   • step refreshes ROM/RAM/registers view
   • a gray overflow is shown for the duration of the jump (~50ms) (unexcepted)

The emulator probably reports a wrong state (e.g. not break) while jumping to the debugger which causes it to show the overlay.

UI prototype: http://jsbin.com/gegonefova/1/edit

In unit-tests the reason for a break()-call should also be checked. For example, in DIV_ww.js#L31-L35, the test should not only check for running = false, but also for reason = 'divide_by_zero'.

Rough UI draft: http://jsbin.com/dofepakoqi/3/edit?js,output

Force the indentation parameters and comments:

        MOV     b0, b1  ; foo

For speed reasons the emulator.tick()-function caches all parsed instructions in emulator.commandCache. When the ROM is changed via emulator.writeROM() part of this cache is cleared. When a big part of the ROM is overwritten by the load()-function (invoked by LOAD-message), the whole commandCache is cleared. Instead only the overwritten parts should be cleared.

• move command-cache-clearing-code into its own function: clearCommandCache(start, len). start is the first byte which has been changed, len the number of bytes which have been changed.
• use clearCommandCache() in both writeRom() and load()
• tests for load() which check for the cleared cache (writeRom() already has these)
• tests for clearCommandCache()

The register w0 shares its bytes with b0 and b1, so the combined value w0 should be shown in the registers-list if either of the byte-registers is used. Same for using w0 (shows b0 and b1).

yasp.disasm.getCommand currently builds up an array of bytes to hand over to extractBits. This is done for every attempt to disassemble an command from ROM. Instead extractBits should have an optional offset parameter, which defines the byte to start at. getCommand should then just hand over the whole ROM-array with the parsing offset.
This saves one array instance for every command in ROM.
Not critical since we cache disassembled commands, but would still give a speed boost for self-modifying code or disabled-cache mode.

Move all IO-Code (including PWM) out of the emulator so that other classes, such as hardware, can use it. This also enables the code to be tested more easily.

Class: IOBank

{
  "pins": []
}

Class: Pin

{
  "nr":    0,    // pin number
  "type":  "",   // "adc" or "gpio"
  "mode":  "",   // "in" or "out"
  "state": 0,    // 0-255
  "pwm":   false // PWM simulation
}

The emulators PWM-implementation, updatePwm(), is currently untested.

The emulator has to implement the message "EXECUTE" and the debugger needs to implement this in the UI.

Depends on #8.

• breadboard: backend-code (listening to and sending state changes to the emulator)
• breadboard: UI-Code (showing pins on hover)
• hardware: add description for each pin in hardware-definitions
• hardware: rewrite state-handling in hardware