file_info_t * file_info( OBJECT * filename )
{
file_info_t *finfo = &filecache_finfo;
int found;
if ( !filecache_hash )
filecache_hash = hashinit( sizeof( file_info_t ), "file_info" );
filename = path_as_key( filename );
finfo = (file_info_t *)hash_insert( filecache_hash, filename, &found );
if ( !found )
{
/* printf( "file_info: %s\n", filename ); */
finfo->name = object_copy( filename );
finfo->is_file = 0;
finfo->is_dir = 0;
finfo->size = 0;
finfo->time = 0;
finfo->files = L0;
}
object_free( filename );
return finfo;
}
static void time_enter( void * closure, OBJECT * target, int const found,
timestamp const * const time )
{
int item_found;
BINDING * b;
struct hash * const bindhash = (struct hash *)closure;
target = path_as_key( target );
b = (BINDING *)hash_insert( bindhash, target, &item_found );
if ( !item_found )
{
b->name = object_copy( target );
b->flags = 0;
}
timestamp_copy( &b->time, time );
b->progress = found ? BIND_FOUND : BIND_SPOTTED;
if ( DEBUG_BINDSCAN )
out_printf( "time ( %s ) : %s\n", object_str( target ), time_progress[
b->progress ] );
object_free( target );
}
file_info_t * file_info( OBJECT * filename )
{
file_info_t *finfo = &filecache_finfo;
if ( !filecache_hash )
filecache_hash = hashinit( sizeof( file_info_t ), "file_info" );
filename = path_as_key( filename );
finfo->name = filename;
finfo->is_file = 0;
finfo->is_dir = 0;
finfo->size = 0;
finfo->time = 0;
finfo->files = 0;
if ( hashenter( filecache_hash, (HASHDATA**)&finfo ) )
{
/* printf( "file_info: %s\n", filename ); */
finfo->name = object_copy( finfo->name );
}
object_free( filename );
return finfo;
}
file_info_t * file_info( OBJECT * const path, int * found )
{
OBJECT * const path_key = path_as_key( path );
file_info_t * finfo;
if ( !filecache_hash )
filecache_hash = hashinit( sizeof( file_info_t ), "file_info" );
finfo = (file_info_t *)hash_insert( filecache_hash, path_key, found );
if ( !*found )
{
finfo->name = path_key;
finfo->files = L0;
}
else
object_free( path_key );
return finfo;
}
/* Records the binding of a target with an explicit LOCATE. */
void set_explicit_binding( OBJECT * target, OBJECT * locate )
{
OBJECT * boundname;
OBJECT * key;
PATHNAME f[ 1 ];
string buf[ 1 ];
int found;
BINDING * ba;
if ( !explicit_bindings )
explicit_bindings = hashinit( sizeof( BINDING ), "explicitly specified "
"locations" );
string_new( buf );
/* Parse the filename. */
path_parse( object_str( target ), f );
/* Ignore the grist. */
f->f_grist.ptr = 0;
f->f_grist.len = 0;
/* Root the target path at the given location. */
f->f_root.ptr = object_str( locate );
f->f_root.len = strlen( object_str( locate ) );
path_build( f, buf );
boundname = object_new( buf->value );
if ( DEBUG_SEARCH )
printf( "explicit locate %s: %s\n", object_str( target ), buf->value );
string_free( buf );
key = path_as_key( boundname );
object_free( boundname );
ba = (BINDING *)hash_insert( explicit_bindings, key, &found );
if ( !found )
{
ba->binding = key;
ba->target = target;
}
else
object_free( key );
}
file_archive_info_t * file_archive_info( OBJECT * const path, int * found )
{
OBJECT * const path_key = path_as_key( path );
file_archive_info_t * archive;
if ( !archivecache_hash )
archivecache_hash = hashinit( sizeof( file_archive_info_t ),
"file_archive_info" );
archive = (file_archive_info_t *)hash_insert( archivecache_hash, path_key,
found );
if ( !*found )
{
archive->file = 0;
archive->members = FL0;
}
else
object_free( path_key );
return archive;
}
file_info_t * file_info( OBJECT * const path )
{
OBJECT * const path_key = path_as_key( path );
file_info_t * finfo;
int found;
if ( !filecache_hash )
filecache_hash = hashinit( sizeof( file_info_t ), "file_info" );
finfo = (file_info_t *)hash_insert( filecache_hash, path_key, &found );
if ( !found )
{
finfo->name = path_key;
finfo->is_file = 0;
finfo->is_dir = 0;
timestamp_clear( &finfo->time );
finfo->files = L0;
}
else
object_free( path_key );
return finfo;
}
OBJECT *
search(
OBJECT * target,
time_t *time,
OBJECT * * another_target,
int file
)
{
PATHNAME f[1];
LIST * varlist;
string buf[1];
int found = 0;
/* Will be set to 1 if target location is specified via LOCATE. */
int explicitly_located = 0;
OBJECT * boundname = 0;
OBJECT * varname;
if ( another_target )
*another_target = 0;
if (! explicit_bindings )
explicit_bindings = hashinit( sizeof(BINDING),
"explicitly specified locations");
string_new( buf );
/* Parse the filename */
path_parse( object_str( target ), f );
f->f_grist.ptr = 0;
f->f_grist.len = 0;
varname = object_new( "LOCATE" );
varlist = var_get( varname );
object_free( varname );
if ( varlist )
{
OBJECT * key;
f->f_root.ptr = object_str( varlist->value );
f->f_root.len = strlen( object_str( varlist->value ) );
path_build( f, buf, 1 );
if ( DEBUG_SEARCH )
printf( "locate %s: %s\n", object_str( target ), buf->value );
explicitly_located = 1;
key = object_new( buf->value );
timestamp( key, time );
object_free( key );
found = 1;
}
else if ( ( varname = object_new( "SEARCH" ),
varlist = var_get( varname ),
object_free( varname ),
varlist ) )
{
while ( varlist )
{
BINDING b, *ba = &b;
file_info_t *ff;
OBJECT * key;
OBJECT * test_path;
f->f_root.ptr = object_str( varlist->value );
f->f_root.len = strlen( object_str( varlist->value ) );
string_truncate( buf, 0 );
path_build( f, buf, 1 );
if ( DEBUG_SEARCH )
printf( "search %s: %s\n", object_str( target ), buf->value );
test_path = object_new( buf->value );
key = path_as_key( test_path );
object_free( test_path );
ff = file_query( key );
timestamp( key, time );
b.binding = key;
if ( hashcheck( explicit_bindings, (HASHDATA**)&ba ) )
{
if ( DEBUG_SEARCH )
printf(" search %s: found explicitly located target %s\n",
object_str( target ), object_str( ba->target ) );
if ( another_target )
*another_target = ba->target;
found = 1;
object_free( key );
break;
}
else if ( ff && ff->time )
{
if ( !file || ff->is_file )
{
found = 1;
object_free( key );
break;
}
}
object_free( key );
varlist = list_next( varlist );
}
}
if ( !found )
{
/* Look for the obvious */
/* This is a questionable move. Should we look in the */
/* obvious place if SEARCH is set? */
OBJECT * key;
f->f_root.ptr = 0;
f->f_root.len = 0;
string_truncate( buf, 0 );
path_build( f, buf, 1 );
if ( DEBUG_SEARCH )
printf( "search %s: %s\n", object_str( target ), buf->value );
key = object_new( buf->value );
timestamp( key, time );
object_free( key );
}
boundname = object_new( buf->value );
string_free( buf );
if ( explicitly_located )
{
BINDING b;
BINDING * ba = &b;
OBJECT * key = path_as_key( boundname );
b.binding = key;
b.target = target;
/* CONSIDER: we probably should issue a warning is another file
is explicitly bound to the same location. This might break
compatibility, though. */
if ( !hashenter( explicit_bindings, (HASHDATA * *)&ba ) )
{
object_free( key );
}
}
/* prepare a call to BINDRULE if the variable is set */
call_bind_rule( target, boundname );
return boundname;
}
OBJECT * short_path_to_long_path( OBJECT * short_path )
{
return path_as_key( short_path );
}
OBJECT *
search(
OBJECT * target,
time_t *time,
OBJECT * * another_target,
int file
)
{
PATHNAME f[1];
LIST * varlist;
string buf[1];
int found = 0;
/* Will be set to 1 if target location is specified via LOCATE. */
int explicitly_located = 0;
OBJECT * boundname = 0;
if ( another_target )
*another_target = 0;
if (! explicit_bindings )
explicit_bindings = hashinit( sizeof(BINDING),
"explicitly specified locations");
string_new( buf );
/* Parse the filename */
path_parse( object_str( target ), f );
f->f_grist.ptr = 0;
f->f_grist.len = 0;
varlist = var_get( root_module(), constant_LOCATE );
if ( !list_empty( varlist ) )
{
OBJECT * key;
f->f_root.ptr = object_str( list_front( varlist ) );
f->f_root.len = strlen( object_str( list_front( varlist ) ) );
path_build( f, buf, 1 );
if ( DEBUG_SEARCH )
printf( "locate %s: %s\n", object_str( target ), buf->value );
explicitly_located = 1;
key = object_new( buf->value );
timestamp( key, time );
object_free( key );
found = 1;
}
else if ( varlist = var_get( root_module(), constant_SEARCH ), !list_empty( varlist ) )
{
LISTITER iter = list_begin( varlist ), end = list_end( varlist );
for ( ; iter != end; iter = list_next( iter ) )
{
BINDING * ba;
file_info_t *ff;
OBJECT * key;
OBJECT * test_path;
f->f_root.ptr = object_str( list_item( iter ) );
f->f_root.len = strlen( object_str( list_item( iter ) ) );
string_truncate( buf, 0 );
path_build( f, buf, 1 );
if ( DEBUG_SEARCH )
printf( "search %s: %s\n", object_str( target ), buf->value );
test_path = object_new( buf->value );
key = path_as_key( test_path );
object_free( test_path );
ff = file_query( key );
timestamp( key, time );
if ( ( ba = (BINDING *)hash_find( explicit_bindings, key ) ) )
{
if ( DEBUG_SEARCH )
printf(" search %s: found explicitly located target %s\n",
object_str( target ), object_str( ba->target ) );
if ( another_target )
*another_target = ba->target;
found = 1;
object_free( key );
break;
}
else if ( ff && ff->time )
{
if ( !file || ff->is_file )
{
found = 1;
object_free( key );
break;
}
}
object_free( key );
}
}
if ( !found )
{
/* Look for the obvious */
/* This is a questionable move. Should we look in the */
/* obvious place if SEARCH is set? */
OBJECT * key;
f->f_root.ptr = 0;
f->f_root.len = 0;
string_truncate( buf, 0 );
path_build( f, buf, 1 );
if ( DEBUG_SEARCH )
printf( "search %s: %s\n", object_str( target ), buf->value );
key = object_new( buf->value );
timestamp( key, time );
object_free( key );
}
boundname = object_new( buf->value );
string_free( buf );
if ( explicitly_located )
{
int found;
BINDING * ba;
OBJECT * key = path_as_key( boundname );
/* CONSIDER: we probably should issue a warning is another file
is explicitly bound to the same location. This might break
compatibility, though. */
ba = (BINDING *)hash_insert( explicit_bindings, key, &found );
if ( !found )
{
ba->binding = key;
ba->target = target;
}
else
{
object_free( key );
}
}
/* prepare a call to BINDRULE if the variable is set */
call_bind_rule( target, boundname );
return boundname;
}
OBJECT * search( OBJECT * target, timestamp * const time,
OBJECT * * another_target, int const file )
{
PATHNAME f[ 1 ];
LIST * varlist;
string buf[ 1 ];
int found = 0;
OBJECT * boundname = 0;
if ( another_target )
*another_target = 0;
if ( !explicit_bindings )
explicit_bindings = hashinit( sizeof( BINDING ), "explicitly specified "
"locations" );
string_new( buf );
/* Parse the filename. */
path_parse( object_str( target ), f );
f->f_grist.ptr = 0;
f->f_grist.len = 0;
varlist = var_get( root_module(), constant_LOCATE );
if ( !list_empty( varlist ) )
{
OBJECT * key;
f->f_root.ptr = object_str( list_front( varlist ) );
f->f_root.len = strlen( object_str( list_front( varlist ) ) );
path_build( f, buf );
if ( DEBUG_SEARCH )
printf( "locate %s: %s\n", object_str( target ), buf->value );
key = object_new( buf->value );
timestamp_from_path( time, key );
object_free( key );
found = 1;
}
else if ( varlist = var_get( root_module(), constant_SEARCH ),
!list_empty( varlist ) )
{
LISTITER iter = list_begin( varlist );
LISTITER const end = list_end( varlist );
for ( ; iter != end; iter = list_next( iter ) )
{
BINDING * ba;
file_info_t * ff;
OBJECT * key;
OBJECT * test_path;
f->f_root.ptr = object_str( list_item( iter ) );
f->f_root.len = strlen( object_str( list_item( iter ) ) );
string_truncate( buf, 0 );
path_build( f, buf );
if ( DEBUG_SEARCH )
printf( "search %s: %s\n", object_str( target ), buf->value );
test_path = object_new( buf->value );
key = path_as_key( test_path );
object_free( test_path );
ff = file_query( key );
timestamp_from_path( time, key );
if ( ( ba = (BINDING *)hash_find( explicit_bindings, key ) ) )
{
if ( DEBUG_SEARCH )
printf(" search %s: found explicitly located target %s\n",
object_str( target ), object_str( ba->target ) );
if ( another_target )
*another_target = ba->target;
found = 1;
object_free( key );
break;
}
else if ( ff )
{
if ( !file || ff->is_file )
{
found = 1;
object_free( key );
break;
}
}
object_free( key );
}
}
if ( !found )
{
/* Look for the obvious. */
/* This is a questionable move. Should we look in the obvious place if
* SEARCH is set?
*/
OBJECT * key;
f->f_root.ptr = 0;
f->f_root.len = 0;
string_truncate( buf, 0 );
path_build( f, buf );
if ( DEBUG_SEARCH )
printf( "search %s: %s\n", object_str( target ), buf->value );
key = object_new( buf->value );
timestamp_from_path( time, key );
object_free( key );
}
boundname = object_new( buf->value );
string_free( buf );
/* Prepare a call to BINDRULE if the variable is set. */
call_bind_rule( target, boundname );
return boundname;
}
