int read_baud (void) { char *baudstr, *ep; int baud = -1; do { fd_printf(STO, "\r\n"); baudstr = linenoise("*** baud: "); fd_printf(STO, "\r"); if ( baudstr == NULL ) break; baud = strtol(baudstr, &ep, 0); if ( ! ep || *ep != '\0' || ! term_baud_ok(baud) || baud == 0 ) { fd_printf(STO, "*** Invalid baudrate!"); baud = -1; } free(baudstr); } while (baud < 0); if (baudstr != NULL) add_history(baudstr); return baud; }
// interactive line entry using linenoise static bool terminal(State& state, std::istream & in, std::ostream & out, Value& code) { std::string input; code = Value::Nil(); int status = 0; while(status == 0) { char* line = linenoise( input.size() == 0 ? "> " : "+ " ); if(line == 0) return true; input += line; if(line[0] != '\0') { linenoiseHistoryAdd(line); linenoiseHistorySave((char*)".riposte_history"); } free(line); input += "\n"; /* add the discarded newline back in */ if(input.size() > 0) { Parser parser(state); status = parser.execute(input.c_str(), input.size(), true, code); } } if (status == -1) code = Value::Nil(); return false; }
// private slots: void REPL::startLoop() { char* userInput; // Load REPL history linenoiseHistoryLoad(m_historyFilepath.data()); //< requires "char *" while (m_looping && (userInput = linenoise(PROMPT)) != NULL) { if (userInput[0] != '\0') { // Send the user input to the main Phantom frame for evaluation m_webframe->evaluateJavaScript( QString(JS_EVAL_USER_INPUT).arg( QString(userInput).replace('"', "\\\""))); // Save command in the REPL history linenoiseHistoryAdd(userInput); linenoiseHistorySave(m_historyFilepath.data()); //< requires "char *" } free(userInput); } // If still "looping", close Phantom (usually caused by "CTRL+C" / "CTRL+D") if (m_looping) { m_parentPhantom->exit(); } }
int main(int argc, char *argv[]) { char *line, *url; if(argc < 2){ fprintf(stderr, "Usage: %s url\n", argv[0]); exit(EXIT_FAILURE); } headers = create_map(); url = argv[1]; char prompt[strlen(url)+3]; sprintf(prompt, "%s> ", url); linenoiseSetCompletionCallback(completionCallback); while((line = linenoise(prompt)) != NULL) { if(strcmp(line, "exit")==0) break; if (line[0] != '\0') { linenoiseHistoryAdd(line); handle_input(url, line); } free(line); } return 0; }
int main(int argc, char **argv) { mpc_parser_t *plisp = plisp_set_grammar(); puts("PLisp v.0.0.0.1."); //Pablo Lisp lol puts("Press Ctrl-C to exit."); global = new_lenv(128); lenv_add_builtins(global); while ((input = linenoise("mylsp> ")) != NULL) { if (input[0] != '\0') { mpc_result_t r; linenoiseHistoryAdd(input); if ((mpc_parse("<stdin>", input, plisp, &r))) { lval *val = lval_eval(global, lval_read(r.output)); lval_println(val); lval_del(val); mpc_ast_delete(r.output); } else { mpc_err_print(r.error); mpc_err_delete(r.error); } } free(input); } lenv_del(global); plisp_cleanup_grammar(); return 0; }
void shell_run() { shell_running = 1; printf("Vault version %s\n", VAULT_VERSION); printf("Enter \"help\" for list of commands\n"); char *line; while(shell_running) { while ((line = linenoise("vault> ")) != 0) { if (line[0] != '\0') { printf("%s", line); linenoiseHistoryAdd(line); if (line == SHELL_ACTION_HELP) { } if (line == SHELL_ACTION_EXIT) { shell_close(); } } } free(line); } }
static void repl() { int argc, j; char *line, **argv; while((line = linenoise("redis> ")) != NULL) { if (line[0] != '\0') { argv = splitArguments(line,&argc); linenoiseHistoryAdd(line); if (argc > 0) { if (strcasecmp(argv[0],"quit") == 0 || strcasecmp(argv[0],"exit") == 0) exit(0); else cliSendCommand(argc, argv, 1); } /* Free the argument vector */ for (j = 0; j < argc; j++) sdsfree(argv[j]); zfree(argv); } /* linenoise() returns malloc-ed lines like readline() */ free(line); } exit(0); }
int srepl_init (sphia_t *sphia, cmd_t *cmds, opt_t *opts) { int rc = 0; char *line; linenoiseSetCompletionCallback(completion); linenoiseHistoryLoad("history.txt"); while((line = linenoise("sphia> ")) != NULL) { for(size_t i = 0; i < sizeof(*cmds) / sizeof(cmds[0]); i++) { if(0 == strcmp(cmds[i].name, line) || (NULL != cmds[i].alt && 0 == strcmp(cmds[i].alt, line))) { if(0 == strcmp(cmds[i].name, "set")) { parse_args(line, opts); } if(NULL != cmds[i].func) { if(0 == (rc = cmds[i].func(sphia, opts))) { linenoiseHistoryAdd(line); linenoiseHistorySave("History.txt"); }else { } } } } free(line); } return rc; }
svn_error_t * svnmover_prompt_user(const char **result, const char *prompt_str, apr_pool_t *pool) { #ifdef HAVE_LINENOISE char *input; input = linenoise(prompt_str); if (! input) { return svn_error_create(SVN_ERR_CANCELLED, NULL, NULL); } /* add the line to the recallable history (if non-empty) */ if (input && *input) { linenoiseHistoryAdd(input); } *result = apr_pstrdup(pool, input); free(input); #else SVN_ERR(svn_cmdline_prompt_user2(result, prompt_str, NULL, pool)); #endif return SVN_NO_ERROR; }
char * prepare_post(CURL * curl){ char * data; curl_easy_setopt(curl, CURLOPT_POST, 1); data = linenoise("..."); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); return data; }
static int readlines(void) { char *line; mpl_list_t *reqMsg = NULL; int quit = 0; mpl_list_t *tmp; completionStrings = calloc(maxStrings, sizeof(char *)); while((line = linenoise("PERS> ")) != NULL) { if (line[0] != '\0') { if (strcmp(line,"quit") && strncmp(line, "help ", 5)) { char *req; int ret = -1; req = formatCmdLine(line, "Req"); reqMsg = mpl_param_list_unpack_param_set(req, PERSONNEL_PARAM_SET_ID); if (!reqMsg) { printf("Protocol error\n"); ret = -1; } else if (checkCommand(reqMsg) == 0) { ret = pack_and_send(reqMsg); } mpl_param_list_destroy(&reqMsg); free(req); if (ret == 0) { fgets(buf, 1024, fi); printf("%s\n", buf); } } else if (!strncmp(line, "help ", 5)) { char *helptext; persfile_get_command_help(line, &helptext); if (helptext != NULL) { printf("%s", helptext); free(helptext); } else printf("No help\n"); } else { quit = 1; } linenoiseHistoryAdd(line); linenoiseHistorySave("history.txt"); /* Save every new entry */ free(line); while ((tmp = mpl_list_remove(&completionCallstack, NULL)) != NULL) { completion_callstack_entry_t *e; e = MPL_LIST_CONTAINER(tmp, completion_callstack_entry_t, list_entry); free(e); } } if (quit) break; } free(completionStrings); return 0; }
static void repl() { int argc, j; char *line; sds *argv; config.interactive = 1; linenoiseSetCompletionCallback(completionCallback); while((line = linenoise(db ? "redislite> " : "not connected> ")) != NULL) { if (line[0] != '\0') { argv = sdssplitargs(line, &argc); linenoiseHistoryAdd(line); if (config.historyfile) { linenoiseHistorySave(config.historyfile); } if (argv == NULL) { printf("Invalid argument(s)\n"); continue; } else if (argc > 0) { if (strcasecmp(argv[0], "quit") == 0 || strcasecmp(argv[0], "exit") == 0) { exit(0); } else if (argc == 1 && !strcasecmp(argv[0], "clear")) { linenoiseClearScreen(); } else { long long start_time = mstime(), elapsed; if (cliSendCommand(argc, argv, 1) != REDISLITE_OK) { cliConnect(1); /* If we still cannot send the command, * print error and abort. */ if (cliSendCommand(argc, argv, 1) != REDISLITE_OK) { cliPrintContextErrorAndExit(); } } elapsed = mstime() - start_time; if (elapsed >= 500) { printf("(%.2fs)\n", (double)elapsed / 1000); } } } /* Free the argument vector */ for (j = 0; j < argc; j++) { sdsfree(argv[j]); } redislite_free(argv); } /* linenoise() returns malloc-ed lines like readline() */ free(line); } exit(0); }
void run_cmdline_loop(repl_t *repl, JSContextRef ctx) { while (true) { char *input_line = NULL; if (config.dumb_terminal) { display_prompt(repl->current_prompt); input_line = get_input(); if (input_line == NULL) { // Ctrl-D pressed printf("\n"); break; } } else { // Handle prints while processing linenoise input if (cljs_engine_ready) { cljs_set_print_sender(ctx, &linenoisePrintNow); } // If *print-newline* is off, we need to emit a newline now, otherwise // the linenoise prompt and line editing will overwrite any printed // output on the current line. if (cljs_engine_ready && !cljs_print_newline(ctx)) { fprintf(stdout, "\n"); } char *line = linenoise(repl->current_prompt, prompt_ansi_code_for_theme(config.theme), repl->indent_space_count); // Reset printing handler back if (cljs_engine_ready) { cljs_set_print_sender(ctx, NULL); } repl->indent_space_count = 0; if (line == NULL) { if (errno == EAGAIN) { // Ctrl-C errno = 0; repl->input = NULL; empty_previous_lines(repl); repl->current_prompt = form_prompt(repl->current_ns, false); printf("\n"); continue; } else { // Ctrl-D exit_value = EXIT_SUCCESS_INTERNAL; break; } } input_line = line; } bool break_out = process_line(repl, ctx, input_line); if (break_out) { break; } } }
int main(void) { char *line; config_t config = loadConfiguration("./conf/config"); while((line = linenoise("nosh: ")) != NULL) { parms = parse(line, config); exec(parms, config); } free(line); }
int main(int UNUSED(argc), char *argv[]) { // int i; const int num_threads = 2; pthread_t tid[num_threads]; // void *status; struct listen_param lis_para; struct send_param send_para; char *line; //mtrace(); que_msg = CreateQueue(100); sem_init(&sem_msg, 0, 0); memset(&dev_map, 0, sizeof(dev_map)); lis_para.port = SERVER_PORT; lis_para.receive_thread = receive_thread; pthread_create(&tid[0], NULL, listen_thread, &lis_para); send_para.que_msg = que_msg; send_para.mutex_msg = &mutex_msg; send_para.sem_msg = &sem_msg; pthread_create(&tid[1], NULL, send_thread, &send_para); linenoiseHistoryLoad("hist-srv.txt"); /* Load the history at startup */ while((line = linenoise("srv> ")) != NULL) { /* Do something with the string. */ if (line[0] != '\0' && line[0] != '/') { //printf("echo: '%s'\n", line); linenoiseHistoryAdd(line); /* Add to the history. */ linenoiseHistorySave("hist-srv.txt"); /* Save the history on disk. */ cmd_handle(0, line); } else if (!strncmp(line,"/q",2)) { free(line); break; } else if (!strncmp(line,"/historylen",11)) { /* The "/historylen" command will change the history len. */ int len = atoi(line+11); linenoiseHistorySetMaxLen(len); } else if (line[0] == '/') { printf("Unreconized command: %s\n", line); } else { printf("\n"); } free(line); } // for (i = 0; i < num_threads; i++) // pthread_join(tid[i],&status); return 0; }
std::string Console::prompt(const std::string& message) { std::string ret; char* line = linenoise(message.c_str()); if (line) { ret = line; linenoiseHistoryAdd(line); } free(line); return ret; }
static int line_noise_run(int argc, char **argv) { char buf[BUF_SIZE]; struct hist h; linenoise_history_init(&h); linenoise_history_add("history1", &h); linenoise_history_add("history2", &h); linenoise("enter string> ", buf, BUF_SIZE, &h, (compl_callback_t) compl); printf("You've entered %s.\n", buf); return ENOERR; }
int main(int argc, char *argv[]) { char *line; #ifdef HAVE_MULTILINE /* Note: multiline support has not yet been integrated */ char *prgname = argv[0]; /* Parse options, with --multiline we enable multi line editing. */ while(argc > 1) { argc--; argv++; if (!strcmp(*argv,"--multiline")) { linenoiseSetMultiLine(1); printf("Multi-line mode enabled.\n"); } else { fprintf(stderr, "Usage: %s [--multiline]\n", prgname); exit(1); } } #endif #ifndef NO_COMPLETION /* Set the completion callback. This will be called every time the * user uses the <tab> key. */ linenoiseSetCompletionCallback(completion); #endif /* Load history from file. The history file is just a plain text file * where entries are separated by newlines. */ linenoiseHistoryLoad("history.txt"); /* Load the history at startup */ /* Now this is the main loop of the typical linenoise-based application. * The call to linenoise() will block as long as the user types something * and presses enter. * * The typed string is returned as a malloc() allocated string by * linenoise, so the user needs to free() it. */ while((line = linenoise("hello> ")) != NULL) { /* Do something with the string. */ if (line[0] != '\0' && line[0] != '/') { printf("echo: '%s'\n", line); linenoiseHistoryAdd(line); /* Add to the history. */ linenoiseHistorySave("history.txt"); /* Save the history on disk. */ } else if (!strncmp(line,"/historylen",11)) { /* The "/historylen" command will change the history len. */ int len = atoi(line+11); linenoiseHistorySetMaxLen(len); } else if (line[0] == '/') { printf("Unreconized command: %s\n", line); } free(line); } return 0; }
static void repl() { char *line; while(line = linenoise("luna> ")) { if ('\0' != line[0]) { printf("%s\n", line); linenoiseHistoryAdd(line); } free(line); } exit(0); }
char * read_filename (void) { char *fname; linenoiseSetCompletionCallback(file_completion_cb); fd_printf(STO, "\r\n"); fname = linenoise("*** file: "); fd_printf(STO, "\r"); linenoiseSetCompletionCallback(NULL); if (fname != NULL) add_history(fname); return fname; }
char * prepare_put(CURL * curl, upload_buffer * upbuf){ char * data; curl_easy_setopt(curl, CURLOPT_UPLOAD, 1); data = linenoise("..."); upbuf->data = data; upbuf->index = 0; upbuf->length = strlen(data); curl_easy_setopt(curl, CURLOPT_READDATA, upbuf); curl_easy_setopt(curl, CURLOPT_READFUNCTION, handle_upload); return data; }
int main(int argc,const string_t* argv){ sh_prompt_update(); //linenoiseHistorySetMaxLen(10); sh_initAutoComplete(); string_t line; sds prcdLn; while((line = linenoise(sh_prompt())) != NULL) { linenoiseHistoryAdd(line); //prcdLn = sh_expand_string(line); sh_system(line); free(cPTR line); //sh_system(prcdLn); //sdsfree(prcdLn); } }
int main(void) { char buf[1024]; int retval; while(1) { retval = linenoise(buf,1024,"hello> "); if (retval > 0) { printf("echo: '%s'\n", buf); linenoiseHistoryAdd(buf); } else if (retval == -1) { exit(1); } } return 0; }
int main(void) { setlocale(LC_ALL, ""); signal(SIGINT, sig); signal(SIGQUIT, sig); signal(SIGHUP, sig); signal(SIGTERM, sig); linenoiseSetCompletionCallback(completion); char *home_dir = getenv("HOME"); assert(home_dir != NULL); char *histfile_path = get_hist_path(home_dir); if (NULL == histfile_path) { fprintf(stderr,"cannot determine history file path\n"); exit(EXIT_FAILURE); } printf("history file: %s\n",histfile_path); linenoiseHistoryLoad(histfile_path); char *line; cmd_request *cr; while((line = linenoise("qind> ")) != NULL) { if (strncmp(line,"",MAX_CMD_LEN) == 0) { continue; } cr = new_cmd_request(line); if (NULL == cr) { fprintf(stderr,"could not make cmd_request\n"); exit(EXIT_FAILURE); } dump_cmd_request(cr); if (strncmp(QUIT_CMD,line,MAX_CMD_LEN) == 0) { printf("<quitting>\n"); break; } linenoiseHistoryAdd(cr->request); destroy_cmd_request(cr); free(line); } linenoiseHistorySave(histfile_path); free(histfile_path); exit(EXIT_SUCCESS); }
static int l_linenoise(lua_State *L) { const char *prompt = luaL_checkstring(L, 1); const char *line; completion_state = L; line = linenoise(prompt); completion_state = NULL; if(! line) { return handle_ln_error(L); } lua_pushstring(L, line); free(line); return 1; }
/** * Returns an allocated line, or NULL if EOF. */ char *Jim_HistoryGetline(const char *prompt) { #ifdef USE_LINENOISE return linenoise(prompt); #else char *line = malloc(MAX_LINE_LEN); fputs(prompt, stdout); fflush(stdout); if (fgets(line, MAX_LINE_LEN, stdin) == NULL) { free(line); return NULL; } return line; #endif }
int main(int argc, char *argv[]) { char *line; linenoiseSetCompletionCallback(completion); linenoiseHistoryLoad("history.txt"); /* Load the history at startup */ while((line = linenoise("hello> ")) != NULL) { if (line[0] != '\0') { printf("echo: '%s'\n", line); linenoiseHistoryAdd(line); linenoiseHistorySave("history.txt"); /* Save every new entry */ } free(line); } return 0; }
int main(int argc, char *argv[]) { int err; char *host = "127.0.0.1"; int port = 1276; char *prompt = "lamb"; /* Signal event processing */ lamb_signal_processing(); /* Start main event thread */ int sock; err = lamb_sock_connect(&sock, host, port); if (err) { fprintf(stderr, "Can't connect to %s server\n", host); return -1; } char *line; char *prgname = argv[0]; linenoiseSetCompletionCallback(completion); linenoiseSetHintsCallback(hints); linenoiseHistoryLoad(".lamb_history"); linenoiseHistorySetMaxLen(1000); while((line = linenoise("lamb> ")) != NULL) { /* Do something with the string. */ if (line[0] != '\0') { printf("echo: %s\n", line); linenoiseHistoryAdd(line); linenoiseHistorySave(".lamb_history"); } else if (line[0] != '\0' && !strncmp(line, "show client", 11)) { int id = atoi(line + 11); lamb_show_client(sock, id); linenoiseHistoryAdd(line); linenoiseHistorySave(".lamb_history"); } else if (line[0] != '\0') { printf("Unknown Command: '%s'\n", line); } free(line); } return 0; }
static void interactiveLoop() { setjmp(recovery); linenoiseSetMultiLine(1); linenoiseHistorySetMaxLen(100); char *buf; while ((buf = linenoise("clay> ")) != NULL) { linenoiseHistoryAdd(buf); string line = stripSpaces(buf); if (line[0] == ':') { replCommand(line.substr(1, line.size() - 1)); } else { eval(line); } free(buf); } engine->runStaticConstructorsDestructors(true); }
static void repl() { int argc, j; char *line; sds *argv; config.interactive = 1; while((line = linenoise("redis> ")) != NULL) { if (line[0] != '\0') { argv = sdssplitargs(line,&argc); linenoiseHistoryAdd(line); if (config.historyfile) linenoiseHistorySave(config.historyfile); if (argv == NULL) { printf("Invalid argument(s)\n"); continue; } else if (argc > 0) { if (strcasecmp(argv[0],"quit") == 0 || strcasecmp(argv[0],"exit") == 0) { exit(0); } else { int err; if ((err = cliSendCommand(argc, argv, 1)) != 0) { if (err == ECONNRESET) { printf("Reconnecting... "); fflush(stdout); if (cliConnect(1) == -1) exit(1); printf("OK\n"); cliSendCommand(argc,argv,1); } } } } /* Free the argument vector */ for (j = 0; j < argc; j++) sdsfree(argv[j]); zfree(argv); } /* linenoise() returns malloc-ed lines like readline() */ free(line); } exit(0); }