Exemplo n.º 1
0
void wcache_invalidate_cache(void)
{
	struct winbindd_domain *domain;

	for (domain = domain_list(); domain; domain = domain->next) {
		struct winbind_cache *cache = get_cache(domain);

		DEBUG(10, ("wcache_invalidate_cache: invalidating cache "
			   "entries for %s\n", domain->name));
		if (cache)
			tdb_traverse(cache->tdb, traverse_fn, NULL);
	}
}
Exemplo n.º 2
0
CacheRef< CachedTexture > get_texture(string const &filename, bool pad, bool flip) {
    string key = "texture:";
    key += (pad?'1':'0');
    key += (flip?'1':'0');
    key += filename;
    CacheRef< CachedTexture > ret(NULL);
    CachedTexture *item = (CachedTexture *)get_cache().get_item(key);
    if (!item) {
        item = new CachedTexture(filename, pad, flip);
        if (!item->loaded) {
            cerr << "Texture loading failed for " << filename << "." << endl;
            delete item;
            return ret;
        }
        get_cache().add_item(key, item);
    }
    if (item->id != TEXTURE_ID) {
        cerr << "Item with key '" << key << "' isn't a texture." << endl;
        return ret;
    }
    ret.set(item);
    return ret;
}
Exemplo n.º 3
0
static void refresh_sequence_number(struct winbindd_domain *domain, BOOL force)
{
	NTSTATUS status;
	unsigned time_diff;
	time_t t = time(NULL);
	unsigned cache_time = lp_winbind_cache_time();

	get_cache( domain );

#if 0	/* JERRY -- disable as the default cache time is now 5 minutes */
	/* trying to reconnect is expensive, don't do it too often */
	if (domain->sequence_number == DOM_SEQUENCE_NONE) {
		cache_time *= 8;
	}
#endif

	time_diff = t - domain->last_seq_check;

	/* see if we have to refetch the domain sequence number */
	if (!force && (time_diff < cache_time)) {
		DEBUG(10, ("refresh_sequence_number: %s time ok\n", domain->name));
		goto done;
	}
	
	/* try to get the sequence number from the tdb cache first */
	/* this will update the timestamp as well */
	
	status = fetch_cache_seqnum( domain, t );
	if ( NT_STATUS_IS_OK(status) )
		goto done;	

	status = domain->backend->sequence_number(domain, &domain->sequence_number);

	if (!NT_STATUS_IS_OK(status)) {
		domain->sequence_number = DOM_SEQUENCE_NONE;
	}
	
	domain->last_status = status;
	domain->last_seq_check = time(NULL);
	
	/* save the new sequence number ni the cache */
	store_cache_seqnum( domain );

done:
	DEBUG(10, ("refresh_sequence_number: %s seq number is now %d\n", 
		   domain->name, domain->sequence_number));

	return;
}
Exemplo n.º 4
0
CacheRef< CachedFont > get_font(string name)
{
  string key = "font:" + name;
  CacheRef< CachedFont > ret(NULL);
  CachedFont *item = (CachedFont *)get_cache().get_item(key);
  if (!item)
  {
    TexFont *font = txfLoadFont(name.c_str());
    if (font == NULL)
    {
      cerr << "Error loading font '" << name << "'." << endl;
      return ret;
    }
    item = new CachedFont(font);
    get_cache().add_item(key, item);
  }
  if (item->id != FONT_ID)
  {
    cerr << "Item with key '" << key << "' isn't a font." << endl;
    return ret;
  }
  ret.set(item);
  return ret;
}
Exemplo n.º 5
0
/* enumerate trusted domains */
static NTSTATUS trusted_domains(struct winbindd_domain *domain,
				TALLOC_CTX *mem_ctx,
				uint32 *num_domains,
				char ***names,
				char ***alt_names,
				DOM_SID **dom_sids)
{
	get_cache(domain);

	DEBUG(10,("trusted_domains: [Cached] - doing backend query for info for domain %s\n",
		domain->name ));

	/* we don't cache this call */
	return domain->backend->trusted_domains(domain, mem_ctx, num_domains, 
					       names, alt_names, dom_sids);
}
Exemplo n.º 6
0
struct directory *init_directory(struct node *node){
  struct cache *cache = get_cache(node);
  struct directory *dir;
  if (!cache->directory){
    dir = NULL;
    return dir;
  }

  dir = malloc(sizeof(struct directory));
  dir->nb_sons = get_nb_sons(node);
  struct cache **caches = malloc(dir->nb_sons * sizeof(struct cache *));

  int current = 0;
  assign_sons(dir, node, caches, &current);
  dir->sons_caches = caches;
  return dir;
}
Exemplo n.º 7
0
/*
 * Find a entry in the specified dir with name _dname_.
 */
static const struct iso_dir_entry *
iso_find_entry(const char *dname, struct inode *inode)
{
    struct fs_info *fs = inode->fs;
    block_t dir_block = PVT(inode)->lba;
    int i = 0, offset = 0;
    const char *de_name;
    int de_name_len, de_len;
    const struct iso_dir_entry *de;
    const char *data = NULL;

    dprintf("iso_find_entry: \"%s\"\n", dname);
    
    while (1) {
	if (!data) {
	    dprintf("Getting block %d from block %llu\n", i, dir_block);
	    if (++i > inode->blocks)
		return NULL;	/* End of directory */
	    data = get_cache(fs->fs_dev, dir_block++);
	    offset = 0;
	}

	de = (const struct iso_dir_entry *)(data + offset);
	de_len = de->length;
	offset += de_len;
	
	/* Make sure we have a full directory entry */
	if (de_len < 33 || offset > BLOCK_SIZE(fs)) {
	    /*
	     * Zero = end of sector, or corrupt directory entry
	     *
	     * ECMA-119:1987 6.8.1.1: "Each Directory Record shall end
	     * in the Logical Sector in which it begins.
	     */
	    data = NULL;
	    continue;
	}
	
	de_name_len = de->name_len;
	de_name = de->name;
	if (iso_compare_name(de_name, de_name_len, dname)) {
	    dprintf("Found.\n");
	    return de;
	}
    }
}
Exemplo n.º 8
0
url
get_from_web (url name) {
    if (!is_rooted_web (name)) return url_none ();
    url res= get_cache (name);
    if (!is_none (res)) return res;

#ifdef OS_WIN32
    string urlString = as_string (name);
    url tmp = url_temp();

    if (starts (urlString, "www."))
        urlString = "http://" * urlString;
    else if (starts (urlString, "ftp."))
        urlString = "ftp://" * urlString;
    else if (starts (urlString, "ftp://"))
        urlPath = NULL;
    else if (starts (urlString, "http://"))
        urlPath = NULL;
    else
        urlString = "http://" * urlString;
    urlString= web_encode (urlString);

    c_string urlPath (urlString);
    c_string tempFilePath (as_string (tmp));

    if(!URL_Get(urlPath, tempFilePath))
        return url_none();
    else return set_cache (name, tmp);
#else
    string test= var_eval_system ("which wget");
    if (!ends (test, "wget")) return url_none ();
    url tmp= url_temp ();
    string tmp_s= escape_sh (concretize (tmp));
    string cmd= "wget --header='User-Agent: TeXmacs-" TEXMACS_VERSION "' -q";
    cmd << " -O " << tmp_s << " " << escape_sh (web_encode (as_string (name)));
    // cout << cmd << "\n";
    system (cmd);
    // cout << "got " << name << " as " << tmp << "\n";

    if (var_eval_system ("cat " * tmp_s * " 2> /dev/null") == "") {
        remove (tmp);
        return url_none ();
    }
    else return set_cache (name, tmp);
#endif
}
Exemplo n.º 9
0
caddr_t
get_bcache(fileid_t *fp)
{
	/*
	 *  Search Disk Block Cache:
	 *
	 *  This should be getting pretty monotonous by now.  Aren't generalized
	 *  subroutines ("objects", if you prefer) great?
	 */
	cache_t *bcp;

	x_len = fp->fi_count;
	x_blkno = fp->fi_blocknum;
	x_dev = fp->fi_devp->di_dcookie;
	bcp = get_cache(bc_hash[BC_HASH(x_dev, x_blkno, x_len)], &bc_head);

	return (bcp ? (caddr_t)bcp->data : 0);
}
Exemplo n.º 10
0
void *
get_icache(int dev, int inum)
{
	/*
	 *  Search File Cache:
	 *
	 *  This routine searches the file cache looking for the entry bound to
	 *  the given "dev"ice and file number ["inum"].  If said entry exists,
	 *  it returns the address of the associated file structure.  Otherwise
	 *  it returns null.
	 */
	cache_t *icp;

	x_dev = dev;
	x_inode = inum;
	icp = get_cache(ic_hash[IC_HASH(dev, inum)], &ic_head);

	return (icp ? (caddr_t)icp->data : 0);
}
Exemplo n.º 11
0
Arquivo: nif.c Projeto: arekinath/e2qc
/* create(Cache :: atom(), MaxSize :: integer(), MinQ1Size :: integer()) */
static ERL_NIF_TERM
create(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
	ERL_NIF_TERM atom;
	ErlNifUInt64 max_size, min_q1_size;
	struct cache *c;

	if (!enif_is_atom(env, argv[0]))
		return enif_make_badarg(env);
	atom = argv[0];

	if (!enif_get_uint64(env, argv[1], &max_size))
		return enif_make_badarg(env);
	if (!enif_get_uint64(env, argv[2], &min_q1_size))
		return enif_make_badarg(env);

	if ((c = get_cache(atom))) {
		ERL_NIF_TERM ret = enif_make_atom(env, "already_exists");
		enif_consume_timeslice(env, 5);

		enif_rwlock_rwlock(c->cache_lock);
		/* expansion is safe because we don't have to engage the background
		   thread and won't cause sudden eviction pressure
		   TODO: a nice way to shrink the cache without seizing it up */
		if (c->max_size < max_size && c->min_q1_size < min_q1_size) {
			c->max_size = max_size;
			c->min_q1_size = min_q1_size;
			enif_rwlock_rwunlock(c->cache_lock);

			ret = enif_make_atom(env, "ok");
			enif_consume_timeslice(env, 10);
		} else {
			enif_rwlock_rwunlock(c->cache_lock);
		}

		return ret;
	} else {
		c = new_cache(atom, max_size, min_q1_size);
		enif_consume_timeslice(env, 20);
		return enif_make_atom(env, "ok");
	}
}
Exemplo n.º 12
0
static int bee_dep_conflicts(int argc, char *argv[])
{
    int c, opt_count, help;
    struct hash *graph;
    struct option long_options[] = {
        {"help", 0, &help, 1},
        {0, 0, 0, 0}
    };

    help = opt_count = 0;

    while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
        switch (c) {
            case '?':
                usage_conflicts();
                return 1;

            default:
                opt_count++;
        }
    }

    if (help) {
        usage_conflicts();
        return 0;
    }

    if (optind < argc) {
        fprintf(stderr, "bee-dep: too many arguments\n");
        return 1;
    }

    graph = get_cache();

    if (print_conflicts(graph)) {
        hash_free(graph);
        return 1;
    }

    hash_free(graph);
    return 0;
}
Exemplo n.º 13
0
int
get_dcache(int dev, char *name, int pnum)
{
	/*
	 *  Search Directory Cache:
	 *
	 *  This routine searches the directory cache for an entry
	 *  associated with directory number "pnum" from the given
	 *  file system that de-scribes a file of the given "name".
	 *  If we find such an entry, we return the corresponding file
	 *  number, 0 otherwise.
	 */
	dc_t *dcp;

	x_dev = dev;
	x_len = strlen(name)+1;
	x_pnum = pnum;
	x_name = name;
	dcp = (dc_t *)get_cache(dc_hash[DC_HASH(dev, name, x_len)], &dc_head);

	return (dcp ? dcp->dc_inum : 0);
}
Exemplo n.º 14
0
void* pref_main (void* arg) {
	int thread_id = *((int*)arg);
	free(arg);
	while (1) {
		char guess[MAX_REQUEST]; // Buffer for guessed filename
		int size = 0;

		void* item = queue_consume( &prefetch_queue );
		
		// this happens only if queue_consume_all() was called and no items remain.
		if( item == (void*)-1 ) {
			printf( "Prefetcher exiting.\n" );
			pthread_exit( (void*)NULL );
		}
		
		request_t* req = (request_t*)item;

		if (nextguess(req->filename, guess) != 0) { 
			fprintf(stderr, "Prefetcher failed to get next guess\n");
			fprintf(stderr, " --filename: %s\n", req->filename );
			fprintf(stderr, " --guess: %s\n", guess );
		} else {
			// try to get the cache entry for the guess. if it isn't there
			// then put it there.
			char* data;
			if (get_cache(guess, &data) == -1) {
				size = get_file_data(guess, &data);
				put_cache(guess, data, size);
			}
		}

		// free request created by dispatch.
		free( req->filename );
		free( req );
			
	}

}
Exemplo n.º 15
0
static int
get_lang_stemmer(term_t t, struct sb_stemmer **stemmer)
{ stem_cache *cache = get_cache();
  atom_t lang;
  int i;

  if ( !PL_get_atom(t, &lang) )
    return type_error("atom", t);

  for(i=0; i<CACHE_SIZE; i++)
  { if ( cache->stemmers[i].language == lang )
    { *stemmer = cache->stemmers[i].stemmer;
      return TRUE;
    }
  }
  for(i=0; i<CACHE_SIZE; i++)
  { if ( !cache->stemmers[i].stemmer )
    { struct sb_stemmer *st;

      if ( !(st= sb_stemmer_new(PL_atom_chars(lang), NULL)) )
      { if ( errno == ENOMEM )
	  return resource_error("memory");
	else
	  return domain_error("snowball_algorithm", t);
      }

      cache->stemmers[i].language = lang;
      cache->stemmers[i].stemmer  = st;
      PL_register_atom(cache->stemmers[i].language);

      *stemmer = cache->stemmers[i].stemmer;
      return TRUE;
    }
  }

  assert(0);				/* TBD: clean cache */
  return FALSE;
}
Exemplo n.º 16
0
void map::apply_directional_light( const tripoint &p, int direction, float luminance )
{
    const int x = p.x;
    const int y = p.y;

    auto &cache = get_cache( p.z );
    float (&lm)[MAPSIZE*SEEX][MAPSIZE*SEEY] = cache.lm;
    float (&transparency_cache)[MAPSIZE*SEEX][MAPSIZE*SEEY] = cache.transparency_cache;

    if( direction == 90 ) {
        castLight<1, 0, 0, -1, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
        castLight<-1, 0, 0, -1, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
    } else if( direction == 0 ) {
        castLight<0, -1, 1, 0, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
        castLight<0, -1, -1, 0, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
    } else if( direction == 270 ) {
        castLight<1, 0, 0, 1, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
        castLight<-1, 0, 0, 1, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
    } else if( direction == 180 ) {
        castLight<0, 1, 1, 0, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
        castLight<0, 1, -1, 0, light_calc, light_check>( lm, transparency_cache, x, y, 0, luminance );
    }
}
Exemplo n.º 17
0
url
get_from_server (url u) {
    if (!is_rooted_tmfs (u)) return url_none ();
    url res= get_cache (u);
    if (!is_none (res)) return res;

    string name= as_string (u);
    if (ends (name, "~") || ends (name, "#")) {
        if (!is_rooted_tmfs (name)) return url_none ();
        if (!as_bool (call ("tmfs-can-autosave?", unglue (u, 1))))
            return url_none ();
    }
    string r= as_string (call ("tmfs-load", object (name)));
    if (r == "") return url_none ();
    url tmp= url_temp ();
    (void) save_string (tmp, r, true);

    //return set_cache (u, tmp);
    return tmp;
    // FIXME: certain files could be cached, but others not
    // for instance, files which are loaded in a delayed fashion
    // would always be cached as empty files, which is erroneous.
}
Exemplo n.º 18
0
static const struct ext2_inode *
ext2_get_inode(struct fs_info *fs, int inr)
{
    const struct ext2_group_desc *desc;
    const char *data;
    uint32_t inode_group, inode_offset;
    uint32_t block_num, block_off;

    inr--;
    inode_group  = inr / EXT2_INODES_PER_GROUP(fs);
    inode_offset = inr % EXT2_INODES_PER_GROUP(fs);
    desc = ext2_get_group_desc(fs, inode_group);
    if (!desc)
	return NULL;

    block_num = desc->bg_inode_table +
	inode_offset / EXT2_INODES_PER_BLOCK(fs);
    block_off = inode_offset % EXT2_INODES_PER_BLOCK(fs);

    data = get_cache(fs->fs_dev, block_num);

    return (const struct ext2_inode *)
	(data + block_off * EXT2_SB(fs)->s_inode_size);
}
Exemplo n.º 19
0
/*
 * get the group's descriptor of group_num
 */
static const struct ext2_group_desc *
ext2_get_group_desc(struct fs_info *fs, uint32_t group_num)
{
    struct ext2_sb_info *sbi = EXT2_SB(fs);
    uint32_t desc_block, desc_index;
    const struct ext2_group_desc *desc_data_block;

    if (group_num >= sbi->s_groups_count) {
	printf ("ext2_get_group_desc"
		"block_group >= groups_count - "
		"block_group = %d, groups_count = %d",
		group_num, sbi->s_groups_count);

	return NULL;
    }

    desc_block = group_num / sbi->s_desc_per_block;
    desc_index = group_num % sbi->s_desc_per_block;

    desc_block += sbi->s_first_data_block + 1;

    desc_data_block = get_cache(fs->fs_dev, desc_block);
    return &desc_data_block[desc_index];
}
Exemplo n.º 20
0
 */

/**
 * \file coherence.c
 * \brief Initialize SMC structure, link from SMC to C.
 * \author ~ahonorat
 * \version 1.7
 * \date 16th march 2014
 *
 */


#include "coherence.h"

void coherence_up_stat(struct coherence *this, struct node *node, unsigned long entry, int stats_type){
  struct cache *cache = get_cache(node);
  up_stat(cache, entry, stats_type);
} 	


void coherence_invalid_line(struct coherence *this, struct line *line) {
  line->status = I;
}

void coherence_modify_line(struct coherence *this, struct line *line) {
  line->status = M;
  line->dirty = 1;
}

void coherence_share_line(struct coherence *this, struct line *line) {
  line->status = S;
Exemplo n.º 21
0
int vpbp_dread(SceUID fd, SceIoDirent * dir)
{
    int result, cur_idx, ret;
    struct IoDirentEntry *entry;

    lock();

    entry = dirent_search(fd);

    if(entry == NULL) {
        result = -44;
        goto exit;
    }

    result = sceIoDread(entry->iso_dfd, dir);

    if(sceKernelFindModuleByName("Game_Categories_Light") == NULL) {
        while(result > 0 && !is_iso(dir)) {
            result = sceIoDread(entry->iso_dfd, dir);
        }
    }

    if (result > 0 && is_iso(dir)) {
        VirtualPBP *vpbp;

        vpbp = vpbp_realloc(g_vpbps, g_vpbps_cnt+1);

        if(vpbp == NULL) {
            result = -42;
            goto exit;
        }

        g_vpbps = vpbp;
        g_vpbps_cnt++;
        cur_idx = g_vpbps_cnt-1;
        vpbp = &g_vpbps[cur_idx];
        STRCPY_S(vpbp->name, entry->path);
        vpbp->name[4] = '\0';
        STRCAT_S(vpbp->name, "/ISO");
        STRCAT_S(vpbp->name, entry->path + sizeof("xxx:/PSP/GAME") - 1);
        STRCAT_S(vpbp->name, "/");
        STRCAT_S(vpbp->name, dir->d_name);
        memcpy(&vpbp->ctime, &dir->d_stat.st_ctime, sizeof(vpbp->ctime));
        memcpy(&vpbp->mtime, &dir->d_stat.st_mtime, sizeof(vpbp->mtime));

        ret = get_cache(vpbp->name, &vpbp->mtime, vpbp);

        if (ret < 0) {
            ret = build_vpbp(vpbp);

            if (ret < 0) {
                result = -43;
                goto exit;
            }
        }

        result = add_fake_dirent(dir, cur_idx);
    }

exit:
    unlock();

    return result;
}
Exemplo n.º 22
0
Arquivo: nif.c Projeto: arekinath/e2qc
static ERL_NIF_TERM
put(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
	ERL_NIF_TERM atom;
	ErlNifBinary kbin, vbin;
	struct cache *c;
	struct cache_node *n, *ng;
	ErlNifUInt64 lifetime = 0;

	if (!enif_is_atom(env, argv[0]))
		return enif_make_badarg(env);
	atom = argv[0];

	if (!enif_inspect_binary(env, argv[1], &kbin))
		return enif_make_badarg(env);
	if (!enif_inspect_binary(env, argv[2], &vbin))
		return enif_make_badarg(env);

	if ((c = get_cache(atom))) {
		enif_consume_timeslice(env, 1);

	} else {
		/* if we've been asked to put() in to a cache that doesn't exist yet
		   then we should create it! */
		ErlNifUInt64 max_size, min_q1_size;
		if (!enif_get_uint64(env, argv[3], &max_size))
			return enif_make_badarg(env);
		if (!enif_get_uint64(env, argv[4], &min_q1_size))
			return enif_make_badarg(env);
		c = new_cache(atom, max_size, min_q1_size);
		enif_consume_timeslice(env, 20);
	}

	if (argc > 5)
		if (!enif_get_uint64(env, argv[5], &lifetime))
			return enif_make_badarg(env);

	n = enif_alloc(sizeof(*n));
	memset(n, 0, sizeof(*n));
	n->c = c;
	n->vsize = vbin.size;
	n->ksize = kbin.size;
	n->size = vbin.size + kbin.size;
	n->key = enif_alloc(kbin.size);
	memcpy(n->key, kbin.data, kbin.size);
	n->val = enif_alloc_resource(value_type, vbin.size);
	memcpy(n->val, vbin.data, vbin.size);
	n->q = &(c->q1);
	if (lifetime) {
		clock_now(&(n->expiry));
		n->expiry.tv_sec += lifetime;
	}

	enif_rwlock_rwlock(c->cache_lock);
	enif_rwlock_rwlock(c->lookup_lock);
	HASH_FIND(hh, c->lookup, kbin.data, kbin.size, ng);
	if (ng) {
		enif_mutex_lock(c->ctrl_lock);
		destroy_cache_node(ng);
		enif_mutex_unlock(c->ctrl_lock);
	}
	TAILQ_INSERT_HEAD(&(c->q1.head), n, entry);
	c->q1.size += n->size;
	HASH_ADD_KEYPTR(hh, c->lookup, n->key, n->ksize, n);
	if (lifetime) {
		struct cache_node *rn;
		rn = RB_INSERT(expiry_tree, &(c->expiry_head), n);
		/* it's possible to get two timestamps that are the same, if this happens
		   just bump us forwards by 1 usec until we're unique */
		while (rn != NULL) {
			++(n->expiry.tv_nsec);
			rn = RB_INSERT(expiry_tree, &(c->expiry_head), n);
		}
	}
	enif_rwlock_rwunlock(c->lookup_lock);
	enif_rwlock_rwunlock(c->cache_lock);

	enif_cond_broadcast(c->check_cond);
	enif_consume_timeslice(env, 50);

	return enif_make_atom(env, "ok");
}
Exemplo n.º 23
0
Arquivo: nif.c Projeto: arekinath/e2qc
static ERL_NIF_TERM
get(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
	ERL_NIF_TERM atom;
	ErlNifBinary kbin;
	struct cache *c;
	struct cache_node *n;
	struct cache_incr_node *in;
	struct timespec now;
	int incrqs, hashv, bkt;
	ERL_NIF_TERM ret;
	ErlNifTid tid;

	if (!enif_is_atom(env, argv[0]))
		return enif_make_badarg(env);
	atom = argv[0];

	if (!enif_inspect_binary(env, argv[1], &kbin))
		return enif_make_badarg(env);

	if ((c = get_cache(atom))) {
		enif_rwlock_rlock(c->lookup_lock);
		HASH_FIND(hh, c->lookup, kbin.data, kbin.size, n);
		if (!n) {
			enif_rwlock_runlock(c->lookup_lock);
			__sync_add_and_fetch(&c->miss, 1);
			enif_consume_timeslice(env, 10);
			return enif_make_atom(env, "notfound");
		}

		if (n->expiry.tv_sec != 0) {
			clock_now(&now);
			if (n->expiry.tv_sec < now.tv_sec) {
				enif_rwlock_runlock(c->lookup_lock);
				__sync_add_and_fetch(&c->miss, 1);
				enif_consume_timeslice(env, 10);
				return enif_make_atom(env, "notfound");
			}
		}

		in = enif_alloc(sizeof(*in));
		memset(in, 0, sizeof(*in));
		in->node = n;
		__sync_add_and_fetch(&c->hit, 1);

		tid = enif_thread_self();
		HASH_SFH(&tid, sizeof(ErlNifTid), N_INCR_BKT, hashv, bkt);
		enif_mutex_lock(c->incr_lock[bkt]);
		TAILQ_INSERT_TAIL(&(c->incr_head[bkt]), in, entry);
		enif_mutex_unlock(c->incr_lock[bkt]);
		incrqs = __sync_add_and_fetch(&(c->incr_count), 1);

		ret = enif_make_resource_binary(env, n->val, n->val, n->vsize);
		enif_rwlock_runlock(c->lookup_lock);

		if (incrqs > 1024)
			enif_cond_broadcast(c->check_cond);

		enif_consume_timeslice(env, 20);

		return ret;

	}

	return enif_make_atom(env, "notfound");
}
Exemplo n.º 24
0
/*
 * Map a logical sector and load it into the cache
 */
static const void *
ext2_get_cache(struct inode *inode, block_t lblock)
{
    block_t pblock = ext2_bmap(inode, lblock, NULL);
    return get_cache(inode->fs->fs_dev, pblock);
}
Exemplo n.º 25
0
int AModule::import_samples(AEdit *edit, 
	int64_t start_project,
	int64_t edit_startproject,
	int64_t edit_startsource,
	int direction,
	int sample_rate,
	Samples *buffer,
	int64_t fragment_len)
{
	int result = 0;
// start in EDL samplerate
	int64_t start_source = start_project - 
		edit_startproject + 
		edit_startsource;
// fragment size adjusted for speed curve
	int64_t speed_fragment_len = fragment_len;
// boundaries of input fragment required for speed curve
	double max_position = 0;
	double min_position = 0;

	double speed_position = edit_startsource;
// position in source where speed curve starts reading
	double speed_position1 = speed_position;
// position in source where speed curve finishes
	double speed_position2 = speed_position;

// Need speed curve processing
	int have_speed = 0;
// Temporary buffer for rendering speed curve
	Samples *speed_buffer = buffer;
	const int debug = 0;

if(debug) printf("AModule::import_samples %d edit=%p nested_edl=%p\n", 
__LINE__,
edit,
nested_edl);
	if(nested_edl && edit->channel >= nested_edl->session->audio_channels)
		return 1;
if(debug) printf("AModule::import_samples %d\n", __LINE__);

	this->channel = edit->channel;
if(debug) printf("AModule::import_samples %d speed_fragment_len=%ld\n", 
__LINE__,
speed_fragment_len);




// apply speed curve to source position so the timeline agrees with the playback
	if(track->has_speed())
	{
// get speed adjusted position from start of edit.
		FloatAuto *previous = 0;
		FloatAuto *next = 0;
		FloatAutos *speed_autos = (FloatAutos*)track->automation->autos[AUTOMATION_SPEED];
		for(int64_t i = edit_startproject; i < start_project; i++)
		{
			double speed = speed_autos->get_value(i, 
				PLAY_FORWARD,
				previous,
				next);
			speed_position += speed;
		}

		speed_position1 = speed_position;


// calculate boundaries of input fragment required for speed curve
		max_position = speed_position;
		min_position = speed_position;
		for(int64_t i = start_project; i < start_project + fragment_len; i++)
		{
			double speed = speed_autos->get_value(i, 
				PLAY_FORWARD,
				previous,
				next);
			speed_position += speed;
			if(speed_position > max_position) max_position = speed_position;
			if(speed_position < min_position) min_position = speed_position;
		}

		speed_position2 = speed_position;
		if(speed_position2 < speed_position1)
		{
			max_position += 1.0;
//			min_position -= 1.0;
			speed_fragment_len = (int64_t)(max_position - min_position);
		}
		else
		{
			max_position += 1.0;
			speed_fragment_len = (int64_t)(max_position - min_position);
		}

printf("AModule::import_samples %d %f %f %f %f\n", 
__LINE__, 
min_position, 
max_position,
speed_position1,
speed_position2);

// new start of source to read from file
		start_source = (int64_t)min_position;
		have_speed = 1;



// swap in the temp buffer
		if(speed_temp && speed_temp->get_allocated() < speed_fragment_len)
		{
			delete speed_temp;
			speed_temp = 0;
		}
		
		if(!speed_temp)
		{
			speed_temp = new Samples(speed_fragment_len);
		}
		
		speed_buffer = speed_temp;
	}



	if(speed_fragment_len == 0)
		return 1;



// Source is a nested EDL
	if(edit->nested_edl)
	{
		int command;
		asset = 0;
		
		if(direction == PLAY_REVERSE)
			command = NORMAL_REWIND;
		else
			command = NORMAL_FWD;

if(debug) printf("AModule::import_samples %d\n", __LINE__);
		if(!nested_edl || nested_edl->id != edit->nested_edl->id)
		{
			nested_edl = edit->nested_edl;
			if(nested_renderengine)
			{
				delete nested_renderengine;
				nested_renderengine = 0;
			}

			if(!nested_command)
			{
				nested_command = new TransportCommand;
			}


			if(!nested_renderengine)
			{
				nested_command->command = command;
				nested_command->get_edl()->copy_all(nested_edl);
				nested_command->change_type = CHANGE_ALL;
				nested_command->realtime = renderengine->command->realtime;
				nested_renderengine = new RenderEngine(0,
					get_preferences(), 
					0,
					renderengine ? renderengine->channeldb : 0,
					1);
				nested_renderengine->set_acache(get_cache());
// Must use a private cache for the audio
// 				if(!cache) 
// 				{
// 					cache = new CICache(get_preferences());
// 					private_cache = 1;
// 				}
// 				nested_renderengine->set_acache(cache);
				nested_renderengine->arm_command(nested_command);
			}
		}
if(debug) printf("AModule::import_samples %d speed_fragment_len=%d\n", __LINE__, (int)speed_fragment_len);

// Allocate output buffers for all channels
		for(int i = 0; i < nested_edl->session->audio_channels; i++)
		{
			if(nested_allocation < speed_fragment_len)
			{
				delete nested_output[i];
				nested_output[i] = 0;
			}

			if(!nested_output[i])
			{
				nested_output[i] = new Samples(speed_fragment_len);
			}
		}
if(debug) printf("AModule::import_samples %d\n", __LINE__);

		if(nested_allocation < speed_fragment_len)
			nested_allocation = speed_fragment_len;

// Update direction command
		nested_renderengine->command->command = command;

// Render the segment
		if(!nested_renderengine->arender)
		{
			bzero(speed_buffer->get_data(), speed_fragment_len * sizeof(double));
		}
		else
		if(sample_rate != nested_edl->session->sample_rate)
		{
// Read through sample rate converter.
			if(!resample)
			{
				resample = new AModuleResample(this);
			}

if(debug) printf("AModule::import_samples %d %d %d\n", 
__LINE__,
(int)sample_rate,
(int)nested_edl->session->sample_rate);
			result = resample->resample(speed_buffer,
				speed_fragment_len,
				nested_edl->session->sample_rate,
				sample_rate,
				start_source,
				direction);
// Resample reverses to keep it running forward.
if(debug) printf("AModule::import_samples %d\n", __LINE__);
		}
		else
		{
// Render without resampling
if(debug) printf("AModule::import_samples %d\n", __LINE__);
			result = nested_renderengine->arender->process_buffer(
				nested_output, 
				speed_fragment_len,
				start_source);
if(debug) printf("AModule::import_samples %d\n", __LINE__);
			memcpy(speed_buffer->get_data(),
				nested_output[edit->channel]->get_data(),
				speed_fragment_len * sizeof(double));
if(debug) printf("AModule::import_samples %d\n", __LINE__);

// Reverse fragment so ::render can apply transitions going forward.
			if(direction == PLAY_REVERSE)
			{
				Resample::reverse_buffer(speed_buffer->get_data(), speed_fragment_len);
			}
		}

if(debug) printf("AModule::import_samples %d\n", __LINE__);
	}
	else
// Source is an asset
	if(edit->asset)
	{
		nested_edl = 0;
if(debug) printf("AModule::import_samples %d\n", __LINE__);
		asset = edit->asset;

if(debug) printf("AModule::import_samples %d\n", __LINE__);
		get_cache()->age();

if(debug) printf("AModule::import_samples %d\n", __LINE__);
		if(nested_renderengine)
		{
			delete nested_renderengine;
			nested_renderengine = 0;
		}

if(debug) printf("AModule::import_samples %d\n", __LINE__);

		if(!(file = get_cache()->check_out(
			asset,
			get_edl())))
		{
// couldn't open source file / skip the edit
			printf(_("AModule::import_samples Couldn't open %s.\n"), asset->path);
			result = 1;
		}
		else
		{
			result = 0;


			if(sample_rate != asset->sample_rate)
			{
// Read through sample rate converter.
				if(!resample)
				{
					resample = new AModuleResample(this);
				}

if(debug) printf("AModule::import_samples %d %d %d\n", 
__LINE__,
sample_rate,
asset->sample_rate);
				result = resample->resample(speed_buffer,
					speed_fragment_len,
					asset->sample_rate,
					sample_rate,
					start_source,
					direction);
// Resample reverses to keep it running forward.
			}
			else
			{

if(debug)
printf("AModule::import_samples %d channel=%d start_source=%ld len=%d\n", __LINE__, edit->channel, start_source, (int)speed_fragment_len);
				file->set_audio_position(start_source);
				file->set_channel(edit->channel);
				result = file->read_samples(speed_buffer, speed_fragment_len);
// Reverse fragment so ::render can apply transitions going forward.
if(debug) printf("AModule::import_samples %d speed_buffer=%p data=%p speed_fragment_len=%d\n", 
__LINE__, 
(void*)speed_buffer,
(void*)speed_buffer->get_data(), 
(int)speed_fragment_len);
				if(direction == PLAY_REVERSE)
				{
					Resample::reverse_buffer(speed_buffer->get_data(), speed_fragment_len);
				}
if(debug) printf("AModule::import_samples %d\n", __LINE__);
			}

if(debug) printf("AModule::import_samples %d\n", __LINE__);
			get_cache()->check_in(asset);
if(debug) printf("AModule::import_samples %d\n", __LINE__);
			file = 0;





		}
	}
	else
	{
		nested_edl = 0;
		asset = 0;
if(debug) printf("AModule::import_samples %d %p %d\n", __LINE__, speed_buffer->get_data(), (int)speed_fragment_len);
		if(speed_fragment_len > 0) bzero(speed_buffer->get_data(), speed_fragment_len * sizeof(double));
if(debug) printf("AModule::import_samples %d\n", __LINE__);
	}
if(debug) printf("AModule::import_samples %d\n", __LINE__);









// Stretch it to fit the speed curve
// Need overlapping buffers to get the interpolation to work, but this
// screws up sequential effects.
	if(have_speed)
	{
		FloatAuto *previous = 0;
		FloatAuto *next = 0;
		FloatAutos *speed_autos = (FloatAutos*)track->automation->autos[AUTOMATION_SPEED];
		double *buffer_samples = buffer->get_data();
		double *speed_samples = speed_buffer->get_data();

//printf("AModule::import_samples %d %lld\n", __LINE__, speed_fragment_len);

		if(speed_fragment_len == 0)
		{
			bzero(buffer_samples, fragment_len * sizeof(double));
			bzero(prev_tail, SPEED_OVERLAP * sizeof(double));
			bzero(prev_head, SPEED_OVERLAP * sizeof(double));
		}
		else
		{
// buffer is now reversed
			if(direction == PLAY_REVERSE)
			{
				int out_offset = 0;
				speed_position = speed_position2;
	//printf("AModule::import_samples %d %lld %lld\n", __LINE__, start_project, speed_fragment_len);
				for(int64_t i = start_project + fragment_len;
					i != start_project;
					i--)
				{
	// funky sample reordering, because the source is a reversed buffer
					int in_offset = (int64_t)(speed_fragment_len - 1 - speed_position);
					CLAMP(in_offset, 0, speed_fragment_len - 1);
					buffer_samples[out_offset++] = speed_samples[in_offset];
					double speed = speed_autos->get_value(i, 
						PLAY_REVERSE,
						previous,
						next);
					speed_position -= speed;
				}
	//printf("AModule::import_samples %d %f\n", __LINE__, speed_position);
 			}
			else
			{
				int out_offset = 0;
// position in buffer to read
				speed_position = speed_position1 - start_source;

//printf("AModule::import_samples %d %f\n", __LINE__, speed_position);
				for(int64_t i = start_project; i < start_project + fragment_len; i++)
				{
					double speed = speed_autos->get_value(i, 
						PLAY_FORWARD,
						previous,
						next);
					double next_speed_position = speed_position + speed;

					int in_offset = (int)(speed_position);
					if(fabs(speed) >= 1.0)
					{
						int total = abs(speed);
						double accum = 0;
						for(int j = 0; j < total; j++)
						{
							int in_offset2 = in_offset + (speed > 0 ? j : -j);

							CLAMP(in_offset2, 0, speed_fragment_len - 1);
							accum += speed_samples[in_offset2];
						}


						buffer_samples[out_offset++] = accum / total;
					}
					else
					{


// if(in_offset < 0 || in_offset >= speed_fragment_len)
// printf("AModule::import_samples %d %d %d\n", 
// __LINE__, 
// in_offset, 
// speed_fragment_len);

						int in_offset1 = in_offset;
						int in_offset2 = in_offset;

						if(speed < 0)
						{
							in_offset1 += SPEED_OVERLAP;
							in_offset2 = in_offset1 - 1;
						}
						else
						{
							in_offset1 -= SPEED_OVERLAP;
							in_offset2 = in_offset1 + 1;
						}

						CLAMP(in_offset1, -SPEED_OVERLAP, speed_fragment_len - 1 + SPEED_OVERLAP);
						CLAMP(in_offset2, -SPEED_OVERLAP, speed_fragment_len - 1 + SPEED_OVERLAP);
						
						double value1 = 0;
						if(in_offset1 >= speed_fragment_len)
						{
							value1 = prev_head[in_offset1 - speed_fragment_len];
						}
						else
						if(in_offset1 >= 0)
						{ 
							value1 = speed_samples[in_offset1];
						}
						else
						{
//printf("AModule::import_samples %d %d\n", __LINE__, in_offset1);
							value1 = prev_tail[SPEED_OVERLAP + in_offset1];
						}
#if 0
						double value2 = 0;
						if(in_offset2 >= speed_fragment_len)
						{
							value2 = prev_head[in_offset2 - speed_fragment_len];
						}
						else
						if(in_offset2 >= 0)
						{
							value2 = speed_samples()[in_offset2];
						}
						else
						{
							value2 = prev_tail[SPEED_OVERLAP + in_offset2];
						}

						double fraction = speed_position - floor(speed_position);
						buffer_samples[out_offset++] = 
							value1 * (1.0 - fraction) +
							value2 * fraction;
#endif
						buffer_samples[out_offset++] = value1;


					}

					speed_position = next_speed_position;
				}
			}
			
			for(int i = 0; i < SPEED_OVERLAP; i++)
			{
				int offset = speed_fragment_len - 
					SPEED_OVERLAP +
					i;
				CLAMP(offset, 0, speed_fragment_len - 1);
//printf("AModule::import_samples %d %d\n", __LINE__, offset, );
				prev_tail[i] = speed_samples[offset];
				offset = i;
				CLAMP(offset, 0, speed_fragment_len - 1);
				prev_head[i] = speed_samples[offset];
			}
		}
	}
	
	
	
 

	return result;
}
Exemplo n.º 26
0
/*
 * Create an external variant from our internal representation
 */
static Variant
make_variant(VariantInt vi, FunctionCallInfo fcinfo, IOFuncSelector func)
{
    VariantCache	*cache;
    Variant				v;
    bool					oid_overflow=OID_TOO_LARGE(vi->typid);
    long					variant_length, data_length; /* long because we subtract */
    Pointer				data_ptr = 0;
    uint					flags = 0;

    cache = get_cache(fcinfo, vi, func);
    Assert(cache->typid = vi->typid);

#ifdef VARIANT_TEST_OID
    vi->typid += OID_MASK;
    oid_overflow=OID_TOO_LARGE(vi->typid);
#endif

    if(vi->isnull)
    {
        flags |= VAR_ISNULL;
        data_length = 0;
    }
    else if(cache->typlen == -1) /* varlena */
    {
        /*
         * Short varlena is OK, but we need to make sure it's not external. It's OK
         * to leave compressed varlena's alone too, but detoast_packed will
         * uncompress them. We'll just follow rangetype.c's lead here.
         */
        vi->data = PointerGetDatum( PG_DETOAST_DATUM_PACKED(vi->data) );
        data_ptr = DatumGetPointer(vi->data);

        /*
         * Because we don't store varlena aligned or with it's header, our
         * data_length is simply the varlena length.
         */
        data_length = VARSIZE_ANY_EXHDR(vi->data);
        data_ptr = VARDATA_ANY(data_ptr);
    }
    else if(cache->typlen == -2) /* cstring */
    {
        data_length = strlen(DatumGetCString(vi->data)); /* We don't store NUL terminator */
        data_ptr = DatumGetPointer(vi->data);
    }
    else
    {
        Assert(cache->typlen >= 0);
        if(cache->typbyval)
        {
            data_length = VHDRSZ; /* Start with header size to make sure alignment is correct */
            data_length = (long) VDATAPTR_ALIGN(data_length, cache->typalign);
            data_length += cache->typlen;
            data_length -= VHDRSZ;
        }
        else /* fixed length, pass by reference */
        {
            data_length = cache->typlen;
            data_ptr = DatumGetPointer(vi->data);
        }
    }

    /* If typid is too large then we need an extra byte */
    variant_length = VHDRSZ + data_length + (oid_overflow ? sizeof(char) : 0);
    if( variant_length < 0 )
        elog(ERROR, "Negative variant_length %li", variant_length);

    v = palloc0(variant_length);
    SET_VARSIZE(v, variant_length);
    v->pOid = vi->typid;
    v->typmod = vi->typmod;

    if(oid_overflow)
    {
        flags |= VAR_OVERFLOW;

        /* Reset high pOid byte to zero */
        v->pOid &= 0x00FFFFFF;

        /* Store high byte of OID at the end of our structure */
        *((char *) v + VARSIZE(v) - 1) = vi->typid >> 24;
    }

    /*
     * Be careful not to overwrite the valid OID data
     */
    v->pOid |= flags;
    Assert( get_oid(v, &flags) == vi->typid );

    if(!vi->isnull)
    {
        if(cache->typbyval)
        {
            Pointer p = VDATAPTR_ALIGN(v, cache->typalign);
            store_att_byval(p, vi->data, cache->typlen);
        }
        else
            memcpy(VDATAPTR(v), data_ptr, data_length);
    }

    return v;
}
Exemplo n.º 27
0
/*
 * make_variant_int: Converts our external (Variant) representation to a VariantInt.
 */
static VariantInt
make_variant_int(Variant v, FunctionCallInfo fcinfo, IOFuncSelector func)
{
    VariantCache	*cache;
    VariantInt		vi;
    long 					data_length; /* long instead of size_t because we're subtracting */
    Pointer 			ptr;
    uint					flags;


    /* Ensure v is fully detoasted */
    Assert(!VARATT_IS_EXTENDED(v));

    /* May need to be careful about what context this stuff is palloc'd in */
    vi = palloc0(sizeof(VariantDataInt));

    vi->typid = get_oid(v, &flags);

#ifdef VARIANT_TEST_OID
    vi->typid -= OID_MASK;
#endif

    vi->typmod = v->typmod;
    vi->isnull = (flags & VAR_ISNULL ? true : false);

    cache = get_cache(fcinfo, vi, func);

    /*
     * by-value type. We do special things with all pass-by-reference when we
     * store, so we only use this for typbyval even though fetch_att supports
     * pass-by-reference.
     *
     * Note that fetch_att sanity-checks typlen for us (because we're only passing typbyval).
     */
    if(cache->typbyval)
    {
        if(!vi->isnull)
        {
            Pointer p = VDATAPTR_ALIGN(v, cache->typalign);
            vi->data = fetch_att(p, cache->typbyval, cache->typlen);
        }
        return vi;
    }

    /* we don't store a varlena header for varlena data; instead we compute
     * it's size based on ours:
     *
     * Our size - our header size - overflow byte (if present)
     *
     * For cstring, we don't store the trailing NUL
     */
    data_length = VARSIZE(v) - VHDRSZ - (flags & VAR_OVERFLOW ? 1 : 0);
    if( data_length < 0 )
        elog(ERROR, "Negative data_length %li", data_length);

    if (cache->typlen == -1) /* varlena */
    {
        ptr = palloc0(data_length + VARHDRSZ);
        SET_VARSIZE(ptr, data_length + VARHDRSZ);
        memcpy(VARDATA(ptr), VDATAPTR(v), data_length);
    }
    else if(cache->typlen == -2) /* cstring */
    {
        ptr = palloc(data_length + 1); /* Need space for NUL terminator */
        memcpy(ptr, VDATAPTR(v), data_length);
        *(ptr + data_length + 1) = '\0';
    }
    else /* Fixed size, pass by reference */
    {
        if(vi->isnull)
        {
            vi->data = (Datum) 0;
            return vi;
        }

        Assert(data_length == cache->typlen);
        ptr = palloc0(data_length);
        Assert(ptr == (char *) att_align_nominal(ptr, cache->typalign));
        memcpy(ptr, VDATAPTR(v), data_length);
    }
    vi->data = PointerGetDatum(ptr);

    return vi;
}
Exemplo n.º 28
0
void component_synchronizer<false, F>::rebuild_density(const size_t index) const {
	for (auto f : get_cache().fixtures_per_collider[index])
		f->SetDensity(component.colliders[index].density * component.colliders[index].density_multiplier);

	get_cache().fixtures_per_collider[0][0]->GetBody()->ResetMassData();
}
Exemplo n.º 29
0
static int bee_dep_list(int argc, char *argv[])
{
    int c, i, opt_count, help, files, packages, count,
        depending_on, required_by, removable, provider_of,
        not_cached, broken;
    struct hash *graph;
    char *name;
    struct option long_options[] = {
        {"help",         0, &help,         1},
        {"files",        0, &files,        1},
        {"packages",     0, &packages,     1},
        {"count",        0, &count,        1},
        {"depending-on", 0, &depending_on, 1},
        {"required-by",  0, &required_by,  1},
        {"removable",    0, &removable,    1},
        {"provider-of",  0, &provider_of,  1},
        {"not-cached",   0, &not_cached,   1},
        {"broken",       0, &broken,       1},
        {0, 0, 0, 0}
    };

    opt_count = help         = files       = packages  = provider_of =
    count     = depending_on = required_by = removable = not_cached  =
    broken    = 0;

    while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
        switch (c) {
            case '?':
                usage_list();
                return 1;

            default:
                opt_count++;
        }
    }

    if (help) {
        usage_list();
        return 0;
    }

    if (!opt_count && optind != argc) {
        fprintf(stderr, "bee-dep: too many arguments\n");
        return 1;
    }

    if (!opt_count)
        packages = 1;

    if (opt_count > 1 && !count) {
        fprintf(stderr, "bee-dep: too many options specified\n");
        return 1;
    }

    if (packages) {
        graph = get_cache();

        if (count)
            printf("%d\n", count_packages(graph));
        else
            list_packages(graph);

        hash_free(graph);
        return 0;
    }

    if (broken && optind < argc) {
        fprintf(stderr, "bee-dep: too many arguments\n");
        return 1;
    }

    if (optind == argc && !broken) {
        fprintf(stderr, "bee-dep: arguments needed\n");
        return 1;
    }

    if (count && (depending_on || required_by))
        fprintf(stderr, "bee-dep: ignoring option --count\n");

    graph = get_cache();

    for (i = optind; i < argc; i++) {
        name = argv[i];

        if (optind < argc - 1)
            printf("%s:\n", name);

        if (files) {
            if (count) {
                c = count_files(graph, name);

                if (c < 0) {
                    hash_free(graph);
                    return 1;
                }

                printf("%d\n", c);
            } else if (list_files(graph, name)) {
                 hash_free(graph);
                 return 1;
            }
        }

        if (removable) {
            if (count) {
                c = count_removable(graph, name);

                if (c < 0) {
                    hash_free(graph);
                    return 1;
                }

                printf("%d\n", c);
            } else if (print_removable(graph, name)) {
                hash_free(graph);
                return 1;
            }
        }

        if (depending_on && print_neededby(graph, name)) {
            hash_free(graph);
            return 1;
        }

        if (required_by && print_needs(graph, name)) {
            hash_free(graph);
            return 1;
        }

        if (provider_of) {
            if (count) {
                c = count_providers(graph, name);

                if (c < 0) {
                    hash_free(graph);
                    return 1;
                }

                printf("%d\n", c);
            } else if (print_providers(graph, name)) {
                hash_free(graph);
                return 1;
            }
        }

        if (not_cached) {
            c = print_not_cached(graph, name, !count);

            if (c < 0) {
                hash_free(graph);
                return 1;
            }

            if (count)
                printf("%d\n", c);
        }
    }

    if (broken) {
        c = print_broken(graph, !count);

        if (c < 0) {
            hash_free(graph);
            return 1;
        }

        if (count)
            printf("%d\n", c);
    }

    hash_free(graph);
    return 0;
}
Exemplo n.º 30
0
static int bee_dep_update(int argc, char *argv[])
{
    int c, help;
    char *pkg;
    char path[PATH_MAX + 1];
    struct hash *graph;
    struct stat st;
    struct option long_options[] = {
        {"help", 0, &help, 1},
        {0, 0, 0, 0}
    };

    help = 0;

    while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
        switch (c) {
            case '?':
                usage_update();
                return 1;
        }
    }

    if (help) {
        usage_update();
        return 0;
    }

    if (argc == 1) {
        graph = get_cache();

        if (update_cache(graph) || save_cache(graph, cache_filename())) {
            hash_free(graph);
            return 1;
        }

        hash_free(graph);
        return 0;
    }

    if (argc < 2) {
        fprintf(stderr, "bee-dep: pkgname needed\n");
        return 1;
    }

    if (argc > 2) {
        fprintf(stderr, "bee-dep: too many arguments\n");
        return 1;
    }

    pkg = argv[1];

    if (sprintf(path, "%s/%s/DEPENDENCIES", bee_metadir(), pkg) < 0) {
        perror("bee-dep: sprintf");
        return 1;
    }

    graph = get_cache();

    if (stat(path, &st) != -1) {
        if (hash_search(graph, pkg)) {
            hash_free(graph);
            return 0;
        }

        if (graph_insert_nodes(graph, path)) {
            hash_free(graph);
            return 1;
        }
    } else {
        if (remove_package(graph, pkg)) {
            hash_free(graph);
            return 1;
        }
    }

    if (save_cache(graph, cache_filename())) {
        hash_free(graph);
        return 1;
    }

    hash_free(graph);
    return 0;
}