/* This extension is not dynamically loaded, instead it's linked statically, which is why we shouldn't use the unspecific 'Jim_OnLoad' name */ int Jim_EventLoopOnLoad(Jim_Interp *interp) { Jim_EventLoop *eventLoop; Jim_InitExtension(interp); if (Jim_PackageProvide(interp, "eventloop", "1.0", JIM_ERRMSG) != JIM_OK) return JIM_ERR; eventLoop = Jim_Alloc(sizeof(*eventLoop)); eventLoop->fileEventHead = NULL; eventLoop->timeEventHead = NULL; eventLoop->timeEventNextId = 1; Jim_SetAssocData(interp, "eventloop", JimELAssocDataDeleProc, eventLoop); Jim_CreateCommand(interp, "vwait", JimELVwaitCommand, NULL, NULL); Jim_CreateCommand(interp, "after", JimELAfterCommand, NULL, NULL); /* Export events API */ Jim_RegisterApi(interp, "Jim_CreateFileHandler", Jim_CreateFileHandler); Jim_RegisterApi(interp, "Jim_DeleteFileHandler", Jim_DeleteFileHandler); Jim_RegisterApi(interp, "Jim_CreateTimeHandler", Jim_CreateTimeHandler); Jim_RegisterApi(interp, "Jim_DeleteTimeHandler", Jim_DeleteTimeHandler); Jim_RegisterApi(interp, "Jim_ProcessEvents", Jim_ProcessEvents); return JIM_OK; }
int Jim_readlineInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "readline", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "readline.readline", JimRlReadlineCommand, NULL, NULL); Jim_CreateCommand(interp, "readline.addhistory", JimRlAddHistoryCommand, NULL, NULL); return JIM_OK; }
int Jim_namespaceInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "namespace", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "namespace", JimNamespaceCmd, NULL, NULL); Jim_CreateCommand(interp, "variable", JimVariableCmd, NULL, NULL); return JIM_OK; }
int Jim_regexpInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "regexp", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "regexp", Jim_RegexpCmd, NULL, NULL); Jim_CreateCommand(interp, "regsub", Jim_RegsubCmd, NULL, NULL); return JIM_OK; }
/* * Now we try to write big enough code to duplication our array in Jim's * list implementation. Later, we try to load a sample script in Tcl that * could print our list. */ int main(int argc, char **argv) { struct mystate *jconf; Jim_Interp *interp; Jim_Obj *errstr; Jim_Obj *n; Jim_Obj *v; int error; errstr = n = v = NULL; error = 0; /* This is the first function embedders should call. */ Jim_InitEmbedded(); /* Create an interpreter */ interp = Jim_CreateInterp(); assert(interp != NULL && "couldn't create interpreter"); /* * Then, we register base commands, so that we actually implement Tcl. */ Jim_RegisterCoreCommands(interp); /* * Create unique state for our sample parser and register all * Jim commands. */ jconf = mystate_new(); Jim_CreateCommand(interp, "interface", InterfaceFunc, jconf, NULL); Jim_CreateCommand(interp, "ip", InterfaceIPFunc, jconf, NULL); /* * Parse a script. */ error = Jim_EvalFile(interp, "./net.tcl"); if (error == JIM_ERR) { fprintf(stderr, "Couldn't execute Jim's script. " "Error occured\n"); Jim_PrintErrorMessage(interp); Jim_FreeInterp(interp); exit(EXIT_FAILURE); } ShowInterfaces(jconf->head); mystate_destroy(jconf); if (n != NULL) Jim_FreeObj(interp, n); Jim_FreeInterp(interp); return (EXIT_SUCCESS); }
Jim_AioInit(Jim_Interp *interp) #endif { #ifndef JIM_STATICEXT Jim_InitExtension(interp); // Jim_ImportEventloopAPI(interp); // Johnicholas comments this out #endif if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG) != JIM_OK) return JIM_ERR; Jim_CreateCommand(interp, "aio.open", JimAioOpenCommand, NULL, NULL); Jim_CreateCommand(interp, "aio.socket", JimAioSockCommand, NULL, NULL); return JIM_OK; }
struct command *register_command(struct command_context *context, struct command *parent, const struct command_registration *cr) { if (!context || !cr->name) return NULL; const char *name = cr->name; struct command **head = command_list_for_parent(context, parent); struct command *c = command_find(*head, name); if (NULL != c) { /* TODO: originally we treated attempting to register a cmd twice as an error * Sometimes we need this behaviour, such as with flash banks. * http://www.mail-archive.com/[email protected]/msg11152.html */ LOG_DEBUG("command '%s' is already registered in '%s' context", name, parent ? parent->name : "<global>"); return c; } c = command_new(context, parent, cr); if (NULL == c) return NULL; int retval = ERROR_OK; if (NULL != cr->jim_handler && NULL == parent) { retval = Jim_CreateCommand(context->interp, cr->name, cr->jim_handler, cr->jim_handler_data, NULL); } else if (NULL != cr->handler || NULL != parent) retval = register_command_handler(context, command_root(c)); if (ERROR_OK != retval) { unregister_command(context, parent, name); c = NULL; } return c; }
int Jim_execInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "exec", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "exec", Jim_ExecCmd, NULL, NULL); return JIM_OK; }
/** * [interp] creates a new interpreter. */ static int JimInterpCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { Jim_Interp *child; char buf[32]; if (argc != 1) { Jim_WrongNumArgs(interp, 1, argv, ""); return JIM_ERR; } /* Create the interpreter command */ child = Jim_CreateInterp(); Jim_RegisterCoreCommands(child); Jim_InitStaticExtensions(child); /* Copy some core variables to the new interpreter */ JimInterpCopyVariable(child, interp, "argv", NULL); JimInterpCopyVariable(child, interp, "argc", NULL); JimInterpCopyVariable(child, interp, "argv0", NULL); JimInterpCopyVariable(child, interp, "jim::argv0", NULL); JimInterpCopyVariable(child, interp, "jim::exe", NULL); /* Allow the child interpreter to find the parent */ Jim_SetAssocData(child, "interp.parent", NULL, interp); snprintf(buf, sizeof(buf), "interp.handle%ld", Jim_GetId(interp)); Jim_CreateCommand(interp, buf, JimInterpSubCmdProc, child, JimInterpDelProc); Jim_SetResultString(interp, buf, -1); return JIM_OK; }
/* * Now we try to write big enough code to duplication our array in Jim's * list implementation. Later, we try to load a sample script in Tcl that * could print our list. */ int main(int argc, char **argv) { Jim_Interp *interp; int error; /* Create an interpreter. */ interp = Jim_CreateInterp(); assert(interp != NULL && "couldn't create interpreter"); /* We register base commands, so that we actually implement Tcl. */ Jim_RegisterCoreCommands(interp); /* And initialise any static extensions */ Jim_InitStaticExtensions(interp); /* Register our Jim commands. */ Jim_CreateCommand(interp, "MySampleCommand", MySampleCommandFunc, NULL, NULL); /* Run a script. */ error = Jim_Eval(interp, JIM_PROGRAM); if (error == JIM_ERR) { Jim_MakeErrorMessage(interp); fprintf(stderr, "%s\n", Jim_GetString(Jim_GetResult(interp), NULL)); Jim_FreeInterp(interp); exit(EXIT_FAILURE); } Jim_FreeInterp(interp); return (EXIT_SUCCESS); }
static int register_command_handler(struct command_context *cmd_ctx, struct command *c) { Jim_Interp *interp = cmd_ctx->interp; char *ocd_name = alloc_printf("ocd_%s", c->name); if (NULL == ocd_name) return JIM_ERR; LOG_DEBUG("registering '%s'...", ocd_name); Jim_CmdProc *func = c->handler ? &script_command : &command_unknown; int retval = Jim_CreateCommand(interp, ocd_name, func, c, NULL); free(ocd_name); if (JIM_OK != retval) return retval; /* we now need to add an overrideable proc */ char *override_name = alloc_printf( "proc %s {args} {eval ocd_bouncer %s $args}", c->name, c->name); if (NULL == override_name) return JIM_ERR; retval = Jim_Eval_Named(interp, override_name, 0, 0); free(override_name); return retval; }
int Jim_execInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "exec", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "exec", Jim_ExecCmd, JimAllocWaitInfoTable(), JimFreeWaitInfoTable); return JIM_OK; }
/** * Creates a channel for fh/fd/filename. * * If fh is not NULL, uses that as the channel (and set AIO_KEEPOPEN). * Otherwise, if fd is >= 0, uses that as the chanel. * Otherwise opens 'filename' with mode 'mode'. * * hdlfmt is a sprintf format for the filehandle. Anything with %ld at the end will do. * mode is used for open or fdopen. * * Creates the command and sets the name as the current result. */ static int JimMakeChannel(Jim_Interp *interp, FILE *fh, int fd, Jim_Obj *filename, const char *hdlfmt, int family, const char *mode) { AioFile *af; char buf[AIO_CMD_LEN]; int OpenFlags = 0; if (filename == NULL) { filename = Jim_NewStringObj(interp, hdlfmt, -1); } Jim_IncrRefCount(filename); if (fh == NULL) { if (fd < 0) { fh = fopen(Jim_String(filename), mode); } else { fh = fdopen(fd, mode); } } else { OpenFlags = AIO_KEEPOPEN; } if (fh == NULL) { JimAioSetError(interp, filename); #if !defined(JIM_ANSIC) if (fd >= 0) { close(fd); } #endif Jim_DecrRefCount(interp, filename); return JIM_ERR; } /* Create the file command */ af = Jim_Alloc(sizeof(*af)); memset(af, 0, sizeof(*af)); af->fp = fh; af->fd = fileno(fh); af->filename = filename; #ifdef FD_CLOEXEC if ((OpenFlags & AIO_KEEPOPEN) == 0) { fcntl(af->fd, F_SETFD, FD_CLOEXEC); } #endif af->OpenFlags = OpenFlags; #ifdef O_NDELAY af->flags = fcntl(af->fd, F_GETFL); #endif af->addr_family = family; snprintf(buf, sizeof(buf), hdlfmt, Jim_GetId(interp)); Jim_CreateCommand(interp, buf, JimAioSubCmdProc, af, JimAioDelProc); Jim_SetResultString(interp, buf, -1); return JIM_OK; }
int Jim_sqlite3Init(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "sqlite3", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "sqlite3.open", JimSqliteOpenCommand, NULL, NULL); return JIM_OK; }
int Jim_aioInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL); #ifndef JIM_ANSIC Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL); #endif /* Create filehandles for stdin, stdout and stderr */ JimMakeChannel(interp, stdin, -1, NULL, "stdin", 0, "r"); JimMakeChannel(interp, stdout, -1, NULL, "stdout", 0, "w"); JimMakeChannel(interp, stderr, -1, NULL, "stderr", 0, "w"); return JIM_OK; }
int Jim_readdirInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "readdir", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "readdir", Jim_ReaddirCmd, NULL, NULL); return JIM_OK; }
int Jim_arrayInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "array", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "array", Jim_SubCmdProc, (void *)array_command_table, NULL); return JIM_OK; }
int Jim_eventloopInit(Jim_Interp *interp) { Jim_EventLoop *eventLoop; if (Jim_PackageProvide(interp, "eventloop", "1.0", JIM_ERRMSG)) return JIM_ERR; eventLoop = Jim_Alloc(sizeof(*eventLoop)); memset(eventLoop, 0, sizeof(*eventLoop)); Jim_SetAssocData(interp, "eventloop", JimELAssocDataDeleProc, eventLoop); Jim_CreateCommand(interp, "vwait", JimELVwaitCommand, eventLoop, NULL); Jim_CreateCommand(interp, "update", JimELUpdateCommand, eventLoop, NULL); Jim_CreateCommand(interp, "after", JimELAfterCommand, eventLoop, NULL); return JIM_OK; }
int Jim_OnLoad(Jim_Interp *interp) { Jim_InitExtension(interp); if (Jim_PackageProvide(interp, "readdir", "1.0", JIM_ERRMSG) != JIM_OK) { return JIM_ERR; } Jim_CreateCommand(interp, "readdir", Jim_ReaddirCmd, NULL, NULL); return JIM_OK; }
int Jim_interpInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "interp", "1.0", JIM_ERRMSG)) return JIM_ERR; Jim_CreateCommand(interp, "interp", JimInterpCommand, NULL, NULL); return JIM_OK; }
int Jim_tclprefixInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "tclprefix", "1.0", JIM_ERRMSG)) { return JIM_ERR; } Jim_CreateCommand(interp, "tcl::prefix", Jim_TclPrefixCoreCommand, NULL, NULL); return JIM_OK; }
void initialize() { interpreter_ = Jim_CreateInterp(); Jim_RegisterCoreCommands(interpreter_); // Register extensions ::Jim_clockInit(interpreter_); ::Jim_regexpInit(interpreter_); // Register built in commands for (auto * cmd : builtInProcs()) Jim_CreateCommand(interpreter_, cmd->name(), cmdProc, cmd, nullptr); for (auto * cmd : builtInSubCmdProcs()) Jim_CreateCommand(interpreter_, cmd->name(), subCmdProc, cmd, nullptr); // Register built in variables for (auto * var : builtInVariables()) Jim_SetGlobalVariableStr(interpreter_, var->name(), var->defaultValue()); #if DEBUG // Use the file from the source directory Jim_EvalFileGlobal(interpreter_, "../src/ScriptingLib.tcl"); #else Jim_EvalSource(interpreter_, __FILE__, __LINE__, std::string((char *)&ScriptingLib[0], BX_COUNTOF(ScriptingLib)).c_str()); #endif std::string configFile = ""; #if BX_PLATFORM_LINUX || BX_PLATFORM_OSX // Try to load the config file char * home = getenv("HOME"); if (home) configFile = std::string(home) + "/." + CONFIG_FILE; else configFile = "~/." + CONFIG_FILE; #else char pwd[1024]; configFile = std::string(bx::pwd(pwd, 1024)) + "/" + CONFIG_FILE; #endif logInfo("Loading config file: ", configFile); Jim_EvalFileGlobal(interpreter_, configFile.c_str()); }
int Jim_signalInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "signal", "1.0", JIM_ERRMSG)) return JIM_ERR; /* Teach the jim core how to set a result from a sigmask */ interp->signal_set_result = signal_set_sigmask_result; /* Make sure we know where to store the signals which occur */ sigloc = &interp->sigmask; Jim_CreateCommand(interp, "signal", Jim_SubCmdProc, (void *)signal_command_table, NULL); Jim_CreateCommand(interp, "alarm", Jim_AlarmCmd, 0, 0); Jim_CreateCommand(interp, "kill", Jim_KillCmd, 0, 0); /* Sleep is slightly dubious here */ Jim_CreateCommand(interp, "sleep", Jim_SleepCmd, 0, 0); return JIM_OK; }
int Jim_zlibInit(Jim_Interp *interp) { if (Jim_PackageProvide(interp, "zlib", "1.0", JIM_ERRMSG)) { return JIM_ERR; } Jim_CreateCommand(interp, "zlib", JimZlibCmd, 0, 0); return JIM_OK; }
// end added int Jim_OnLoad(Jim_Interp *interp) { Jim_InitExtension(interp); if (Jim_PackageProvide(interp, "posix", "1.0", JIM_ERRMSG) != JIM_OK) return JIM_ERR; Jim_CreateCommand(interp, "os.fork", Jim_PosixForkCommand, NULL, NULL); Jim_CreateCommand(interp, "os.sleep", Jim_PosixSleepCommand, NULL, NULL); Jim_CreateCommand(interp, "os.getids", Jim_PosixGetidsCommand, NULL, NULL); Jim_CreateCommand(interp, "os.gethostname", Jim_PosixGethostnameCommand, NULL, NULL); Jim_CreateCommand(interp, "os.sethostname", Jim_PosixSethostnameCommand, NULL, NULL); Jim_CreateCommand(interp, "os.usleep", Jim_LinuxUSleepCommand, NULL, NULL); Jim_CreateCommand(interp, "os.signal", Jim_PosixSignalCommand, NULL, NULL); Jim_CreateCommand(interp, "pit", Jim_PointInTimeCommand, NULL, NULL); Jim_CreateCommand(interp, "Jpit", Jim_PointInTimeJulianCommand, NULL, NULL); return JIM_OK; }
int Jim_eventloopInit(Jim_Interp *interp) { Jim_EventLoop *eventLoop; if (Jim_PackageProvide(interp, "eventloop", "1.0", JIM_ERRMSG)) return JIM_ERR; eventLoop = Jim_Alloc(sizeof(*eventLoop)); eventLoop->fileEventHead = NULL; eventLoop->timeEventHead = NULL; eventLoop->timeEventNextId = 1; eventLoop->suppress_bgerror = 0; Jim_SetAssocData(interp, "eventloop", JimELAssocDataDeleProc, eventLoop); Jim_CreateCommand(interp, "vwait", JimELVwaitCommand, eventLoop, NULL); Jim_CreateCommand(interp, "update", JimELUpdateCommand, eventLoop, NULL); Jim_CreateCommand(interp, "after", JimELAfterCommand, eventLoop, NULL); return JIM_OK; }
int Jim_AioInit(Jim_Interp *interp) #endif { #ifndef JIM_STATICEXT Jim_InitExtension(interp); #endif if (Jim_PackageProvide(interp, "aio", "1.0", JIM_ERRMSG) != JIM_OK) return JIM_ERR; Jim_CreateCommand(interp, "aio.open", JimAioOpenCommand, NULL, NULL); return JIM_OK; }
int zy1000_register_commands(struct command_context_s *cmd_ctx) { register_command(cmd_ctx, NULL, "power", handle_power_command, COMMAND_ANY, "power <on/off> - turn power switch to target on/off. No arguments - print status."); register_command(cmd_ctx, NULL, "zy1000_version", handle_zy1000_version_command, COMMAND_EXEC, "show zy1000 version numbers"); Jim_CreateCommand(interp, "powerstatus", zylinjtag_Jim_Command_powerstatus, NULL, NULL); return ERROR_OK; }
int Jim_historyInit(Jim_Interp *interp) { void **history; if (Jim_PackageProvide(interp, "history", "1.0", JIM_ERRMSG)) return JIM_ERR; history = Jim_Alloc(sizeof(*history)); *history = NULL; Jim_CreateCommand(interp, "history", JimHistorySubCmdProc, history, JimHistoryDelProc); return JIM_OK; }
int ioutil_init(struct command_context_s *cmd_ctx) { register_command(cmd_ctx, NULL, "rm", handle_rm_command, COMMAND_ANY, "remove file"); register_command(cmd_ctx, NULL, "cat", handle_cat_command, COMMAND_ANY, "display file content"); register_command(cmd_ctx, NULL, "trunc", handle_trunc_command, COMMAND_ANY, "truncate a file to 0 size"); register_command(cmd_ctx, NULL, "cp", handle_cp_command, COMMAND_ANY, "copy a file <from> <to>"); register_command(cmd_ctx, NULL, "append_file", handle_append_command, COMMAND_ANY, "append a variable number of strings to a file"); register_command(cmd_ctx, NULL, "meminfo", handle_meminfo_command, COMMAND_ANY, "display available ram memory"); Jim_CreateCommand(interp, "rm", zylinjtag_Jim_Command_rm, NULL, NULL); Jim_CreateCommand(interp, "peek", zylinjtag_Jim_Command_peek, NULL, NULL); Jim_CreateCommand(interp, "poke", zylinjtag_Jim_Command_poke, NULL, NULL); Jim_CreateCommand(interp, "ls", zylinjtag_Jim_Command_ls, NULL, NULL); Jim_CreateCommand(interp, "mac", zylinjtag_Jim_Command_mac, NULL, NULL); Jim_CreateCommand(interp, "ip", zylinjtag_Jim_Command_ip, NULL, NULL); return ERROR_OK; }