int main(){ history_remove(); history_load(); history_add(__T("abcd")); assert( _tcscmp(history_get(0),__T("abcd"))==0 ); history_add(__T("qwerrr")); assert( _tcscmp(history_get(0),__T("qwerrr"))==0 ); history_add(__T("zxcv")); assert( _tcscmp(history_get(0),__T("zxcv"))==0 ); history_save(); history_load(); history_add(__T("zxcv1")); assert( _tcscmp(history_get(0),__T("zxcv1"))==0 ); assert( _tcscmp(history_get(1),__T("zxcv"))==0 ); assert( _tcscmp(history_get(2),__T("qwerrr"))==0 ); assert( _tcscmp(history_get(3),__T("abcd"))==0 ); history_delete(1); history_save(); history_load(); assert( _tcscmp(history_get(0),__T("zxcv1"))==0 ); assert( _tcscmp(history_get(1),__T("zxcv"))!=0 ); assert( _tcscmp(history_get(2),__T("qwerrr"))==0 ); assert( _tcscmp(history_get(3),__T("abcd"))==0 ); history_pin(2); check_ni_wi(); history_add(__T("asdff")); history_add(__T("asdfff")); history_add(__T("asdffff")); assert( _tcscmp(history_get(0),__T("asdffff"))==0 ); assert( _tcscmp(history_get(1),__T("asdfff"))==0 ); assert( _tcscmp(history_get(2),__T("qwerrr"))==0 ); assert( _tcscmp(history_get(3),__T("asdff"))==0 ); history_pin(3); check_ni_wi(); history_unpin(2); check_ni_wi(); history_pin(11); history_pin(13); check_ni_wi(); history_pin(5); history_pin(6); check_ni_wi(); history_delete(4); history_delete(5); check_ni_wi(); { TCHAR buffer[VIEW_HISTORY*MAX_PATH]; int len = history_to_json(buffer); buffer[len+1] = __T('\0'); _tprintf(__T("\n%d,%s\n"),len,buffer); } return 0; }
static void history_shift(Rune c, void* f, int n){ if(n){ history_save(); history_advance(n); } history_load(); }
void history_default(void) { int i; for(i=0; i < NUM_HISTORY_ENTRIES; i++) memset(&history.entries[i], 0, sizeof(t_history_entry)); /* restore history */ history_load(); }
void history_first() { if( current_mode ) { if( !current_mode->has_loaded ) { history_load( current_mode ); } current_mode->pos = 0; } }
input_state* input_init(void) { input_state *input; input = malloc(sizeof(input_state)); input->history_current = input->history_first = NULL; input->cursor = 0; history_load(input); history_add(input); set_attr(input); reset_term(input, false); return input; }
static void flush_line(Rune c, void* f, int v){ if(pty_mode || f == NULL){ append_character(v); }else{ (*(void(*)(int)) f)(v); } cursor_shift(-cursor); erase_line(); fflush(stderr); render(stdout, line->buf, utf8_of_rune); fflush(stdout); if(pty_mode || f == NULL) line->buf->c--; /* FIXME! store history without the flushing character! */ hist_cur = hist_len - 1; history_save(); if(--lines <= 0) exit(0); history_add(); history_load(); }
GList * history_get (const char *input_name) { GList *hist = NULL; char *profile; mc_config_t *cfg; if (num_history_items_recorded == 0) /* this is how to disable */ return NULL; if ((input_name == NULL) || (*input_name == '\0')) return NULL; profile = mc_config_get_full_path (MC_HISTORY_FILE); cfg = mc_config_init (profile); hist = history_load (cfg, input_name); mc_config_deinit (cfg); g_free (profile); return hist; }
wchar_t *history_get( int idx ) { int len; if( !current_mode ) return 0; len = al_get_count( ¤t_mode->item ); if( (idx >= len ) && !current_mode->has_loaded ) { history_load( current_mode ); len = al_get_count( ¤t_mode->item ); } if( idx < 0 ) return 0; if( idx >= len ) return 0; return item_get( current_mode, al_get( ¤t_mode->item, len - 1 - idx ) )->data; }
/* main loop, parse lines into trees and execute them * ----------------------------------------------------------------------- */ void sh_loop(void) { struct parser p; union node *list; stralloc cmd; /* if we're in interactive mode some additional stuff is to be initialized */ if(source->mode & SOURCE_IACTIVE) history_load(); stralloc_init(&cmd); parse_init(&p, P_DEFAULT); while(!(parse_gettok(&p, P_DEFAULT) & T_EOF)) { p.pushback++; parse_lineno = source->line; var_setvint("LINENO", parse_lineno, V_DEFAULT); /* launch the parser to get a complete command */ if((list = parse_list(&p))) { struct eval e; if(source->mode & SOURCE_IACTIVE) { tree_printlist(list, &cmd, NULL); stralloc_catc(&cmd, '\n'); stralloc_nul(&cmd); history_set(cmd.s); cmd.s = NULL; history_advance(); } #ifdef DEBUG /* debug_list(list, 0); buffer_putnlflush(fd_err->w);*/ #endif /* DEBUG */ eval_push(&e, E_JCTL); eval_tree(&e, list, E_ROOT|E_LIST); sh->exitcode = eval_pop(&e); stralloc_zero(&cmd); tree_free(list); } else if(!(p.tok & (T_NL | T_SEMI | T_BGND))) { /* we have a parse error */ if(p.tok != T_EOF) parse_error(&p, 0); /* exit if not interactive */ if(!(source->mode & SOURCE_IACTIVE)) sh_exit(1); /* ..otherwise discard the input buffer */ source_flush(); p.pushback = 0; } if(p.tok & (T_NL|T_SEMI|T_BGND)) p.pushback = 0; /* reset prompt */ prompt_number = 0; } }
int main (int argc, char *argv[]) { #ifdef HW_RVL /* initialize DVD device */ DI_Init(); #endif u16 usBetweenFrames; long long now, prev; /* Initialize OGC subsystems */ ogc_video__init(); ogc_input__init(); ogc_audio__init(); #ifdef HW_DOL /* Initialize GC DVD interface */ DVD_Init (); dvd_drive_detect(); #endif #ifdef HW_RVL /* Power Button callback */ SYS_SetPowerCallback(Power_Off); #endif /* Initialize FAT Interface */ if (fatInitDefault() == true) { fat_enabled = 1; } /* Default Config */ legal(); set_option_defaults (); config_load(); #ifdef HW_RVL /* Load SMB Settings */ loadSettings(); #endif /* Restore Recent Files list */ set_history_defaults(); history_load(); /* Initialize Virtual Machine */ init_machine (); /* Show Menu */ MainMenu(); ConfigRequested = 0; /* Initialize Frame timings */ frameticker = 0; usBetweenFrames = sms.display ? 20000 : 16666; prev = gettime(); /* Emulation Loop */ while (1) { /* update inputs */ ogc_input__update(); /* Frame synchronization */ if (gc_pal != sms.display) { /* use timers */ now = gettime(); if (diff_usec(prev, now) > usBetweenFrames) { /* Frame skipping */ prev = now; system_frame(1); } else { /* Delay */ while (diff_usec(prev, now) < usBetweenFrames) now = gettime(); /* Render Frame */ prev = now; system_frame(0); } } else { /* use VSync */ if (frameticker > 1) { /* Frame skipping */ frameticker--; system_frame (1); } else { /* Delay */ while (!frameticker) usleep(10); system_frame (0); } frameticker--; } /* update video & audio */ ogc_video__update(); ogc_audio__update(); /* Check for Menu request */ if (ConfigRequested) { /* reset AUDIO */ ogc_audio__reset(); /* go to menu */ MainMenu (); ConfigRequested = 0; ogc_video__reset(); /* reset frame timings */ frameticker = 0; usBetweenFrames = sms.display ? 20000 : 16666; prev = gettime(); } } return 0; }
//============================================================================== int main(int argc, char *argv[]) { //--------------------------------------------------------------------------- #ifdef USE_PYTHON_APP exec_interactive_interpreter(argc, argv); #endif //--------------------------------------------------------------------------- if(argc > 1) { if((strcmp(argv[1], CMD_S_VERSION) == 0) || ((strcmp(argv[1], CMD_VERSION) == 0))) { print_version(); return 0; } if((strcmp(argv[1], CMD_S_HELP) == 0) || ((strcmp(argv[1], CMD_HELP) == 0))) { print_help(1); return 0; } if((strcmp(argv[1], CMD_S_CONFIG) == 0) || ((strcmp(argv[1], CMD_CONFIG) == 0))) { if(read_config() >= ERROR_WARNING) log_add_fmt(LOG_ERROR, "main,\nmessage: %s", last_error()->message); print_config(); return 0; } } //--------------------------------------------------------------------------- print_version(); //--------------------------------------------------------------------------- if(read_config() >= LOG_ERROR) log_add_fmt(LOG_ERROR, "main,\nmessage: %s", last_error()->message); print_config(); //--------------------------------------------------------------------------- log_add(LOG_INFO, "application started"); log_add(LOG_INFO, "-------------------"); //--------------------------------------------------------------------------- if(sock_init() >= ERROR_NORMAL) goto exit; //--------------------------------------------------------------------------- #ifdef USE_PYTHON if(py_init() >= ERROR_NORMAL) goto exit; #endif //--------------------------------------------------------------------------- #ifdef PI_DEVICE if(gpio_init() >= ERROR_NORMAL) goto exit; #endif //--------------------------------------------------------------------------- char command[256]; if(argc > 1) { // Read params for(int i = 1; i < argc; i++) { if((strcmp(argv[i], PARAM_S_PORT) == 0) || ((strcmp(argv[i], PARAM_PORT) == 0))) { cmd_server_port = atoi(argv[++i]); } else if((strcmp(argv[i], PARAM_S_WEB_PORT) == 0) || ((strcmp(argv[i], PARAM_WEB_PORT) == 0))) { web_server_port = atoi(argv[++i]); } else if((strcmp(argv[i], PARAM_S_WS_PORT) == 0) || ((strcmp(argv[i], PARAM_WS_PORT) == 0))) { ws_server_port = atoi(argv[++i]); } else if((strcmp(argv[i], PARAM_S_HOST) == 0) || ((strcmp(argv[i], PARAM_HOST) == 0))) { strcpy((char*)cmd_server_host, argv[++i]); } else if((strcmp(argv[i], PARAM_S_COUNT) == 0) || ((strcmp(argv[i], PARAM_COUNT) == 0))) { cmd_clients_count = atoi(argv[++i]); } } // Read cmd for(int i = 1; i < argc; i++) { if((strcmp(argv[i], CMD_S_ALL) == 0) || ((strcmp(argv[i], CMD_ALL) == 0))) { strcpy(command, CMD_ALL); } else if((strcmp(argv[i], CMD_S_SERVER) == 0) || ((strcmp(argv[i], CMD_SERVER) == 0))) { strcpy(command, CMD_SERVER); } else if((strcmp(argv[i], CMD_S_WEB_SERVER) == 0) || ((strcmp(argv[i], CMD_WEB_SERVER) == 0))) { strcpy(command, CMD_WEB_SERVER); } else if((strcmp(argv[i], CMD_S_WS_SERVER) == 0) || ((strcmp(argv[i], CMD_WS_SERVER) == 0))) { strcpy(command, CMD_WS_SERVER); } else if((strcmp(argv[i], CMD_S_CLIENT) == 0) || ((strcmp(argv[i], CMD_CLIENT) == 0))) { strcpy(command, CMD_CLIENT); } } handle_command_str(NULL, command); } //--------------------------------------------------------------------------- if(history_load() >= ERROR_NORMAL) log_add_fmt(LOG_ERROR, "main,\nmessage: %s", last_error()->message); log_add(LOG_INFO, "command mode"); //--------------------------------------------------------------------------- strcpy(command, "\0"); while(TRUE) { // char ch = getcode(); // if(ch == '\033') // { // getchar(); // skip the [ // ch = getchar(); // switch(ch) // { // case 'A': // arrow up // { // strcpy(command, history_prev()); // break; // } // case 'B': // arrow down // { // strcpy(command, history_next()); // break; // } // } // if(strlen(command) != 0) // { // printf("%s\n", command); // continue; // } // } // if(strlen(command) == 0) // { // printf("manual input\n"); fgets(command, sizeof(command), stdin); history_add(command); // }; switch(handle_command_str(NULL, command)) { case EXEC_NONE: { make_last_error(ERROR_NONE, errno, "exit by user command"); goto exit; } case EXEC_UNKNOWN: log_add_fmt(LOG_CMD, "unknown command: %s", command); break; case EXEC_DONE: log_add_fmt(LOG_CMD, "done command: %s", command); break; } strcpy(command, "\0"); } //--------------------------------------------------------------------------- exit: sock_deinit(); #ifdef PI_DEVICE gpio_close(); #endif //--------------------------------------------------------------------------- #ifdef USE_PYTHON py_final(); #endif //--------------------------------------------------------------------------- log_add_fmt(LOG_INFO, "application finished, result: %s\n", last_error()->message); //--------------------------------------------------------------------------- return 0; //--------------------------------------------------------------------------- }
const wchar_t *history_prev_match( const wchar_t *needle ) { if( current_mode ) { if( current_mode->pos > 0 ) { for( current_mode->pos--; current_mode->pos>=0; current_mode->pos-- ) { item_t *i = item_get( current_mode, al_get( ¤t_mode->item, current_mode->pos ) ); wchar_t *haystack = (wchar_t *)i->data; if( history_test( needle, haystack ) ) { int is_used; /* This is ugly. Whenever we call item_get(), there is a chance that the return value of any previous call to item_get will become invalid. The history_is_used function uses the item_get() function. Therefore, we must create a copy of the haystack string, and if the string is unused, we must call item_get anew. */ haystack = wcsdup(haystack ); is_used = history_is_used( haystack ); free( haystack ); if( !is_used ) { i = item_get( current_mode, al_get( ¤t_mode->item, current_mode->pos ) ); al_push_long( ¤t_mode->used, current_mode->pos ); return i->data; } } } } if( !current_mode->has_loaded ) { /* We found no match in the list, try loading the history file and continue the search */ history_load( current_mode ); return history_prev_match( needle ); } else { /* We found no match in the list, and the file is already loaded. Set poition before first element and return original search string. */ current_mode->pos=-1; if( al_peek_long( ¤t_mode->used ) != -1 ) al_push_long( ¤t_mode->used, -1 ); } } return needle; }
/** Save the specified mode to file */ static void history_save_mode( void *n, history_mode_t *m ) { FILE *out; history_mode_t *on_disk; int i; int has_new=0; wchar_t *tmp_name; int ok = 1; /* First check if there are any new entries to save. If not, then we can just return */ for( i=0; i<al_get_count(&m->item); i++ ) { void *ptr = al_get( &m->item, i ); has_new = item_is_new( m, ptr ); if( has_new ) { break; } } if( !has_new ) { return; } signal_block(); /* Set up on_disk variable to describe the current contents of the history file */ on_disk = history_create_mode( m->name ); history_load( on_disk ); tmp_name = history_filename( on_disk, m->name, L".tmp" ); if( tmp_name ) { tmp_name = wcsdup(tmp_name ); if( (out=wfopen( tmp_name, "w" ) ) ) { hash_table_t mine; hash_init( &mine, &hash_item_func, &hash_item_cmp ); for( i=0; i<al_get_count(&m->item); i++ ) { void *ptr = al_get( &m->item, i ); int is_new = item_is_new( m, ptr ); if( is_new ) { hash_put( &mine, item_get( m, ptr ), L"" ); } } /* Re-save the old history */ for( i=0; ok && (i<al_get_count(&on_disk->item)); i++ ) { void *ptr = al_get( &on_disk->item, i ); item_t *i = item_get( on_disk, ptr ); if( !hash_get( &mine, i ) ) { if( item_write( out, on_disk, ptr ) == -1 ) { ok = 0; break; } } } hash_destroy( &mine ); /* Add our own items last */ for( i=0; ok && (i<al_get_count(&m->item)); i++ ) { void *ptr = al_get( &m->item, i ); int is_new = item_is_new( m, ptr ); if( is_new ) { if( item_write( out, m, ptr ) == -1 ) { ok = 0; } } } if( fclose( out ) || !ok ) { /* This message does not have high enough priority to be shown by default. */ debug( 2, L"Error when writing history file" ); } else { wrename( tmp_name, history_filename( on_disk, m->name, 0 ) ); } } free( tmp_name ); } halloc_free( on_disk); if( ok ) { /* Reset the history. The item_t entries created in this session are not lost or dropped, they are stored in the session_item hash table. On reload, they will be automatically inserted at the end of the history list. */ if( m->mmap_start && (m->mmap_start != MAP_FAILED ) ) { munmap( m->mmap_start, m->mmap_length ); } al_truncate( &m->item, 0 ); al_truncate( &m->used, 0 ); m->pos = 0; m->has_loaded = 0; m->mmap_start=0; m->mmap_length=0; m->save_timestamp=time(0); m->new_count = 0; } signal_unblock(); }
int main(int argc, char *argv[]) { const char *term = getenv("TERM"); const char *home = getenv("HOME"); const char *tag = NULL; const char *rc = NULL; const char *command = NULL; char *command_history_filename; char *search_history_filename; char *editor_dir; bool read_rc = true; int i; if (!home) home = ""; home_dir = xstrdup(home); for (i = 1; i < argc; i++) { const char *opt = argv[i]; if (opt[0] != '-' || !opt[1]) break; if (!opt[2]) { switch (opt[1]) { case 'R': read_rc = false; continue; case 't': tag = opt_arg(opt, argv[++i]); continue; case 'r': rc = opt_arg(opt, argv[++i]); continue; case 'c': command = opt_arg(opt, argv[++i]); continue; case 'V': printf("%s %s\nWritten by Timo Hirvonen\n", program, version); return 0; } if (opt[1] == '-') { i++; break; } } printf("Usage: %s [-R] [-V] [-c command] [-t tag] [-r rcfile] [file]...\n", argv[0]); return 1; } if (!isatty(1)) { fprintf(stderr, "stdout doesn't refer to a terminal\n"); return 1; } if (term == NULL || term[0] == 0) { fprintf(stderr, "TERM not set\n"); return 1; } switch (term_init(term)) { case -1: fprintf(stderr, "terminal is hardcopy\n"); return 1; case -2: fprintf(stderr, "terminal could not be found\n"); return 1; case -3: fprintf(stderr, "terminfo database could not be found\n"); return 1; } // create this early. needed if lock-files is true editor_dir = editor_file(""); mkdir(editor_dir, 0755); free(editor_dir); setlocale(LC_CTYPE, ""); charset = nl_langinfo(CODESET); if (streq(charset, "UTF-8")) term_utf8 = true; exec_builtin_rc(builtin_rc); fill_builtin_colors(); // NOTE: syntax_changed() uses window. should possibly create window after reading rc window = new_window(); root_frame = new_root_frame(window); if (read_rc) { if (rc) { read_config(commands, rc, true); } else { char *filename = editor_file("rc"); if (read_config(commands, filename, false)) { free(filename); filename = xsprintf("%s/rc", pkgdatadir); read_config(commands, filename, true); } free(filename); } } update_all_syntax_colors(); sort_aliases(); /* Terminal does not generate signals for control keys. */ set_signal_handler(SIGINT, SIG_IGN); set_signal_handler(SIGQUIT, SIG_IGN); set_signal_handler(SIGPIPE, SIG_IGN); /* Terminal does not generate signal for ^Z but someone can send * us SIGTSTP nevertheless. SIGSTOP can't be caught. */ set_signal_handler(SIGTSTP, handle_sigtstp); set_signal_handler(SIGCONT, handle_sigcont); set_signal_handler(SIGWINCH, handle_sigwinch); load_file_history(); command_history_filename = editor_file("command-history"); search_history_filename = editor_file("search-history"); history_load(&command_history, command_history_filename, command_history_size); history_load(&search_history, search_history_filename, search_history_size); if (search_history.count) search_set_regexp(search_history.ptrs[search_history.count - 1]); /* Initialize terminal but don't update screen yet. Also display * "Press any key to continue" prompt if there were any errors * during reading configuration files. */ term_raw(); if (nr_errors) { any_key(); clear_error(); } editor_status = EDITOR_RUNNING; for (; i < argc; i++) window_open_buffer(window, argv[i], false, NULL); if (window->views.count == 0) window_open_empty_buffer(window); set_view(window->views.ptrs[0]); if (command || tag) resize(); if (command) handle_command(commands, command); if (tag) { PTR_ARRAY(array); ptr_array_add(&array, xstrdup("tag")); ptr_array_add(&array, xstrdup(tag)); ptr_array_add(&array, NULL); run_commands(commands, &array); ptr_array_free(&array); } resize(); main_loop(); ui_end(); // unlock files and add files to file history remove_frame(root_frame); history_save(&command_history, command_history_filename); history_save(&search_history, search_history_filename); free(command_history_filename); free(search_history_filename); save_file_history(); return 0; }