static trans_node * make_trans_node( const char * chromosome, const char * translation ) { trans_node * res = calloc( 1, sizeof * res ); if ( res != NULL ) { StringInitCString( &(res->chromosome), chromosome ); StringInitCString( &(res->translation), translation ); } return res; }
LIB_EXPORT rc_t CC KCurlRequestAddField( struct KCurlRequest *self, const char * name, const char * value ) { String s_name, s_value; if ( self == NULL ) return RC( rcNS, rcFile, rcReading, rcSelf, rcNull ); if ( name == NULL || name[ 0 ] == 0 || value == NULL || value[ 0 ] == 0 ) return RC( rcNS, rcFile, rcReading, rcParam, rcNull ); StringInitCString( &s_name, name ); StringInitCString( &s_value, value ); return KCurlRequestAddSField( self, &s_name, &s_value ); }
/* Make * make an initialized structure * NB - does NOT attach reference to dir, but steals it */ static rc_t KDatabaseMake ( KDatabase **dbp, const KDirectory *dir, const char *path, KMD5SumFmt *md5, bool read_only ) { KDatabase *db; rc_t rc = 0; assert ( dbp != NULL ); assert ( path != NULL ); db = malloc ( sizeof * db + strlen ( path ) ); if ( db == NULL ) { * dbp = NULL; return RC ( rcDB, rcDatabase, rcConstructing, rcMemory, rcExhausted ); } memset ( db, 0, sizeof * db ); db -> dir = ( KDirectory* ) dir; db -> md5 = md5; rc = KMD5SumFmtAddRef ( md5 ); db -> use_md5 = ( md5 == NULL ) ? false : true; KRefcountInit ( & db -> refcount, 1, "KDatabase", "make", path ); db -> opencount = 1; db -> read_only = read_only; strcpy ( db -> path, path ); db->sym.u.obj = db; StringInitCString (&db->sym.name, db->path); db->sym.type = kptDatabase; * dbp = db; return rc; }
static rc_t KDyldVTryLoadLib ( KDyld *self, KDylib **lib, const KDirectory *dir, const char *path, va_list args ) { rc_t rc; const KSysDir *sdir = KDirectoryGetSysDir ( dir ); if ( sdir == NULL ) rc = RC ( rcFS, rcDylib, rcLoading, rcDirectory, rcIncorrect ); else { char real [ PATH_MAX ]; rc = KSysDirVRealPath ( sdir, real, sizeof real, path, args ); if ( rc == 0 ) { String pstr; StringInitCString ( & pstr, real ); rc = KDylibMake ( lib, & pstr ); if ( rc == 0 ) { rc = KDyldLoad ( self, * lib, real ); if ( rc == 0 ) return 0; free ( * lib ); } } } * lib = NULL; return rc; }
/* Make */ static rc_t KSymAddrMake ( KSymAddr **symp, const KDylib *lib, const char *name ) { void *addr = dlsym ( lib -> handle, name ); const char *estr = dlerror(); if ( addr == NULL && builtins != NULL ) { String builtin_name; KSymbol *builtin_sym; StringInitCString ( & builtin_name, name ); builtin_sym = KSymTableFind ( builtins, & builtin_name ); if ( builtin_sym != NULL ) { addr = builtin_sym -> u . obj; } } if ( addr != NULL || estr == NULL ) { KSymAddr *sym = malloc ( sizeof * sym ); if ( sym == NULL ) return RC ( rcFS, rcDylib, rcConstructing, rcMemory, rcExhausted ); sym -> lib = KDylibAttach ( lib ); sym -> addr = addr; KRefcountInit ( & sym -> refcount, 1, "KSymAddr", "make", name ); * symp = sym; return 0; } * symp = NULL; return RC ( rcFS, rcDylib, rcSelecting, rcName, rcNotFound ); }
static rc_t build_full_url( char ** s ) { rc_t rc; String prefix, accession; const String * full_url; StringInitCString( &prefix, ENTREZ_URL ); StringInitCString( &accession, *s ); rc = StringConcat ( &full_url, &prefix, &accession ); if ( rc == 0 ) { free( *s ); *s = string_dup_measure ( full_url->addr, NULL ); StringWhack ( full_url ); } return rc; }
LIB_EXPORT rc_t CC KCurlRequestAddFields( struct KCurlRequest *self, const char * fields ) { String s; if ( self == NULL ) return RC( rcNS, rcFile, rcReading, rcSelf, rcNull ); if ( fields == NULL || fields[ 0 ] == 0 ) return RC( rcNS, rcFile, rcReading, rcParam, rcNull ); StringInitCString( &s, fields ); return KCurlRequestAddSFields( self, &s ); }
rc_t get_slice( const Args * args, const char *option, slice ** slice ) { const char * value; rc_t rc = get_charptr( args, option, &value ); if ( rc == 0 && value != NULL ) { String S; StringInitCString( &S, value ); *slice = make_slice_from_str( &S ); } else *slice = NULL; return rc; }
rc_t make_column_typelist ( const BSTree *columns, const char *col, uint32_t *dflt_idx, KNamelist **typedecls ) { VNamelist *list; rc_t rc = VNamelistMake ( & list, 8 ); if ( rc == 0 ) { uint32_t idx; const VColumnRef *first; String col_name; StringInitCString ( & col_name, col ); first = ( const VColumnRef* ) BSTreeFind ( columns, & col_name, VColumnRefCmpString ); if ( first != NULL ) { const VColumnRef *cref = ( const VColumnRef* ) BSTNodePrev ( & first -> n ); while ( cref != NULL && StringEqual ( & first -> name, & cref -> name ) ) { first = cref; cref = ( const VColumnRef* ) BSTNodePrev ( & cref -> n ); } for ( cref = first, idx = 0; ; ++ idx ) { rc = VNamelistAppend ( list, cref -> typedecl ); if ( rc != 0 ) break; if ( cref -> dflt ) * dflt_idx = idx; cref = ( const VColumnRef* ) BSTNodeNext ( & cref -> n ); if ( cref == NULL || ! StringEqual ( & first -> name, & cref -> name ) ) break; } } if ( rc == 0 ) rc = VNamelistToNamelist ( list, typedecls ); VNamelistRelease ( list ); } return rc; }
void TrieRead(bool swap) { struct stat sbuf; FILE *fp; PTrie *pt; size_t siz; char *fbuf; char buf[1024]; String key; int len; rc_t rc; PTNode ptn; uint32_t id; size_t count; if (stat("/tmp/foo", &sbuf)) { return; } siz = sbuf.st_size; fbuf = malloc(siz+1); fp = fopen("/tmp/foo", "r"); count = fread(fbuf, 1, siz, fp); if (count != siz) { fprintf(stderr, "Only read %ld of %ld\n", count, siz); return; } fbuf[siz] = '\0'; rc = PTrieMake(&pt, fbuf, siz, swap); if (rc != 0 || pt == NULL) { fprintf(stderr, "PTrieMake failed.\n"); return; } while (NULL != fgets(buf, 1024, stdin)) { len = strlen(buf); buf[--len] = '\0'; StringInitCString( &key, buf ); id = PTrieFind(pt, &key, &ptn, NULL, NULL); if ( id == 0 ) fprintf(stderr, "not found\n"); else fprintf(stderr, "id found: %d - '%.*s'\n", id, (int) ptn.data.size, ptn.data.addr); } }
rc_t get_slices( const Args * args, const char *option, Vector * slices ) { uint32_t count, i; rc_t rc = ArgsOptionCount( args, option, &count ); for ( i = 0; i < count && rc == 0; ++i ) { const char * value; rc = ArgsOptionValue( args, option, i, ( const void ** )&value ); if ( rc == 0 && value != NULL ) { String S; StringInitCString( &S, value ); { slice * s = make_slice_from_str( &S ); rc = VectorAppend( slices, NULL, s ); if ( rc != 0 ) release_slice( s ); } } } return rc; }
LIB_EXPORT rc_t CC KDyldRegisterBuiltin ( const char *c_name, void *addr ) { String name; if (builtins == NULL) { rc_t rc = 0; BSTree *scope; builtins = malloc ( sizeof * builtins ); if ( builtins == NULL ) { return RC ( rcFS, rcDylib, rcRegistering, rcMemory, rcExhausted ); } rc = KSymTableInit ( builtins, NULL ); if (rc == 0) { scope = malloc ( sizeof * scope ); if ( scope == NULL ) { rc = RC ( rcFS, rcDylib, rcRegistering, rcMemory, rcExhausted ); } else { BSTreeInit ( scope ); rc = KSymTablePushScope ( builtins, scope ); if (rc != 0) { free ( scope ); } } } if ( rc != 0 ) { free ( builtins ); builtins = NULL; return rc; } } StringInitCString ( & name, c_name ); return KSymTableCreateSymbol ( builtins, NULL, & name, 0, addr ); }
/* Make */ static rc_t KRepositoryMake ( KRepository **rp, const KConfigNode *node, const char *name, KRepCategory category, KRepSubCategory subcategory ) { rc_t rc; KRepository *r; String name_str; /* measure string */ StringInitCString ( & name_str, name ); /* create object */ r = malloc ( sizeof * r + name_str . size + 1 ); if ( r == NULL ) return RC ( rcKFG, rcNode, rcConstructing, rcMemory, rcExhausted ); rc = KConfigNodeAddRef ( node ); if ( rc != 0 ) { free ( r ); return rc; } r -> node = node; r -> name = name_str; r -> name . addr = ( char* ) ( r + 1 ); KRefcountInit ( & r -> refcount, 1, "KRepository", "make", name ); r -> category = category; r -> subcategory = subcategory; memcpy ( r + 1, name, name_str . size ); ( ( char* ) ( r + 1 ) ) [ name_str . size ] = 0; * rp = r; return 0; }
rc_t KMain ( int argc, char *argv [] ) { rc_t rc; MyKVPair *pair; char buf[1024]; int counter = 0; String key; int len; if (argc > 1 && !strcmp(argv[1], "-read")) { TrieRead(false); return 0; } if (argc > 1 && !strcmp(argv[1], "-swapread")) { TrieRead(true); return 0; } /* the documentation claims to return Unix status codes EINVAL or ENOMEM. however, it's more likely we just ran out of energy to update the comments... this creates a Trie with an initial character set of 0-9, but which expands to accept new characters as seen thanks to the "true" value for "cs_expand" a standard Trie would encode the entire string into the prefix-tree, while this version only encodes as much of the strings initial characters as necessary before depositing the nodes into a BSTree at the leaves. you have told the code that it can accept up to 512 nodes in the BSTree until it has to split them up. to get more standard Trie behavior, choose a lower number, e.g. 1 */ rc = TrieInit(&t, "a-z", 1, true); if (rc != 0) LOGERR ( klogInt, rc, "triecreate" ); /* you might want to get out after such an error... */ /* another comment for you - using "buf, sizeof buf, stdin" will be safer ( I know this is just for experimentation, but since I'm reviewing it, I want you to get your money's worth */ while (NULL != fgets(buf, 1024, stdin)) { len = strlen(buf); buf[--len] = '\0'; /* printf("%d\n", len); */ if (len <= 0) break; /* in C++, the cast to MyKVPair* is required, whereas in C it's not - which is part of its beauty. I prefer to avoid the cast unless we're planning on porting to C++, because the cast prevents you from changing the type of "pair" up above. same goes for "sizeof" - I prefer to let the compiler choose the right size for the allocation as "sizeof *pair" which will always be correct, even if I were to retype "pair" */ pair = (MyKVPair *)malloc(sizeof(MyKVPair) + len + 1); if (pair == NULL) { fprintf(stderr, "Error in malloc\n"); return -1; } strcpy(pair->key, buf); StringInitCString( &pair->tnode.key, (const char *)&pair->key ); pair->value = counter++; /* fprintf(stderr, "At trieinsert\n"); */ /* here I'd prefer "&pair->tnode" rather than the typecast ( do you get the idea I worry about typecasts? ) */ rc = TrieInsert( &t, (TNode *)pair ); if (rc != 0) LOGERR ( klogInt, rc, "triecreate" ); } while (NULL != fgets(buf, 1024, stdin)) { len = strlen(buf); buf[--len] = '\0'; StringInitCString( &key, buf ); /* the first cast is required, although would normally want to be a "const MyKVPair*" so that you are sure not to modify it. the second cast is unnecessary */ pair = (MyKVPair *)TrieFind(&t, (const String *)&key); if (pair != NULL) { printf("%s %d\n", buf, pair->value); } } Persist("/tmp/foo"); return 0; }
static bool StringCmp ( const String * self, const char * val ) { String v; StringInitCString ( & v, val ); return StringEqual ( self, & v ); }