6502/erc-c
1
0
Fork 0
mirror of https://github.com/pevans/erc-c.git synced 2024-12-21 08:30:55 +00:00
Code Issues Projects Releases Wiki Activity

Remove unused vm_reflect files

Browse Source
This commit is contained in:
Peter Evans 2018-04-07 11:05:26 -05:00
parent 4b0b8e1a89
commit ec719da2c5
2 changed files with 0 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
include/vm_reflect.h
View File

@ -1,72 +0,0 @@
#ifndef _VM_REFLECT_H_
#define _VM_REFLECT_H_
#include <stdio.h>
/*
* Some forward decls for vm_reflect
*/
struct vm_reflect;
typedef struct vm_reflect vm_reflect;
/*
* A reflect function, mostly helpful in the struct definition itself as
* well as a function decls and defns. A reflect function would accept a
* reflect object and use that to figure out what it's talking about.
*/
typedef void (*vm_reflect_fn)(vm_reflect *);
struct vm_reflect {
/*
* These are the machine and CPU objects that the reflect system
* would want to work with.
*/
void *machine;
void *cpu;
/*
* Where information that we print will go to.
*/
FILE *stream;
/*
* Print out information about the machine and CPU, respectively.
*/
vm_reflect_fn cpu_info;
vm_reflect_fn machine_info;
/*
* This function will pause or resume operation of the virtual machine.
*/
vm_reflect_fn pause;
/*
* Turn on, or off, disassembly of the instructions being executed.
*/
vm_reflect_fn disasm;
/*
* Eventually we will have the ability to load and save state to a
* file mechanism (probably not the one defined as `stream` above).
*/
#if 0
vm_reflect_fn save_state;
vm_reflect_fn load_state;
#endif
};
/*
* Allow us to either declare or define a new reflect function that can
* be hooked into a reflect struct
*/
#define REFLECT(x) \
void x(vm_reflect *ref)
extern int vm_reflect_cpu_info(vm_reflect *);
extern int vm_reflect_disasm(vm_reflect *);
extern int vm_reflect_machine_info(vm_reflect *);
extern int vm_reflect_pause(vm_reflect *);
extern vm_reflect *vm_reflect_create();
extern void vm_reflect_free(vm_reflect *);
#endif

64
src/vm_reflect.c
View File

@ -1,64 +0,0 @@
/*
* vm_reflect.c
*
* Here we have support for reflection, or perhaps meta-manipulation, of
* the virtual machine. You can create hooks to stop the machine, or
* disassemble opcodes from it, or handle state.
*/
#include <stdlib.h>
#include "log.h"
#include "vm_di.h"
#include "vm_reflect.h"
/*
* Create a new vm_reflect struct with the given machine, cpu and
* stream.
*/
vm_reflect *
vm_reflect_create()
{
vm_reflect *ref;
ref = malloc(sizeof(vm_reflect));
if (ref == NULL) {
log_crit("Could not allocate memory for vm_reflect");
return NULL;
}
ref->machine = vm_di_get(VM_MACHINE);
ref->cpu = vm_di_get(VM_CPU);
ref->stream = vm_di_get(VM_OUTPUT);
ref->cpu_info = NULL;
ref->machine_info = NULL;
ref->pause = NULL;
ref->disasm = NULL;
return ref;
}
/*
* Free a vm_reflect struct that we created earlier
*/
void
vm_reflect_free(vm_reflect *ref)
{
// Not much to this--just going to free the main memory chunk
free(ref);
}
/*
* All of the reflect functions do essentially the same thing--at least,
* right now they do.
*/
#define REFLECT_HANDLER(x) \
int vm_reflect_##x(vm_reflect *ref) { \
if (ref == NULL) ref = (vm_reflect *)vm_di_get(VM_REFLECT); \
if (ref->x == NULL) return ERR_INVALID; ref->x(ref); return OK; }
REFLECT_HANDLER(cpu_info); // ignore docblock
REFLECT_HANDLER(machine_info); // ignore docblock
REFLECT_HANDLER(pause); // ignore docblock
REFLECT_HANDLER(disasm); // ignore docblock