int vm_hw_lua_cpu_handle_irq_get(lua_State* L)
{
// Table is at 1, key is at 2.
vm_t* vm = vm_hw_lua_cpu_extract_cpu(L, 1);
uint16_t idx;
bstring enabled = bfromcstr("enabled");
if (lua_isstring(L, 2) && biseqcstrcaseless(enabled, lua_tostring(L, 2)))
{
lua_pushboolean(L, vm->queue_interrupts);
return 1;
}
else if (!lua_isnumber(L, 2))
{
lua_pushstring(L, "irq access must be by numeric value (use array operator) or \"enabled\" field");
lua_error(L);
return 0;
}
idx = (uint16_t)lua_tonumber(L, 2);
if (idx < 1 || idx > vm->irq_count)
{
lua_pushstring(L, "irq access out of bounds");
lua_error(L);
return 0;
}
lua_pushnumber(L, vm->irq[idx]);
return 1;
}
///
/// Performs preprocessing.
///
void ppimpl(freed_bstring filename, int line, freed_bstring lang, has_t has_input, pop_t input, push_t output)
{
state_t state;
list_init(&state.cached_input);
list_init(&state.cached_output);
list_init(&state.handlers);
list_init(&state.scopes);
list_attributes_comparator(&state.cached_input, list_comparator_char_t);
list_attributes_comparator(&state.cached_output, list_comparator_char_t);
list_attributes_copy(&state.cached_input, list_meter_char_t, false);
list_attributes_copy(&state.cached_output, list_meter_char_t, false);
list_attributes_hash_computer(&state.cached_input, list_hashcomputer_char_t);
list_attributes_hash_computer(&state.cached_output, list_hashcomputer_char_t);
state.has_input = has_input;
state.input = input;
state.output = output;
state.current_line = line;
state.current_filename = bstrcpy(filename.ref);
state.default_filename = bfromcstr("<unknown>");
state.in_single_string = false;
state.in_double_string = false;
if (biseqcstrcaseless(lang.ref, "asm"))
{
ppimpl_asm_line_register(&state);
ppimpl_asm_expr_register(&state);
ppimpl_asm_define_register(&state);
ppimpl_asm_include_register(&state);
ppimpl_asm_lua_register(&state);
ppimpl_asm_init(&state);
}
else if (biseqcstrcaseless(lang.ref, "c"))
{
ppimpl_c_line_register(&state);
ppimpl_c_expr_register(&state);
ppimpl_c_define_register(&state);
ppimpl_c_include_register(&state);
ppimpl_c_init(&state);
}
ppimpl_process(&state);
bautodestroy(lang);
bautodestroy(filename);
}
static inline void check_should_close(Connection *conn, Request *req)
{
if(req->version && biseqcstr(req->version, "HTTP/1.0")) {
debug("HTTP 1.0 request coming in from %s", conn->remote);
conn->close = 1;
} else {
bstring conn_close = Request_get(req, &HTTP_CONNECTION);
if(conn_close && biseqcstrcaseless(conn_close, "close")) {
conn->close = 1;
} else {
conn->close = 0;
}
}
}
struct lua_hardware* vm_hw_lua_load(vm_t* vm, bstring name)
{
bstring path, modtype;
struct lua_hardware* hw;
int module, hwinfo;
// Calculate full path to file.
path = osutil_getarg0path();
#ifdef _WIN32
bcatcstr(path, "modules\\");
#else
bcatcstr(path, "/modules/");
#endif
bconcat(path, name);
// Create the new lua hardware structure.
hw = malloc(sizeof(struct lua_hardware));
hw->vm = vm;
hw->state = lua_open();
assert(hw->state != NULL);
luaL_openlibs(hw->state);
luaX_loadexpressionlib(hw->state);
// Execute the code in the new Lua context.
if (luaL_dofile(hw->state, path->data) != 0)
{
printf("lua error was %s.\n", lua_tostring(hw->state, -1));
// Return NULL.
lua_close(hw->state);
free(hw);
bdestroy(path);
return NULL;
}
// Load tables.
lua_getglobal(hw->state, "MODULE");
module = lua_gettop(hw->state);
lua_getglobal(hw->state, "HARDWARE");
hwinfo = lua_gettop(hw->state);
// Ensure both tables were provided.
if (lua_isnoneornil(hw->state, module) || lua_isnoneornil(hw->state, hwinfo))
{
printf("failed to load hardware from %s.\n", path->data);
// Return NULL.
lua_close(hw->state);
free(hw);
bdestroy(path);
return NULL;
}
// Check to see whether the module is
// a hardware module.
lua_getfield(hw->state, module, "Type");
modtype = bfromcstr(lua_tostring(hw->state, -1));
if (!biseqcstrcaseless(modtype, "Hardware"))
{
// Return NULL.
lua_pop(hw->state, 1);
lua_close(hw->state);
free(hw);
bdestroy(modtype);
bdestroy(path);
return NULL;
}
lua_pop(hw->state, 1);
bdestroy(modtype);
// Store information into the Lua
// hardware structure.
lua_getfield(hw->state, hwinfo, "ID");
lua_getfield(hw->state, hwinfo, "Version");
lua_getfield(hw->state, hwinfo, "Manufacturer");
hw->device.id = (uint32_t)lua_tonumber(hw->state, lua_gettop(hw->state) - 2);
hw->device.version = (uint16_t)lua_tonumber(hw->state, lua_gettop(hw->state) - 1);
hw->device.manufacturer = (uint32_t)lua_tonumber(hw->state, lua_gettop(hw->state));
lua_pop(hw->state, 3);
printf("hardware loaded ID: %u, Version: %u, Manufacturer: %u.\n", hw->device.id, hw->device.version, hw->device.manufacturer);
// Register the hardware.
hw->device.handler = &vm_hw_lua_interrupt;
hw->device.userdata = hw;
vm_hw_register(vm, hw->device);
// Register the hooks.
hw->cycle_id = vm_hook_register(vm, &vm_hw_lua_cycle, HOOK_ON_POST_CYCLE, hw);
hw->write_id = vm_hook_register(vm, &vm_hw_lua_write, HOOK_ON_WRITE, hw);
// Pop tables from stack.
lua_pop(hw->state, 2);
// Return new hardware.
return hw;
}
int main(int argc, char* argv[])
{
CURL* curl;
bstring command;
bstring name;
bstring modpath;
int all;
// Define arguments.
struct arg_lit* show_help = arg_lit0("h", "help", "Show this help.");
struct arg_str* cmdopt = arg_str1(NULL, NULL, "<command>", "The command; either 'search', 'install', 'uninstall', 'enable' or 'disable'.");
struct arg_str* nameopt = arg_str0(NULL, NULL, "<name>", "The name of the module to search for, install, uninstall, enable or disable.");
struct arg_lit* all_flag = arg_lit0("a", "all", "Apply this command to all available / installed modules.");
struct arg_lit* verbose = arg_litn("v", NULL, 0, LEVEL_EVERYTHING - LEVEL_DEFAULT, "Increase verbosity.");
struct arg_lit* quiet = arg_litn("q", NULL, 0, LEVEL_DEFAULT - LEVEL_SILENT, "Decrease verbosity.");
struct arg_end* end = arg_end(20);
void* argtable[] = { show_help, cmdopt, all_flag, nameopt, verbose, quiet, end };
// Parse arguments.
int nerrors = arg_parse(argc, argv, argtable);
if (nerrors != 0 || show_help->count != 0 || (all_flag->count == 0 && nameopt->count == 0))
{
if (all_flag->count == 0 && nameopt->count == 0)
printd(LEVEL_ERROR, "error: must have either module name or -a.");
if (show_help->count != 0)
arg_print_errors(stderr, end, "mm");
fprintf(stderr, "syntax:\n dtmm");
arg_print_syntax(stderr, argtable, "\n");
fprintf(stderr, "options:\n");
arg_print_glossary(stderr, argtable, " %-25s %s\n");
arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
return 1;
}
// Set verbosity level.
debug_setlevel(LEVEL_DEFAULT + verbose->count - quiet->count);
// Show version information.
version_print(bautofree(bfromcstr("Module Manager")));
// Set argument 0 and convert parameters.
osutil_setarg0(bautofree(bfromcstr(argv[0])));
command = bfromcstr(cmdopt->sval[0]);
name = bfromcstr(nameopt->sval[0]);
// Initialize curl or exit.
curl = curl_easy_init();
if (!curl)
{
printd(LEVEL_ERROR, "unable to initialize curl.\n");
return 1;
}
// Ensure module path exists.
modpath = osutil_getmodulepath();
if (modpath == NULL)
{
printd(LEVEL_ERROR, "module path does not exist (searched TOOLCHAIN_MODULES and modules/).\n");
return 1;
}
bdestroy(modpath);
// Convert all flag.
all = (all_flag->count > 0);
// If all is set, set the name back to "".
if (all)
bassigncstr(name, "");
// If the name is "all" or "*", handle this as the all
// boolean flag.
if (biseqcstr(name, "all") || biseqcstr(name, "*"))
{
bassigncstr(name, "");
all = 1;
printd(LEVEL_WARNING, "treating name as -a (all) flag");
}
if (biseqcstrcaseless(command, "search") || biseqcstrcaseless(command, "se"))
return do_search(curl, name, all);
else if (biseqcstrcaseless(command, "install") || biseqcstrcaseless(command, "in"))
{
if (all)
return do_install_all(curl);
else
return do_install(curl, name);
}
else if (biseqcstrcaseless(command, "uninstall") || biseqcstrcaseless(command, "rm"))
{
if (all)
return do_uninstall_all(curl);
else
return do_uninstall(curl, name);
}
else if (biseqcstrcaseless(command, "enable") || biseqcstrcaseless(command, "en"))
{
if (all)
return do_enable_all(curl);
else
return do_enable(curl, name);
}
else if (biseqcstrcaseless(command, "disable") || biseqcstrcaseless(command, "di") || biseqcstrcaseless(command, "dis"))
{
if (all)
return do_disable_all(curl);
else
return do_disable(curl, name);
}
else
{
printd(LEVEL_ERROR, "unknown command (must be search, install, uninstall, enable or disable).");
return 1;
}
return 0;
}
struct lua_debugst* dbg_lua_load(bstring name)
{
bstring path, modtype;
struct lua_debugst* ds;
int module;
// Calculate full path to file.
path = osutil_getmodulepath();
bconchar(path, '/');
bconcat(path, name);
// Create the new lua preprocessor structure.
ds = malloc(sizeof(struct lua_debugst));
ds->state = lua_open();
assert(ds->state != NULL);
luaL_openlibs(ds->state);
luaX_loadexpressionlib(ds->state);
// Load globals.
dcpu_lua_set_constants(ds->state);
// Execute the code in the new Lua context.
if (luaL_dofile(ds->state, path->data) != 0)
{
printd(LEVEL_ERROR, "lua error was %s.\n", lua_tostring(ds->state, -1));
// Return NULL.
lua_close(ds->state);
free(ds);
bdestroy(path);
return NULL;
}
// Load tables.
lua_getglobal(ds->state, "MODULE");
module = lua_gettop(ds->state);
// Ensure module table was provided.
if (lua_isnoneornil(ds->state, module))
{
printd(LEVEL_ERROR, "failed to load debugger module from %s.\n", path->data);
// Return NULL.
lua_close(ds->state);
free(ds);
bdestroy(path);
return NULL;
}
// Check to see whether the module is
// a preprocessor module.
lua_getfield(ds->state, module, "Type");
modtype = bfromcstr(lua_tostring(ds->state, -1));
if (!biseqcstrcaseless(modtype, "Debugger"))
{
// Return NULL.
lua_pop(ds->state, 1);
lua_close(ds->state);
free(ds);
bdestroy(modtype);
bdestroy(path);
return NULL;
}
lua_pop(ds->state, 1);
bdestroy(modtype);
// Create the handler tables.
lua_newtable(ds->state);
lua_setglobal(ds->state, HANDLER_TABLE_COMMANDS_NAME);
lua_newtable(ds->state);
lua_setglobal(ds->state, HANDLER_TABLE_HOOKS_NAME);
lua_newtable(ds->state);
lua_setglobal(ds->state, HANDLER_TABLE_SYMBOLS_NAME);
// Set the global functions.
lua_pushcfunction(ds->state, &dbg_lua_add_command);
lua_setglobal(ds->state, "add_command");
lua_pushcfunction(ds->state, &dbg_lua_add_hook);
lua_setglobal(ds->state, "add_hook");
lua_pushcfunction(ds->state, &dbg_lua_add_symbol_hook);
lua_setglobal(ds->state, "add_symbol_hook");
// Run the setup function.
lua_getglobal(ds->state, "setup");
if (lua_pcall(ds->state, 0, 0, 0) != 0)
{
printd(LEVEL_ERROR, "failed to run setup() in debugger module from %s.\n", path->data);
printd(LEVEL_ERROR, "lua error was %s.\n", lua_tostring(ds->state, -1));
}
// Unset the global functions.
lua_pushnil(ds->state);
lua_setglobal(ds->state, "add_command");
lua_pushnil(ds->state);
lua_setglobal(ds->state, "add_hook");
lua_pushnil(ds->state);
lua_setglobal(ds->state, "add_symbol_hook");
// Pop tables from stack.
lua_pop(ds->state, 2);
// Return new debugger module.
return ds;
}
struct lua_preproc* pp_lua_load(bstring name)
{
bstring path, modtype;
struct lua_preproc* pp;
int module;
// Calculate full path to file.
path = osutil_getmodulepath();
bconchar(path, '/');
bconcat(path, name);
// Create the new lua preprocessor structure.
pp = malloc(sizeof(struct lua_preproc));
pp->state = lua_open();
assert(pp->state != NULL);
luaL_openlibs(pp->state);
luaX_loadexpressionlib(pp->state);
// Execute the code in the new Lua context.
if (luaL_dofile(pp->state, path->data) != 0)
{
printd(LEVEL_ERROR, "lua error was %s.\n", lua_tostring(pp->state, -1));
// Return NULL.
lua_close(pp->state);
free(pp);
bdestroy(path);
return NULL;
}
// Load tables.
lua_getglobal(pp->state, "MODULE");
module = lua_gettop(pp->state);
// Ensure module table was provided.
if (lua_isnoneornil(pp->state, module))
{
printd(LEVEL_ERROR, "failed to load preprocessor module from %s.\n", path->data);
// Return NULL.
lua_close(pp->state);
free(pp);
bdestroy(path);
return NULL;
}
// Check to see whether the module is
// a preprocessor module.
lua_getfield(pp->state, module, "Type");
modtype = bfromcstr(lua_tostring(pp->state, -1));
if (!biseqcstrcaseless(modtype, "Preprocessor"))
{
// Return NULL.
lua_pop(pp->state, 1);
lua_close(pp->state);
free(pp);
bdestroy(modtype);
bdestroy(path);
return NULL;
}
lua_pop(pp->state, 1);
bdestroy(modtype);
// Create the handler table.
lua_newtable(pp->state);
lua_setglobal(pp->state, HANDLER_TABLE_NAME);
// Set the global add_preprocessor_directive function.
lua_pushcfunction(pp->state, &pp_lua_add_preprocessor_directive);
lua_setglobal(pp->state, "add_preprocessor_directive");
// Run the setup function.
lua_getglobal(pp->state, "setup");
if (lua_pcall(pp->state, 0, 0, 0) != 0)
{
printd(LEVEL_ERROR, "failed to run setup() in preprocessor module from %s.\n", path->data);
}
// Unset the add_preprocessor_directive function.
lua_pushnil(pp->state);
lua_setglobal(pp->state, "add_preprocessor_directive");
// Pop tables from stack.
lua_pop(pp->state, 2);
// Return new preprocessor module.
return pp;
}
int vm_hw_lua_cpu_handle_register_set(lua_State* L)
{
// Table is at 1, key is at 2, value is at 3.
vm_t* vm = vm_hw_lua_cpu_extract_cpu(L, 1);
bstring name = bfromcstr(lua_tostring(L, 2));
if (biseqcstrcaseless(name, "A"))
vm->registers[REG_A] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "B"))
vm->registers[REG_B] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "C"))
vm->registers[REG_C] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "X"))
vm->registers[REG_X] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "Y"))
vm->registers[REG_Y] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "Z"))
vm->registers[REG_Z] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "I"))
vm->registers[REG_I] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "J"))
vm->registers[REG_J] = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "SP"))
vm->sp = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "PC"))
vm->pc = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "IA"))
vm->ia = (uint16_t)lua_tonumber(L, 3);
else if (biseqcstrcaseless(name, "EX"))
vm->ex = (uint16_t)lua_tonumber(L, 3);
return 0;
}
int vm_hw_lua_cpu_handle_register_get(lua_State* L)
{
// Table is at 1, key is at 2.
vm_t* vm = vm_hw_lua_cpu_extract_cpu(L, 1);
bstring name = bfromcstr(lua_tostring(L, 2));
if (biseqcstrcaseless(name, "A"))
lua_pushnumber(L, vm->registers[REG_A]);
else if (biseqcstrcaseless(name, "B"))
lua_pushnumber(L, vm->registers[REG_B]);
else if (biseqcstrcaseless(name, "C"))
lua_pushnumber(L, vm->registers[REG_C]);
else if (biseqcstrcaseless(name, "X"))
lua_pushnumber(L, vm->registers[REG_X]);
else if (biseqcstrcaseless(name, "Y"))
lua_pushnumber(L, vm->registers[REG_Y]);
else if (biseqcstrcaseless(name, "Z"))
lua_pushnumber(L, vm->registers[REG_Z]);
else if (biseqcstrcaseless(name, "I"))
lua_pushnumber(L, vm->registers[REG_I]);
else if (biseqcstrcaseless(name, "J"))
lua_pushnumber(L, vm->registers[REG_J]);
else if (biseqcstrcaseless(name, "SP"))
lua_pushnumber(L, vm->sp);
else if (biseqcstrcaseless(name, "PC"))
lua_pushnumber(L, vm->pc);
else if (biseqcstrcaseless(name, "IA"))
lua_pushnumber(L, vm->ia);
else if (biseqcstrcaseless(name, "EX"))
lua_pushnumber(L, vm->ex);
else
lua_pushnil(L);
return 1;
}
