/* 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;
}
