Beispiel #1
0
void xref(const char *name, FILE *fp,
		Table_T identifiers){
	char buf[128];
	if (name == NULL)
		name = "";
	name = Atom_string(name);
	linenum = 1;
	while (getword(fp, buf, sizeof buf, first, rest)) {
		Set_T set;
		Table_T files;
		const char *id = Atom_string(buf);
		files = Table_get(identifiers, id);
		if (files == NULL) {
			files = Table_new(0, NULL, NULL);
			Table_put(identifiers, id, files);
		}
		set = Table_get(files, name);
		if (set == NULL) {
			set = Set_new(0, intcmp, inthash);
			Table_put(files, name, set);
		}
		{
			int *p = &linenum;
			if (!Set_member(set, p)) {
				NEW(p);
				*p = linenum;
				Set_put(set, p);
			}
		}
	}
}
Beispiel #2
0
void cref(char *name, FILE *fp, Table_T identifiers) {
	char buf[512];
	Text_T filename = { 0, "" };
	int linenum;

	if (name)
		filename = Text_put(name);
	for (linenum = 1; fgets(buf, sizeof buf, fp) != NULL; linenum++) {
		Text_T id, line = Text_put(buf);
		while ((id = getword(&line, first, rest)).len > 0) {
			Ring_T ring;
			Table_T files;
			files = Table_get(identifiers, &id);
			if (files == NULL) {
				files = Table_new(0, textcmp, texthash);
				Table_put(identifiers, copy(id), files);
			}
			ring = Table_get(files, &filename);
			if (ring == NULL) {
				ring = Ring_new();
				Table_put(files, copy(filename), ring);
				Ring_addlo(ring, Integer_new(linenum));
			} else if (Integer_get(Ring_get(ring, 0)) != linenum)
				Ring_addlo(ring, Integer_new(linenum));
		}
	}
}
Beispiel #3
0
void kref(char *name, FILE *fp, Table_T identifiers) {
	char buf[512], *filename = "";
	int linenum;

	if (name)
		filename = name;
	for (linenum = 1; fgets(buf, sizeof buf, fp) != NULL; linenum++) {
		int i, j;
		for (i = 0; (j = getword(buf, &i, first, rest)) > 0; i = j) {
			char *id = Str_sub(buf, j, i);
			const char *ln = Atom_int(linenum);
			Seq_T seq;
			Table_T files;
			files = Table_get(identifiers, id);
			if (files == NULL) {
				files = Table_new(0,
					(int (*)(const void *, const void *))strcmp, strhash);
				Table_put(identifiers, id, files);
			} else
				FREE(id);
			seq = Table_get(files, filename);
			if (seq == NULL) {
				seq = Seq_new(0);
				Table_put(files, Str_dup(filename, 1, 0, 1), seq);
				Seq_addlo(seq, (void *)ln);
			} else if (Seq_get(seq, 0) != ln)
				Seq_addlo(seq, (void *)ln);
		}
	}
}
Beispiel #4
0
/* x is really a char ** */
static int
bysegmentpos_compare_alpha (const void *x, const void *y) {
  char *acc1 = * (char **) x;
  char *acc2 = * (char **) y;
  Segmentpos_T a = (Segmentpos_T) Table_get(current_accsegmentpos_table,(void *) acc1);
  Segmentpos_T b = (Segmentpos_T) Table_get(current_accsegmentpos_table,(void *) acc2);

  return Segmentpos_compare_alpha(&a,&b);
}
Beispiel #5
0
void wf(char *name, FILE *fp) {
	Table_T table = Table_new(0, NULL, NULL);
	char buf[128];
	while (getword(fp, buf, sizeof buf, first, rest)) {
		const char *word;
		int i, *count;
		for (i = 0; buf[i] != '\0'; i++)
			buf[i] = tolower(buf[i]);
		word = Atom_string(buf);
		count = Table_get(table, word);
		if (count)
			(*count)++;
		else {
			NEW(count);
			*count = 1;
			Table_put(table, word, count);
		}
	}
	if (name)
		printf("%s:\n", name);
	{ int i;
	  void **array = Table_toArray(table, NULL);
	  qsort(array, Table_length(table), 2*sizeof (*array),
	  	compare);
	  for (i = 0; array[i]; i += 2)
	  	printf("%d\t%s\n", *(int *)array[i+1],
	  		(char *)array[i]);
	  FREE(array); }
	Table_map(table, vfree, NULL);
	Table_free(&table);
}
Beispiel #6
0
int exponent_table_get(exponent_table *E, const exponent expon)
     /* Returns the value associated to 'expon', returning zero, if 'expon'
        is not in the table */
{
  table_nvars = E->nvars;
  return (int) Table_get(E->table,expon);
}
Beispiel #7
0
static int
bysegmentpos_compare (const void *x, const void *y) {
  char *acc1 = * (char **) x;
  char *acc2 = * (char **) y;
  Segmentpos_T a = (Segmentpos_T) Table_get(current_accsegmentpos_table,(void *) acc1);
  Segmentpos_T b = (Segmentpos_T) Table_get(current_accsegmentpos_table,(void *) acc2);

  if (divsort == ALPHA_SORT) {
    return Segmentpos_compare_alpha(&a,&b);
  } else if (divsort == NUMERIC_ALPHA_SORT) {
    return Segmentpos_compare_numeric_alpha(&a,&b);
  } else if (divsort == CHROM_SORT) {
    return Segmentpos_compare_chrom(&a,&b);
  } else {
    abort();
  }
}
Beispiel #8
0
// for each fld in item, get the list from items and test each member in items against item
static void _process(Table_T items, item_ *item) {
    for (int i = 0; item->object[i]; i++) {
        const oe_scalar key = item->object[i];
        Set_T s = (Set_T) Table_get(items, key);
        if (!s) continue;
        bool done = _processSet( items, s, item, i );
        if (done) break;
    }
}
Beispiel #9
0
static void cApply(void** x, void* cl) {
    Position* p = (Position*) *x;
    struct applyStruct* e = (struct applyStruct*) cl;
    double vol = e->vol;

    if(e->volTable)
        vol = * (double*) Table_get(e->volTable, p->Contract);

    e->total += Contract_Price(p->Contract, e->evalTime, e->price, e->riskFree, vol) * p->Quantity;
}
Beispiel #10
0
END_TEST


START_TEST(test_get)
{
    /* Table_get() with non-existant key returns NULL */

    Table_T *table = Table_new(0, cmpatom, hashatom);

    Table_put(table, (void*)0x12, (void*)0x34);

    fail_unless( Table_length(table) == 1 );
    fail_unless( Table_get(table, (void*)0x12) == (void*)0x34);

    /* non-existant key */
    fail_unless( Table_get(table, (void*)0x34) == NULL);

    Table_remove(table, (void*)0x12);
    Table_free(&table);
}
Beispiel #11
0
static int ssl_ctx_callback_impl(void* pvCurl, void* ctx, void* pvThis)
{
    // locate the delegates
    FARPROC fpSslCtxDel;
    unsigned int* pnDelegates =
        (unsigned int*)Table_get(g_delegateTable, pvThis);

    if (!pnDelegates)
        return 0; 
    fpSslCtxDel = (FARPROC)pnDelegates[5];
    return fpSslCtxDel(ctx, pvThis);
}
Beispiel #12
0
void addToTableHelp( Table_T fpTable, fpPair pair )
{
        List_T names = NULL;
        const char * fpAtom = Atom_string(pair.fp);

        // if the key does exist in the table 
        // get the list already stored 
        if( Table_get( fpTable, fpAtom ) != NULL )
        {       
                names = Table_get( fpTable, fpAtom );
        }

        // pushes the the list 
        names = List_push( names, pair.name);
        Table_put( fpTable, fpAtom, names );

        free(pair.fp);

        // List_map( names , applyFree, NULL );

}
Beispiel #13
0
static int ioctl_callback_impl(void* pvCurl, int cmd, void* pvThis)
{
    // locate the delegates
    FARPROC fpIoctlDel;
    unsigned int* pnDelegates =
        (unsigned int*)Table_get(g_delegateTable, pvThis);

    if (!pnDelegates)
        return 0;
    fpIoctlDel = (FARPROC)pnDelegates[6];
    return fpIoctlDel(cmd, pvThis);
}
Beispiel #14
0
void xref(const char *name, FILE *fp, Table_T identifiers){
	char buf[128];
	
	if (name == NULL){
		name = "";
	}
	name = Atom_string(name);
	linenum = 1;
	while (getword(fp, buf, sizeof(buf), first, rest)){
		Set_T set;
		Table_T files;
		const char *id = Atom_string(buf);
		
		// files <- file table in identifiers associated with id 
		files = Table_get(identifiers, id);
		if (files == NULL){
			files = Table_new(0, NULL, NULL);
			Table_put(identifiers, id, files);
		}
		
		
		// set <- set in files associated with name 
		set = Table_get(files, name);
		if (set == NULL){
			set = Set_new(0, intcmp, inthash);
			Table_put(files, name, set);
		}
		
		
		// add linenum to set, if necessary 
		{
			int *p = &linenum;
			if (!Set_member(set, p)){
				NEW(p);
				*p = linenum;
				Set_put(set, p);
			}
		}
	}
}
Beispiel #15
0
static int debug_callback_impl(void* pvCurl, int infoType,
    char* szMsg, size_t msgSize, void* pvThis)
{
    // locate the delegates
    FARPROC fpDebugDel;
    unsigned int* pnDelegates =
        (unsigned int*)Table_get(g_delegateTable, pvThis);

    if (!pnDelegates)
        return 0; 
    fpDebugDel = (FARPROC)pnDelegates[3];
    return fpDebugDel(infoType, szMsg, msgSize, pvThis);
}
Beispiel #16
0
static int progress_callback_impl(void* pvThis, double dlTotal,
    double dlNow, double ulTotal, double ulNow)
{
    // locate the delegates
    FARPROC fpProgDel;
    unsigned int* pnDelegates =
        (unsigned int*)Table_get(g_delegateTable, pvThis);

    if (!pnDelegates)
        return 0; 
    fpProgDel = (FARPROC)pnDelegates[2];
    return fpProgDel(pvThis, dlTotal, dlNow, ulTotal, ulNow);
}
Beispiel #17
0
static size_t header_callback_impl(char* szptr, size_t sz,
    size_t nmemb, void* pvThis)
{
    // locate the delegates
    FARPROC fpHeaderDel;
    unsigned int* pnDelegates =
        (unsigned int*)Table_get(g_delegateTable, pvThis);

    if (!pnDelegates)
        return 0; 
    fpHeaderDel = (FARPROC)pnDelegates[4];
    return fpHeaderDel(szptr, sz, nmemb, pvThis);
}
Beispiel #18
0
END_TEST


START_TEST(test_put_in_same_bucket)
{
    /* Our hash function always places key/vals in the same bucket -
     * assert that multiple items can be placed and retreived from
     * the same bucket */

    Table_T *table = Table_new(0, cmpatom, hashatom);

    Table_put(table, (void*)0x12, (void*)0x34);
    Table_put(table, (void*)0x56, (void*)0x78);

    fail_unless( Table_length(table) == 2 );
    fail_unless( Table_get(table, (void*)0x12) == (void*)0x34);
    fail_unless( Table_get(table, (void*)0x56) == (void*)0x78);

    Table_remove(table, (void*)0x12);
    Table_remove(table, (void*)0x56);
    Table_free(&table);
}
Beispiel #19
0
static void unlock_callback_impl(void* pvHandle, int data,
    void* pvThis)
{
    // locate the delegates
    FARPROC fpUnlockDel;
    unsigned int* pnDelegates =
        (unsigned int*)Table_get(g_shareDelegateTable, pvThis);

    if (pnDelegates)
    {
        fpUnlockDel = (FARPROC)pnDelegates[1];
        fpUnlockDel(data, pvThis);
    }
}
Beispiel #20
0
Datei: stab.c Projekt: bhanug/cdb
/* stabfend - called at end end of compiling a function */
static void stabfend(Symbol cfunc, int lineno) {
	int count = Seq_length(locals);

	for ( ; count > 0; count--) {
		Symbol p = Seq_remlo(locals);
		sym_symbol_ty sym = Table_get(uidTable, p);
		p->x.offset -= tos->x.offset;
		assert(sym);
		switch (sym->kind) {
		case sym_LOCAL_enum: sym->v.sym_LOCAL.offset = p->x.offset; break;
		case sym_PARAM_enum: sym->v.sym_PARAM.offset = p->x.offset; break;
		default: assert(0);
		}
	}
	tos = NULL;
}
Beispiel #21
0
unsigned test_table() {

    Table_T tbl = Table_new(10, NULL, NULL);
    struct Test t1 = { 10, "Luca"};
    char* s1 = TestToStr(&t1);
    const char* a1 = Atom_string(s1);
    char * result;

    Table_put(tbl, a1, "Luca");
    result = (char*) Table_get(tbl, a1);
    test_assert(strcmp(result, "Luca") == 0);

    Table_free(&tbl);
    FREE(s1);
    Atom_freeAll();
    return TEST_SUCCESS;
}
Beispiel #22
0
Datei: stab.c Projekt: bhanug/cdb
/* symboluid - returns sym's uid, adding the symbol, if necessary */
static int symboluid(const Symbol p) {
	int uid;
	sym_symbol_ty sym;

	if (p == NULL)
		return 0;
	sym = Table_get(uidTable, p);
	if (sym != NULL)
		return sym->uid;
	uid = pickle->nuids++;
	switch (p->sclass) {
	case ENUM:
		sym = sym_ENUMCONST(p->name, uid, uname, NULL, 0, 0,
			p->u.value);
		sym->type = typeuid(inttype);
		break;
	case TYPEDEF:
		sym = sym_TYPEDEF(p->name, uid, uname, NULL, 0, 0);
		sym->type = typeuid(p->type);
		break;
	default:
		if (p->sclass == STATIC) {
			sym = sym_STATIC(p->name, uid, uname, NULL, 0, 0,
					 Seq_length(statics));
			Seq_addhi(statics, p);
		} else if (p->scope == GLOBAL || p->sclass == EXTERN) {
			sym = sym_GLOBAL(p->name, uid, uname, NULL, 0, 0,
					 Seq_length(statics));
			Seq_addhi(statics, p);
		} else if (p->scope == PARAM)
			sym = sym_PARAM(p->name, uid, uname, NULL, 0, 0,
				p->x.offset);
		else {
			assert(p->scope >= LOCAL);
			sym = sym_LOCAL(p->name, uid, uname, NULL, 0, 0,
				p->x.offset);
		}
		sym->type = typeuid(p->type);
	}
	Table_put(uidTable, p, sym);
	Seq_addhi(pickle->items, sym_Symbol(uid, sym));
	sym->src = sym_coordinate(p->src.file ? p->src.file : string(""), p->src.x, p->src.y);
	sym->uplink = symboluid(up(p->up));
	return sym->uid;
}
Beispiel #23
0
END_TEST


START_TEST(test_put_replace)
{
    /* New values replace old values with the same key. */

    Table_T *table = Table_new(0, cmpatom, hashatom);

    Table_put(table, (void*)0x12, (void*)0x34);
    Table_put(table, (void*)0x12, (void*)0x56);

    fail_unless( Table_length(table) == 1 );
    fail_unless( Table_get(table, (void*)0x12) == (void*)0x56);

    Table_remove(table, (void*)0x12);
    Table_free(&table);
}
Beispiel #24
0
/*Inserts the value into the table under the corresponding fingerprint*/
void insert_atom(Table_T* table, char* fingerprint, char* name)
{
        const char *key;
        const char *value;
        Set_T old_set;          

        /*Turns fingerprint and name strings into Hanson atoms*/
        key = Atom_string(fingerprint);
        value = Atom_string(name);

        old_set = Table_get(*table, key);
        if (old_set == NULL) {
                Set_T new_set = Set_new(1, NULL, NULL);
                Set_put(new_set, value);
                Table_put(*table, key, new_set);
        } else {
                Set_put(old_set, value);
        }
}
Beispiel #25
0
//calculate the most unique fld in item against the map of lists of templates
//put the tuple in that list associated with the most unique key
static int _add_template(T _this_, item_ *item) {

    Table_T items = _this_->items;

    //calc most unique key
    oe_scalar key = NULL;
    int key_idx = 0;
    int set_size = 0;
    Set_T curset = NULL;
    for ( int i = 0; item->object[i]; i++ ) {
        oe_scalar tmpkey = item->object[i];
        if (strcmp("_", tmpkey) == 0) continue; //don't index by wildcard

        Set_T s = (Set_T) Table_get( items, tmpkey );
        if (s) {
            int size = Set_length( s );
            if ( !key || size < set_size ) {
                key = tmpkey;
                key_idx = i;
                set_size = size;
                curset = s;
            }
        } else { //found an unused key
            key = tmpkey;
            key_idx = i;
            set_size = 0;
            curset = Set_new( 10, _itemcmp, _itemhash );
            Table_put( items, key, curset );
            break;
        }
    }
    if (!curset) {
        OE_ERR(0, "Dispatcher can not add template, make sure it is not all '_' fields\n"); //i18n
        return -1;
    }
    item->items = curset;
    item->key_idx = key_idx; //for self remove of empty sets
    Set_put( curset, item );
    return 0;
}
Beispiel #26
0
terminal *terminalTable(Table_T termtable, subBoard state)
{
  int player;
  int i;
  int w;
  int *canon = canonBoard(state);
  terminal *terms;

  if ((terms = Table_get(termtable, canon)) != 0) {
    free(canon);
    return terms;
  }

  terms = (terminal *) calloc(1, sizeof(terminal));

  if ((w = win(state)) != 0) {
    terms->max = (w == 1) ? 1 : 0;
    terms->min = (w == -1) ? 1 : 0;
  } else if (countOpen(state) == 0) {
    terms->max = 0;
    terms->min = 0;
  } else {
    int childState[9];
    memcpy(childState, state, 9*sizeof(int));

    for (i = 0; i < 9; ++i) {
      if (childState[i] == 0) {
	for (player = 0; player < 2; ++player) {
	  childState[i] = (2*player) - 1;
	  terminal *childterm = terminalTable(termtable, childState);
	  terms->max += childterm->max;
	  terms->min += childterm->min;
	}
	childState[i] = 0;
      }
    }
  }
  Table_put(termtable, canon, terms);
  return terms;
} 
Beispiel #27
0
void store_name(char* fprint_buffer, char* name_buf, T* table, L* name_list)
{
    const char* fprint = Atom_string(fprint_buffer);
    const char* name = Atom_string(name_buf);

    char **name_arr = (char**) List_toArray(*name_list, NULL);
    for(int z = 0; name_arr[z]; z++) {
        if(name_arr[z] == name) {
            fprintf(stderr, "Duplicate name detected: Ignoring input\n");
            free (name_arr);
            return;
        }
    }
    free(name_arr);
    *name_list = List_push(*name_list, (void*) name);
    L list = (L) Table_get(*table, fprint);
    if (list == NULL) {
        list = List_list((char*) name, NULL);
    } else {
        list = List_push(list, (void*) name);

    }
    Table_put(*table, fprint, list);
}
Beispiel #28
0
static void
write_contig_file (char *genomesubdir, char *fileroot, Table_T accsegmentpos_table, 
		   Tableint_T chrlength_table, List_T contigtypelist) {
  FILE *textfp;
  char *textfile, *iitfile, *annot;
  int naccessions, i;
  char **accessions, *divstring;
  Segmentpos_T segmentpos;
  Chrom_T chrom;
  Genomicpos_T chroffset, universalpos1, universalpos2;
  List_T divlist = NULL, intervallist = NULL, labellist = NULL, annotlist = NULL, p;
  Table_T intervaltable, labeltable, annottable;
  Interval_T interval;
#if 0
  void **keys;
  int *values, ntypes;
#endif
  
  if (divsort == NO_SORT) {
    accessions = (char **) Table_keys_by_timeindex(accsegmentpos_table,NULL);
    naccessions = Table_length(accsegmentpos_table);
  } else {
    /* Get accessions in order */
    accessions = (char **) Table_keys(accsegmentpos_table,NULL);
    naccessions = Table_length(accsegmentpos_table);
    current_accsegmentpos_table = accsegmentpos_table;
    qsort(accessions,naccessions,sizeof(char *),bysegmentpos_compare);
  }

#if 0
  /* Get types in order */
  keys = Tableint_keys(contigtype_table,NULL);
  values = Tableint_values(contigtype_table,0);
  ntypes = Tableint_length(contigtype_table);
  contigtypes = (char **) CALLOC(ntypes+1,sizeof(char *)); /* Add 1 for type 0 */
  contigtypes[0] = "";
  for (j = 0; j < ntypes; j++) {
    contigtypes[values[j]] = keys[j];
  }
  FREE(values);
  FREE(keys);
#endif

  /* Write contig text file */
  textfile = (char *) CALLOC(strlen(genomesubdir)+strlen("/")+
			     strlen(fileroot)+strlen(".contig")+1,sizeof(char));
  sprintf(textfile,"%s/%s.contig",genomesubdir,fileroot);
  /* Use binary, not text, so files are Unix-compatible */
  if ((textfp = FOPEN_WRITE_BINARY(textfile)) == NULL) {
    fprintf(stderr,"Can't write to file %s\n",textfile);
    exit(9);
  }
  FREE(textfile);

  for (i = 0; i < naccessions; i++) {
    segmentpos = (Segmentpos_T) Table_get(accsegmentpos_table,(void *) accessions[i]);
    chrom = Segmentpos_chrom(segmentpos);
    chroffset = (Genomicpos_T) Tableint_get(chrlength_table,chrom);
    universalpos1 = chroffset + Segmentpos_chrpos1(segmentpos);
    universalpos2 = chroffset + Segmentpos_chrpos2(segmentpos);

    /* Print as 1-based, inclusive [a,b] */
    if (Segmentpos_revcompp(segmentpos) == true) {
      fprintf(textfp,"%s\t%u..%u\t%s:%u..%u\t%u",
	      accessions[i],universalpos2+1U,universalpos1,
	      Chrom_string(chrom),Segmentpos_chrpos2(segmentpos)+1U,Segmentpos_chrpos1(segmentpos),
	      Segmentpos_length(segmentpos));
    } else {
      fprintf(textfp,"%s\t%u..%u\t%s:%u..%u\t%u",
	      accessions[i],universalpos1+1U,universalpos2,
	      Chrom_string(chrom),Segmentpos_chrpos1(segmentpos)+1U,Segmentpos_chrpos2(segmentpos),
	      Segmentpos_length(segmentpos));
    }
#if 0
    if (Segmentpos_type(segmentpos) > 0) {
      fprintf(textfp,"\t%s",contigtypes[Segmentpos_type(segmentpos)]);
    }
#endif

    fprintf(textfp,"\n");

    /* Store as 0-based, inclusive [a,b] */
    labellist = List_push(labellist,(void *) accessions[i]);
    if (Segmentpos_revcompp(segmentpos) == true) {
      /* The negative sign in the interval is the indication that the
	 contig was reverse complement */
      intervallist = List_push(intervallist, 
			       (void *) Interval_new(universalpos2-1U,universalpos1,
						     Segmentpos_type(segmentpos)));
    } else {
      intervallist = List_push(intervallist, 
			       (void *) Interval_new(universalpos1,universalpos2-1U,
						     Segmentpos_type(segmentpos)));
    }

#if 0
    /* IIT version 1 */
    sprintf(seglength,"%u",Segmentpos_length(segmentpos));
    annot = (char *) CALLOC(strlen(seglength)+1,sizeof(char));
    strcpy(annot,seglength);
#else
    /* IIT versions >= 2 */
    annot = (char *) CALLOC(1,sizeof(char));
    annot[0] = '\0';
#endif
    annotlist = List_push(annotlist,(void *) annot);

  }
  fclose(textfp);

#if 0
  FREE(contigtypes);
#endif
  FREE(accessions);
  intervallist = List_reverse(intervallist);
  /* contigtypelist = List_reverse(contigtypelist); -- Done by caller */ 
  labellist = List_reverse(labellist);
  annotlist = List_reverse(annotlist);

  /* Write contig IIT file */
  divstring = (char *) CALLOC(1,sizeof(char));
  divstring[0] = '\0';
  divlist = List_push(NULL,divstring);

  intervaltable = Table_new(65522,Table_string_compare,Table_string_hash);
  labeltable = Table_new(65522,Table_string_compare,Table_string_hash);
  annottable = Table_new(65522,Table_string_compare,Table_string_hash);

  Table_put(intervaltable,(void *) divstring,intervallist);
  Table_put(labeltable,(void *) divstring,labellist);
  Table_put(annottable,(void *) divstring,annotlist);

  iitfile = (char *) CALLOC(strlen(genomesubdir)+strlen("/")+
			    strlen(fileroot)+strlen(".contig.iit")+1,sizeof(char));
  sprintf(iitfile,"%s/%s.contig.iit",genomesubdir,fileroot);

#if 0
  debug(
	for (p = contigtypelist; p != NULL; p = List_next(p)) {
	  printf("Type %s\n",(char *) List_head(p));
	}
	);
Beispiel #29
0
/*
* Returns the internal sparse matrix from global table, or NULL if
* not found.
*
*/
SPBLASI_Matrix* SPBLASI_table_get(int i)
{
	return (SPBLASI_Matrix *) Table_get(SPBLASI_Table, i);
}