static PyObject * get_current_history_length(PyObject *self, PyObject *noarg) { HISTORY_STATE *hist_st; hist_st = history_get_history_state(); return PyInt_FromLong(hist_st ? (long) hist_st->length : (long) 0); }
/* * Fonction clone de history */ int history2() { using_history(); HISTORY_STATE *histoState = history_get_history_state(); int i; for(i = 0; i < histoState->length; i++) printf("%d %s\n", i, (*(histoState->entries + i))->line); return 0; }
static int _py_get_history_length(void) { HISTORY_STATE *hist_st = history_get_history_state(); int length = hist_st->length; /* the history docs don't say so, but the address of hist_st changes each time history_get_history_state is called which makes me think it's freshly malloc'd memory... on the other hand, the address of the last line stays the same as long as history isn't extended, so it appears to be malloc'd but managed by the history package... */ free(hist_st); return length; }
HistoryItems *get_prioritized_history() { using_history(); char *historyFile = get_history_file_name(); if(read_history(historyFile)!=0) { fprintf(stderr, "\nUnable to read history file from '%s'!\n",historyFile); exit(EXIT_FAILURE); } HISTORY_STATE *historyState=history_get_history_state(); if(historyState->length > 0) { HashSet rankmap; hashset_init(&rankmap); HashSet blacklist; int i; hashset_init(&blacklist); for(i=0; i<4; i++) { hashset_add(&blacklist, commandBlacklist[i]); } RadixSorter rs; radixsort_init(&rs, 100000); RankedHistoryItem *r; RadixItem *radixItem; HIST_ENTRY **historyList=history_list(); char **rawHistory=malloc(sizeof(char*) * historyState->length); int rawOffset=historyState->length-1; char *line; for(i=0; i<historyState->length; i++, rawOffset--) { line=historyList[i]->line; rawHistory[rawOffset]=line; if(hashset_contains(&blacklist, line)) { continue; } if((r=hashset_get(&rankmap, line))==NULL) { r=malloc(sizeof(RankedHistoryItem)); r->rank=HISTORY_RANKING_FUNCTION(0, i, strlen(line)); r->item=historyList[i]->line; hashset_put(&rankmap, line, r); radixItem=malloc(sizeof(RadixItem)); radixItem->key=r->rank; radixItem->data=r; radixItem->next=NULL; radixsort_add(&rs, radixItem); } else { radixItem=radix_cut(&rs, r->rank, r); assert(radixItem); if(radixItem) { r->rank=HISTORY_RANKING_FUNCTION(r->rank, i, strlen(line)); radixItem->key=r->rank; radixsort_add(&rs, radixItem); } } } DEBUG_RADIXSORT(); RadixItem **prioritizedRadix=radixsort_dump(&rs); prioritizedHistory=malloc(sizeof(HistoryItems)); prioritizedHistory->count=rs.size; prioritizedHistory->items=malloc(rs.size * sizeof(char*)); prioritizedHistory->raw=rawHistory; for(i=0; i<rs.size; i++) { if(prioritizedRadix[i]->data) { prioritizedHistory->items[i]=((RankedHistoryItem *)(prioritizedRadix[i]->data))->item; } free(prioritizedRadix[i]->data); free(prioritizedRadix[i]); } radixsort_destroy(&rs); return prioritizedHistory; } else { return NULL; } }
void Console::saveState() { free(pimpl_->history_); pimpl_->history_ = history_get_history_state(); }
static char * call_readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt) { size_t n; char *p, *q; PyOS_sighandler_t old_inthandler; #ifdef SAVE_LOCALE char *saved_locale = strdup(setlocale(LC_CTYPE, NULL)); if (!saved_locale) Py_FatalError("not enough memory to save locale"); setlocale(LC_CTYPE, ""); #endif old_inthandler = PyOS_setsig(SIGINT, onintr); if (setjmp(jbuf)) { #ifdef HAVE_SIGRELSE /* This seems necessary on SunOS 4.1 (Rasmus Hahn) */ sigrelse(SIGINT); #endif PyOS_setsig(SIGINT, old_inthandler); return NULL; } if (event_hook) rl_event_hook = (Function *)on_event_hook; else rl_event_hook = PyOS_InputHook; if (sys_stdin != rl_instream || sys_stdout != rl_outstream) { rl_instream = sys_stdin; rl_outstream = sys_stdout; #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER rl_prep_terminal (1); #endif } p = readline(prompt); PyOS_setsig(SIGINT, old_inthandler); /* We must return a buffer allocated with PyMem_Malloc. */ if (p == NULL) { p = PyMem_Malloc(1); if (p != NULL) *p = '\0'; return p; } n = strlen(p); if (n > 0) { char *line; HISTORY_STATE *state = history_get_history_state(); if (state->length > 0) line = history_get(state->length)->line; else line = ""; if (strcmp(p, line)) add_history(p); /* the history docs don't say so, but the address of state changes each time history_get_history_state is called which makes me think it's freshly malloc'd memory... on the other hand, the address of the last line stays the same as long as history isn't extended, so it appears to be malloc'd but managed by the history package... */ free(state); } /* Copy the malloc'ed buffer into a PyMem_Malloc'ed one and release the original. */ q = p; p = PyMem_Malloc(n+2); if (p != NULL) { strncpy(p, q, n); p[n] = '\n'; p[n+1] = '\0'; } free(q); #ifdef SAVE_LOCALE setlocale(LC_CTYPE, saved_locale); /* Restore locale */ free(saved_locale); #endif return p; }