jim-interactive.c

   1 #include <errno.h>
   2 #include <string.h>
   3
   4 #include "jimautoconf.h"
   5 #include <jim.h>
   6
   7 #ifdef USE_LINENOISE
   8 #ifdef HAVE_UNISTD_H
   9     #include <unistd.h>
  10     #include <sys/stat.h>
  11 #endif
  12 #include "linenoise.h"
  13 #else
  14 #define MAX_LINE_LEN 512
  15 #endif
  16
  17 /**
  18  * Returns an allocated line, or NULL if EOF.
  19  */
  20 char *Jim_HistoryGetline(const char *prompt)
  21 {
  22 #ifdef USE_LINENOISE
  23     return linenoise(prompt);
  24 #else
  25     int len;
  26     char *line = malloc(MAX_LINE_LEN);
  27
  28     fputs(prompt, stdout);
  29     fflush(stdout);
  30
  31     if (fgets(line, MAX_LINE_LEN, stdin) == NULL) {
  32         free(line);
  33         return NULL;
  34     }
  35     len = strlen(line);
  36     if (len && line[len - 1] == '\n') {
  37         line[len - 1] = '\0';
  38     }
  39     return line;
  40 #endif
  41 }
  42
  43 void Jim_HistoryLoad(const char *filename)
  44 {
  45 #ifdef USE_LINENOISE
  46     linenoiseHistoryLoad(filename);
  47 #endif
  48 }
  49
  50 void Jim_HistoryAdd(const char *line)
  51 {
  52 #ifdef USE_LINENOISE
  53     linenoiseHistoryAdd(line);
  54 #endif
  55 }
  56
  57 void Jim_HistorySave(const char *filename)
  58 {
  59 #ifdef USE_LINENOISE
  60     mode_t mask;
  61     /* Just u=rw, but note that this is only effective for newly created files */
  62     mask = umask(S_IXUSR | S_IRWXG | S_IRWXO);
  63     linenoiseHistorySave(filename);
  64     mask = umask(mask);
  65 #endif
  66 }
  67
  68 void Jim_HistoryShow(void)
  69 {
  70 #ifdef USE_LINENOISE
  71     /* built-in history command */
  72     int i;
  73     int len;
  74     char **history = linenoiseHistory(&len);
  75     for (i = 0; i < len; i++) {
  76         printf("%4d %s\n", i + 1, history[i]);
  77     }
  78 #endif
  79 }
  80
  81 #ifdef USE_LINENOISE
  82 struct JimCompletionInfo {
  83     Jim_Interp *interp;
  84     Jim_Obj *command;
  85 };
  86
  87 void JimCompletionCallback(const char *prefix, linenoiseCompletions *comp, void *userdata)
  88 {
  89     struct JimCompletionInfo *info = (struct JimCompletionInfo *)userdata;
  90     Jim_Obj *objv[2];
  91
  92     objv[0] = info->command;
  93     objv[1] = Jim_NewStringObj(info->interp, prefix, -1);
  94
  95     int ret = Jim_EvalObjVector(info->interp, 2, objv);
  96
  97     /* XXX: Consider how best to handle errors here. bgerror? */
  98     if (ret == JIM_OK) {
  99         int i;
 100         Jim_Obj *listObj = Jim_GetResult(info->interp);
 101         int len = Jim_ListLength(info->interp, listObj);
 102         for (i = 0; i < len; i++) {
 103             linenoiseAddCompletion(comp, Jim_String(Jim_ListGetIndex(info->interp, listObj, i)));
 104         }
 105     }
 106 }
 107 #endif
 108
 109 int Jim_InteractivePrompt(Jim_Interp *interp)
 110 {
 111     int retcode = JIM_OK;
 112     char *history_file = NULL;
 113 #ifdef USE_LINENOISE
 114     const char *home;
 115     struct JimCompletionInfo compinfo;
 116
 117     home = getenv("HOME");
 118     if (home && isatty(STDIN_FILENO)) {
 119         int history_len = strlen(home) + sizeof("/.jim_history");
 120         history_file = Jim_Alloc(history_len);
 121         snprintf(history_file, history_len, "%s/.jim_history", home);
 122         Jim_HistoryLoad(history_file);
 123     }
 124
 125     compinfo.interp = interp;
 126     compinfo.command = Jim_NewStringObj(interp, "tcl::autocomplete", -1);
 127     Jim_IncrRefCount(compinfo.command);
 128
 129     /* Register a callback function for tab-completion. */
 130     linenoiseSetCompletionCallback(JimCompletionCallback, &compinfo);
 131 #endif
 132
 133     printf("Welcome to Jim version %d.%d\n",
 134         JIM_VERSION / 100, JIM_VERSION % 100);
 135     Jim_SetVariableStrWithStr(interp, JIM_INTERACTIVE, "1");
 136
 137     while (1) {
 138         Jim_Obj *scriptObjPtr;
 139         const char *result;
 140         int reslen;
 141         char prompt[20];
 142
 143         if (retcode != JIM_OK) {
 144             const char *retcodestr = Jim_ReturnCode(retcode);
 145
 146             if (*retcodestr == '?') {
 147                 snprintf(prompt, sizeof(prompt) - 3, "[%d] . ", retcode);
 148             }
 149             else {
 150                 snprintf(prompt, sizeof(prompt) - 3, "[%s] . ", retcodestr);
 151             }
 152         }
 153         else {
 154             strcpy(prompt, ". ");
 155         }
 156
 157         scriptObjPtr = Jim_NewStringObj(interp, "", 0);
 158         Jim_IncrRefCount(scriptObjPtr);
 159         while (1) {
 160             char state;
 161             char *line;
 162
 163             line = Jim_HistoryGetline(prompt);
 164             if (line == NULL) {
 165                 if (errno == EINTR) {
 166                     continue;
 167                 }
 168                 Jim_DecrRefCount(interp, scriptObjPtr);
 169                 retcode = JIM_OK;
 170                 goto out;
 171             }
 172             if (Jim_Length(scriptObjPtr) != 0) {
 173                 /* Line continuation */
 174                 Jim_AppendString(interp, scriptObjPtr, "\n", 1);
 175             }
 176             Jim_AppendString(interp, scriptObjPtr, line, -1);
 177             free(line);
 178             if (Jim_ScriptIsComplete(interp, scriptObjPtr, &state))
 179                 break;
 180
 181             snprintf(prompt, sizeof(prompt), "%c> ", state);
 182         }
 183 #ifdef USE_LINENOISE
 184         if (strcmp(Jim_String(scriptObjPtr), "h") == 0) {
 185             /* built-in history command */
 186             Jim_HistoryShow();
 187             Jim_DecrRefCount(interp, scriptObjPtr);
 188             continue;
 189         }
 190
 191         Jim_HistoryAdd(Jim_String(scriptObjPtr));
 192         if (history_file) {
 193             Jim_HistorySave(history_file);
 194         }
 195 #endif
 196         retcode = Jim_EvalObj(interp, scriptObjPtr);
 197         Jim_DecrRefCount(interp, scriptObjPtr);
 198
 199         if (retcode == JIM_EXIT) {
 200             break;
 201         }
 202         if (retcode == JIM_ERR) {
 203             Jim_MakeErrorMessage(interp);
 204         }
 205         result = Jim_GetString(Jim_GetResult(interp), &reslen);
 206         if (reslen) {
 207             printf("%s\n", result);
 208         }
 209     }
 210   out:
 211     Jim_Free(history_file);
 212
 213 #ifdef USE_LINENOISE
 214     Jim_DecrRefCount(interp, compinfo.command);
 215     linenoiseSetCompletionCallback(NULL, NULL);
 216 #endif
 217
 218     return retcode;
 219 }