## PDA Debugger Protocol Reference

### clear

Clears any breakpoint set on given line

       C: clear {line}
       R: ok

### data

Retrieves data stack information

       C: data {thread_id}
       R: {value 1}|{value 2}|{value 3}|...|

    Errors:
       error: invalid thread

### drop

Returns from the current frame without executing the rest of instructions.

    If VM running:
       C: drop {thread_id}
       R: ok
       E: resumed {thread_id} drop
       E: suspended {thread_id} drop

    If VM suspended:
       C: drop {thread_id}
       R: ok
       E: vmresumed drop
       E: vmsuspended {thread_id} drop

    Errors:
       error: invalid thread

### eval

Sets what events cause the execution to stop.

       C: eval {thread_id} {instruction}%20{parameter}|{instruction}%20{parameter}|...
       R: ok
       E: resumed {thread_id} client
       E: evalresult result
       E: suspended {thread_id} eval

    Errors:
       error: invalid thread
       error: cannot evaluate while vm is suspended
       error: thread running

### eventstop

Sets what events cause the execution to stop.

       C: eventstop {event_name} {0|1}
       R: ok
       ...
       E: suspended event {event_name}

### exit

Instructs the debugger to exit.

       C: exit
       R: ok

### popdata

Pops the top value from the data stack

       C: popdata {thread_id}
       R: ok

    Errors:
       error: invalid thread

### pushdata

Pushes the given value on top of the data stack.

       C: pushdata {thread_id} {value}
       R: ok

    Errors:
       error: invalid thread

### resume

Resumes the execution of a single thread. Can be issued only if the virtual machine is running.

       C: resume {thread_id}
       R: ok
       E: resumed {thread_id} client

    Errors:
       error: invalid thread
       error: cannot resume thread when vm is suspended
       error: thread already running

### set

Sets a breakpoint at given line

    Suspend a single thread:
       C: set {line_number} 0
       R: ok
       C: resume {thread_id}
       E: resumed {thread_id} client
       E: suspended {thread_id} breakpoint line_number

    Suspend the VM:
       C: set {line_number} 1
       R: ok
       C: vmresume
       E: vmresumed client
       E: vmsuspended {thread_id} breakpoint line_number

### setdata

Sets a data value in the data stack at the given location

       C: setdata {thread_id} {index} {value}
       R: ok

    Errors:
       error: invalid thread

### setvar

Sets a variable value

       C: setvar {thread_id} {frame_number} {variable} {value}
       R: ok

    Errors:
       error: invalid thread

### stack

Retrieves command stack information

       C: stack {thread_id}
       R: {file}|{line}|{function}|{var_1}|{var_2}|...#{file}|{line}|{function}|{var_1}|{var_2}|...#...

    Errors:
       error: invalid thread

### step

Executes next instruction

    If VM running:
       C: step {thread_id}
       R: ok
       E: resumed {thread_id} client
       E: suspended {thread_id} step

    If VM suspended:
       C: step {thread_id}
       R: ok
       E: vmresumed client
       E: vmsuspended {thread_id} step

    Errors:
       error: invalid thread

### stepreturn

Executes instructions until the current subroutine is finished

    If VM running:
       C: stepreturn {thread_id}
       R: ok
       E: resumed {thread_id} client
       E: suspended {thread_id} step

    If VM suspended:
       C: stepreturn {thread_id}
       R: ok
       E: vmresumed client
       E: vmsuspended {thread_id} step

    Errors:
       error: invalid thread

### suspend

Suspends execution of a single thread. Can be issued only if the virtual machine is running.

       C: suspend {thread_id}
       R: ok
       E: suspended {thread_id} client

    Errors:
       error: invalid thread
          error: vm already suspended
       error: thread already suspended

### threads

Retrieves the list of active threads

       C: threads
       R: {thread id} {thread id} ...

### var

Retrieves variable value

       C: var  {thread_id} {frame_number} {variable_name}
       R: {variable_value}

    Errors:
       error: invalid thread
       error: variable undefined

### watch

Sets a watchpoint on a given variable

       C: watch {function}::{variable_name} {watch_operation}
       R: ok
       C: resume
       R: resumed client
       E: suspended watch {watch_operation} {function}::{variable_name}

The `watch_operation`value can be:

- 0 - no watch
- 1 - read watch
- 2 - write watch
- 3 - both, etc.

### vmresume

Resumes the execution of the whole virtual machine

       C: vmresume
       R: ok
       E: vmresumed client

    Errors:
       error: vm already running

### vmsuspend

Suspends the execution of the whole virtual machine

       C: vmsuspend
       R: ok
       E: vmsuspended client

    Errors:
       error: thread already suspended

``