So rather than keep talking about this, I decided to take a peek at the
code, and saw that it was actually pretty trivial to implement my idea.
I decided to just have it present all history lines that match the start of
the string first, and then go through the rest of the history... it would be
really easy to add the switch based on the number of characters, but I think
thats probably not very useful, since if you type more than 3 characters,
and its matching at the beginning of the line, i think its pretty likely
that that is the line you want.
I really like the new behavior, and think its far superior to the old one
since it make searching with only 1 character useful! which in turn is
faster than the previous behavior! :-)
I've attached the modified history.c, done a darcs send, but not sure how to
do a more formal "commit"
enjoy!
-=Abe
here is the diff output by darcs:
110a111,115
>
> /**
> Boolean to indicate whether we're trying to match against the
beginning of the string first
> */
> int search_start;
443a449,450
> new_mode->search_start = 1;
>
454c461,468
< return !!wcsstr( haystack, needle );
---
> /*
> if we're in the search_start mode only check the beginning of the
line, otherwise search the whole line!
> */
>
> if (!current_mode->search_start)
> return !!wcsstr( haystack, needle );
> else
> return !wcsncmp(haystack,needle,wcslen(needle));
846a861,870
> if (current_mode->search_start){
> /*
> We found no match against the start of the line,
try searching
> the entire line
> */
> current_mode->search_start = 0;
> current_mode->pos = al_get_count(
¤t_mode->item );
> return history_prev_match( needle );
> }
>
919a944,948
>
> /*
> set the search_start mode flag back to 1
> */
> current_mode->search_start=1;
On Mon, Nov 3, 2008 at 11:31 AM, Abe Bachrach <[EMAIL PROTECTED]> wrote:
> I was gonna ask another question on the fish mailing list, and it made me
> remember this one... after thinking about my desired behavior more, I think
> the ideal situation would be to have fish do the following:
>
> if there are 2 or less characters being searched for show the items that
> match the beginning of the line first
> if there are 3 or more characters, use the current default behavior...
>
> in matlab most of the time, what makes the feature great is that you can
> enter 1 character, and then hit the up arrow, which is often very fast.
> doing this in fish is pretty much useless since 1 character will likely
> match most any command.
>
> with 2 characters things are better but you can still get unwanted search
> results, and with 3 its somewhat unlikely that you'll get these spurious
> useless matches, so doing the full search with 3 characters might make
> sense.
>
> thanks!
> -=Abe
>
>
> On Wed, Nov 7, 2007 at 12:45 PM, Abe Bachrach <[EMAIL PROTECTED]> wrote:
>
>> I think that would be useful, however if things get too complicated
>> with all the different cases that fish is trying to guess between, it
>> could make it feel inconsistent, which would be bad.
>>
>> My guess is that the easiest solution would be to add an option such
>> as alt+up similar to the ctrl+up which is currently used to tokenize
>> the search. Ideally this should be easily configurable so people could
>> set which their default behavior would be so that I could do the
>> matlab style search from the beginning, and chris could use search
>> anywhere :-)
>>
>> I do like the idea of giving higher priority to the commands which
>> match at the beginning though, and I definitely think there is some
>> room for a smart prioritization of search results such as ranking
>> them:
>> +add importance for being more recent
>> + add importance for matching the beginning of the input
>> - subtract importance for having many repeated commands match the same
>> part
>> etc...
>>
>> thanks for the response, and keep me posted! I would love to see this
>> feature/option get added to fish! :-)
>>
>> thanks,
>> -=Abe
>>
>> On Nov 5, 2007 9:32 PM, Martin Bähr <[EMAIL PROTECTED]>
>> wrote:
>> > On Mon, Nov 05, 2007 at 06:24:27PM -0800, Chris Rebert wrote:
>> > > Under your scheme, I'd type "foo" and then hit the up arrow a million
>> > > times looking for the line I want, whereas in fish, I just have to
>> > > remember one distinguishing *part* of the command, and it'll be
>> > > completed by hitting the up arrow.
>> >
>> > what about making it search the beginning first and and if it fails to
>> > find anything then look in the middle?
>> > unlikely to have a command that starts with -y or a filename.
>> >
>> > greetings, martin.
>> > --
>> > cooperative communication with sTeam - caudium, pike, roxen and
>> unix
>> > offering: programming, training and administration - anywhere in the
>> world
>> > --
>> > pike programmer working in new zealand open-steam.org|
>> webhaven.co.nz
>> > unix system- bahai.or.at iaeste.(tuwien.ac
>> |or).at
>> > administrator (caudium|gotpike).org
>> is.schon.org
>> > Martin Bähr
>> > http://www.iaeste.or.at/~mbaehr/<http://www.iaeste.or.at/%7Embaehr/>
>> >
>>
>
>
/** \file history.c
History functions, part of the user interface.
*/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>
#include <errno.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <string.h>
#include <time.h>
#include <assert.h>
#include "fallback.h"
#include "util.h"
#include "wutil.h"
#include "history.h"
#include "common.h"
#include "halloc.h"
#include "halloc_util.h"
#include "intern.h"
#include "path.h"
#include "signal.h"
/**
Interval in seconds between automatic history save
*/
#define SAVE_INTERVAL (5*60)
/**
Number of new history entries to add before automatic history save
*/
#define SAVE_COUNT 5
/**
A struct representiong a history list
*/
typedef struct
{
/**
The name of this list. Used for picking a suitable filename and for switching modes.
*/
const wchar_t *name;
/**
The items of the list. Each entry may be either a pointer to an
item_t struct or a pointer to an mmaped memory region where a
multibyte string representing the item is stored. Use the
item_get function to always get an item_t.
*/
array_list_t item;
/**
A hash table containing all the items created by the current
session as keys. This can be used as a lookup when loading the
history list to ignore the on-file version of an entry from
this session.
*/
hash_table_t session_item;
/**
The current history position
*/
int pos;
/**
This flag is set nonzero if the file containing earlier saves has ben mmaped in
*/
int has_loaded;
/**
The mmaped region for the history file
*/
char *mmap_start;
/**
The size of the mmaped region
*/
size_t mmap_length;
/**
A list of indices of all previous search maches. This is used to eliminate duplicate search results.
*/
array_list_t used;
/**
Timestamp of last save
*/
time_t save_timestamp;
/**
Number of entries that have been added since last save
*/
int new_count;
/**
A halloc context. This context is free'd every time the history
is saved. Therefore it is very well suited for use as the
context for history item data.
*/
void *item_context;
/**
Boolean to indicate whether we're trying to match against the beginning of the string first
*/
int search_start;
}
history_mode_t;
/**
This struct represents a history item
*/
typedef struct
{
/**
The actual contents of the entry
*/
wchar_t *data;
/**
Original creation time for the entry
*/
time_t timestamp;
}
item_t;
/**
Table of all history modes
*/
static hash_table_t *mode_table=0;
/**
The surrent history mode
*/
static history_mode_t *current_mode=0;
/**
Hash function for item_t struct
*/
static int hash_item_func( void *v )
{
item_t *i = (item_t *)v;
return i->timestamp ^ hash_wcs_func( i->data );
}
/**
Comparison function for item_t struct
*/
static int hash_item_cmp( void *v1, void *v2 )
{
item_t *i1 = (item_t *)v1;
item_t *i2 = (item_t *)v2;
return (i1->timestamp == i2->timestamp) && (wcscmp( i1->data, i2->data )==0);
}
/**
Add backslashes to all newlines, so that the returning string is
suitable for writing to the history file. The memory for the return
value will be reused by subsequent calls to this function.
*/
static wchar_t *history_escape_newlines( wchar_t *in )
{
static string_buffer_t *out = 0;
if( !out )
{
out = sb_halloc( global_context );
if( !out )
{
DIE_MEM();
}
}
else
{
sb_clear( out );
}
for( ; *in; in++ )
{
if( *in == L'\\' )
{
sb_append_char( out, *in );
if( *(in+1) )
{
in++;
sb_append_char( out, *in );
}
else
{
/*
This is a weird special case. When we are trying to
save a string that ends with a backslash, we need to
handle it specially, otherwise this command would be
combined with the one following it. We hack around
this by adding an additional newline.
*/
sb_append_char( out, L'\n' );
}
}
else if( *in == L'\n' )
{
sb_append_char( out, L'\\' );
sb_append_char( out, *in );
}
else
{
sb_append_char( out, *in );
}
}
return (wchar_t *)out->buff;
}
/**
Remove backslashes from all newlines. This makes a string from the
history file better formated for on screen display. The memory for
the return value will be reused by subsequent calls to this
function.
*/
static wchar_t *history_unescape_newlines( wchar_t *in )
{
static string_buffer_t *out = 0;
if( !out )
{
out = sb_halloc( global_context );
if( !out )
{
DIE_MEM();
}
}
else
{
sb_clear( out );
}
for( ; *in; in++ )
{
if( *in == L'\\' )
{
if( *(in+1)!= L'\n')
{
sb_append_char( out, *in );
}
}
else
{
sb_append_char( out, *in );
}
}
return (wchar_t *)out->buff;
}
/**
Check if the specified item is already loaded
*/
static int item_is_new( history_mode_t *m, void *d )
{
char *begin = (char *)d;
if( !m->has_loaded || !m->mmap_start || (m->mmap_start == MAP_FAILED ) )
{
return 1;
}
if( (begin < m->mmap_start) || (begin > (m->mmap_start+m->mmap_length) ) )
{
return 1;
}
return 0;
}
/**
Returns an item_t for the specified adress. The adress must come from the item list of the specified mode.
Later calls to this function may erase the output of a previous call to this function.
*/
static item_t *item_get( history_mode_t *m, void *d )
{
char *begin = (char *)d;
if( item_is_new( m, d ) )
{
return (item_t *)d;
}
else
{
char *end = m->mmap_start + m->mmap_length;
char *pos=begin;
int was_backslash = 0;
static string_buffer_t *out = 0;
static item_t narrow_item;
int first_char = 1;
int timestamp_mode = 0;
narrow_item.timestamp = 0;
if( !out )
{
out = sb_halloc( global_context );
if( !out )
{
DIE_MEM();
}
}
else
{
sb_clear( out );
}
while( 1 )
{
wchar_t c;
mbstate_t state;
size_t res;
memset( &state, 0, sizeof(state) );
res = mbrtowc( &c, pos, end-pos, &state );
if( res == (size_t)-1 )
{
pos++;
continue;
}
else if( res == (size_t)-2 )
{
break;
}
else if( res == (size_t)0 )
{
pos++;
continue;
}
pos += res;
if( c == L'\n' )
{
if( timestamp_mode )
{
wchar_t *time_string = (wchar_t *)out->buff;
while( *time_string && !iswdigit(*time_string))
time_string++;
errno=0;
if( *time_string )
{
time_t tm;
wchar_t *end;
errno = 0;
tm = (time_t)wcstol( time_string, &end, 10 );
if( tm && !errno && !*end )
{
narrow_item.timestamp = tm;
}
}
sb_clear( out );
timestamp_mode = 0;
continue;
}
if( !was_backslash )
break;
}
if( first_char )
{
if( c == L'#' )
timestamp_mode = 1;
}
first_char = 0;
sb_append_char( out, c );
was_backslash = ( (c == L'\\') && !was_backslash);
}
narrow_item.data = history_unescape_newlines((wchar_t *)out->buff);
return &narrow_item;
}
}
/**
Write the specified item to the specified file.
*/
static int item_write( FILE *f, history_mode_t *m, void *v )
{
item_t *i = item_get( m, v );
return fwprintf( f, L"# %d\n%ls\n", i->timestamp, history_escape_newlines( i->data ) );
}
/**
Release all memory used by the specified history mode.
*/
static void history_destroy_mode( history_mode_t *m )
{
halloc_free( m->item_context );
if( m->mmap_start && (m->mmap_start != MAP_FAILED ))
{
munmap( m->mmap_start, m->mmap_length);
}
}
/**
Free all memory used by specified mistory mode
*/
static void history_destroy_mode_wrapper( void *n, history_mode_t *m )
{
halloc_free( m );
}
/**
Create a new empty mode with the specified name.
The mode is a halloc context, and the entire mode can be destroyed using halloc_free().
*/
static history_mode_t *history_create_mode( const wchar_t *name )
{
history_mode_t *new_mode = halloc( 0, sizeof( history_mode_t ));
new_mode->name = intern(name);
al_init( &new_mode->item );
al_init( &new_mode->used );
halloc_register_function( new_mode, (void (*)(void *))&al_destroy, &new_mode->item );
halloc_register_function( new_mode, (void (*)(void *))&al_destroy, &new_mode->used );
hash_init( &new_mode->session_item, &hash_item_func, &hash_item_cmp );
halloc_register_function( new_mode, (void (*)(void *))&hash_destroy, &new_mode->session_item );
new_mode->save_timestamp=time(0);
new_mode->item_context = halloc( 0,0 );
new_mode->search_start = 1;
halloc_register_function( new_mode, (void (*)(void *))&history_destroy_mode, new_mode );
return new_mode;
}
/**
This function tests if the search string is a match for the given string
*/
static int history_test( const wchar_t *needle, const wchar_t *haystack )
{
/*
if we're in the search_start mode only check the beginning of the line, otherwise search the whole line!
*/
if (!current_mode->search_start)
return !!wcsstr( haystack, needle );
else
return !wcsncmp(haystack,needle,wcslen(needle));
}
/**
Returns the name of the save file for a mode.
\param context a halloc context used to allocate memory
\param name the name of the hstory mode
\param suffix an optional file suffix
*/
static wchar_t *history_filename( void *context, const wchar_t *name, const wchar_t *suffix )
{
wchar_t *path;
wchar_t *res;
if( !current_mode )
return 0;
path = path_get_config( context );
if( !path )
return 0;
res = wcsdupcat( path, L"/", name, L"_history", suffix?suffix:(void *)0);
halloc_register_function( context, &free, res );
return res;
}
/**
Go through the mmaped region and insert pointers to suitable loacations into the item list
*/
static void history_populate_from_mmap( history_mode_t *m )
{
char *begin = m->mmap_start;
char *end = begin + m->mmap_length;
char *pos;
array_list_t old_item;
array_list_t session_item_list;
int ignore_newline = 0;
int do_push = 1;
al_init( &old_item );
al_init( &session_item_list );
al_push_all( &old_item, &m->item );
al_truncate( &m->item, 0 );
for( pos = begin; pos <end; pos++ )
{
if( do_push )
{
item_t *i;
item_t *i_orig;
ignore_newline = *pos == '#';
i = item_get( m, pos );
if( (i_orig=hash_get( ¤t_mode->session_item, i ) ) )
{
/*
This item comes from this session. Insert the
original item at the end of the item list.
*/
al_push( &session_item_list, i_orig );
}
else
{
/*
Old item. Insert pointer directly to the item list
*/
al_push( &m->item, pos );
}
do_push = 0;
}
switch( *pos )
{
case '\\':
{
pos++;
break;
}
case '\n':
{
if( ignore_newline )
{
ignore_newline = 0;
}
else
{
do_push = 1;
}
break;
}
}
}
al_push_all( &m->item, &session_item_list );
m->pos += al_get_count( &m->item );
al_push_all( &m->item, &old_item );
al_destroy( &session_item_list );
al_destroy( &old_item );
}
/**
Load contents of the backing file to memory
*/
static void history_load( history_mode_t *m )
{
int fd;
int ok=0;
void *context;
wchar_t *filename;
if( !m )
return;
m->has_loaded=1;
signal_block();
context = halloc( 0, 0 );
filename = history_filename( context, m->name, 0 );
if( filename )
{
if( ( fd = wopen( filename, O_RDONLY ) ) > 0 )
{
off_t len = lseek( fd, 0, SEEK_END );
if( len != (off_t)-1)
{
m->mmap_length = (size_t)len;
if( lseek( fd, 0, SEEK_SET ) == 0 )
{
if( (m->mmap_start = mmap( 0, m->mmap_length, PROT_READ, MAP_PRIVATE, fd, 0 )) != MAP_FAILED )
{
ok = 1;
history_populate_from_mmap( m );
}
}
}
close( fd );
}
}
halloc_free( context );
signal_unblock();
}
/**
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();
}
void history_add( const wchar_t *str )
{
item_t *i;
if( !current_mode )
return;
i = halloc( current_mode->item_context, sizeof(item_t));
i->data = (wchar_t *)halloc_wcsdup( current_mode->item_context, str );
i->timestamp = time(0);
al_push( ¤t_mode->item, i );
hash_put( ¤t_mode->session_item, i, i );
al_truncate( ¤t_mode->used, 0 );
current_mode->pos = al_get_count( ¤t_mode->item );
current_mode->new_count++;
if( (time(0) > current_mode->save_timestamp+SAVE_INTERVAL) || (current_mode->new_count >= SAVE_COUNT) )
{
history_save_mode( 0, current_mode );
}
}
/**
Check if the specified string has already been used a s a search match
*/
static int history_is_used( const wchar_t *str )
{
int i;
int res =0;
item_t *it = 0;
for( i=0; i<al_get_count( ¤t_mode->used); i++ )
{
long idx = al_get_long( ¤t_mode->used, i );
it = item_get( current_mode, al_get( ¤t_mode->item, (int)idx ) );
if( wcscmp( it->data, str ) == 0 )
{
res = 1;
break;
}
}
return res;
}
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->search_start){
/*
We found no match against the start of the line, try searching
the entire line
*/
current_mode->search_start = 0;
current_mode->pos = al_get_count( ¤t_mode->item );
return history_prev_match( needle );
}
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;
}
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;
}
void history_first()
{
if( current_mode )
{
if( !current_mode->has_loaded )
{
history_load( current_mode );
}
current_mode->pos = 0;
}
}
void history_reset()
{
if( current_mode )
{
current_mode->pos = al_get_count( ¤t_mode->item );
/*
Clear list of search matches
*/
al_truncate( ¤t_mode->used, 0 );
/*
set the search_start mode flag back to 1
*/
current_mode->search_start=1;
}
}
const wchar_t *history_next_match( const wchar_t *needle)
{
if( current_mode )
{
/*
The index of previous search matches are saved in the 'used'
list. We just need to pop the top item and set the new
position. Easy!
*/
if( al_get_count( ¤t_mode->used ) )
{
al_pop( ¤t_mode->used );
if( al_get_count( ¤t_mode->used ) )
{
current_mode->pos = (int) al_peek_long( ¤t_mode->used );
item_t *i = item_get( current_mode, al_get( ¤t_mode->item, current_mode->pos ) );
return i->data;
}
}
/*
The used-list is empty. Set position to 'past end of list'
and return the search string.
*/
current_mode->pos = al_get_count( ¤t_mode->item );
}
return needle;
}
void history_set_mode( const wchar_t *name )
{
if( !mode_table )
{
mode_table = malloc( sizeof(hash_table_t ));
hash_init( mode_table, &hash_wcs_func, &hash_wcs_cmp );
}
current_mode = (history_mode_t *)hash_get( mode_table, name );
if( !current_mode )
{
current_mode = history_create_mode( name );
hash_put( mode_table, name, current_mode );
}
}
void history_init()
{
}
void history_destroy()
{
if( mode_table )
{
hash_foreach( mode_table, (void (*)(void *, void *))&history_save_mode );
hash_foreach( mode_table, (void (*)(void *, void *))&history_destroy_mode_wrapper );
hash_destroy( mode_table );
free( mode_table );
mode_table=0;
}
}
void history_sanity_check()
{
/*
No sanity checking implemented yet...
*/
}
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
Fish-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/fish-users
