int main(int argc, char **argv) { namelist nl=make_namelist(); int i; char c='f'; if(strcmp(argv[1],"-p")==0){ i=3; c='t'; } else i=1; while(i<argc){ FILE *file=fopen(argv[i],"r"); char name[64]; while(!feof(file)){ if (fgetname(name,64,file)!= NULL && res_name(name)!=1){ if(c=='f'||(c=='t'&& (name[0])!=*argv[2])) add_name(nl,name); } } fclose(file); i++; } qsort(nl->names,nl->size,sizeof(struct namestat),cmpfunc); print_list(nl); return 0; }
int32_t CodeBuilder::addop_name(Op opcode,std::string& name) { int arg = add_name(name); if (arg < 0) return 0; return addop_i(opcode, arg); }
int main (int argc, char **argv){ //varibales namelist nl = make_namelist(); FILE *stream; char *fileName; char name[64]; int FLAG = 0; int i = 1; int j = 0; //upload files in a loop and gets the name to an array for (i=1;i!=argc;i++){//each file fileName = argv[i];//get the file stream = fopen(fileName, "r");//read the file while(fgetname(name, sizeof(name), stream)) { if(legalName(name)){ printf("%s ", name); add_name(nl, name); //printf("\n"); } } fclose(stream); } qsort(nl->names,nl->size,sizeof(struct namestat),compare); for(i=0;i<nl->size;i++){ printf("%s %d\n",nl->names[i].name,nl->names[i].count); } return 0; }
/* flag the dll exports that link to an undefined symbol */ static void check_undefined_exports( DLLSPEC *spec ) { int i; for (i = 0; i < spec->nb_entry_points; i++) { ORDDEF *odp = &spec->entry_points[i]; if (odp->type == TYPE_STUB || odp->type == TYPE_ABS || odp->type == TYPE_VARIABLE) continue; if (odp->flags & FLAG_FORWARD) continue; if (find_name( odp->link_name, &undef_symbols )) { switch(odp->type) { case TYPE_PASCAL: case TYPE_STDCALL: case TYPE_CDECL: case TYPE_VARARGS: case TYPE_THISCALL: if (link_ext_symbols) { odp->flags |= FLAG_EXT_LINK; add_name( &ext_link_imports, odp->link_name ); } else error( "%s:%d: function '%s' not defined\n", spec->src_name, odp->lineno, odp->link_name ); break; default: error( "%s:%d: external symbol '%s' is not a function\n", spec->src_name, odp->lineno, odp->link_name ); break; } } } }
/* * Called to initialize the driver */ isc_result_t dlz_create(const char *dlzname, unsigned int argc, char *argv[], void **dbdata, ...) { struct dlz_example_data *state; const char *helper_name; va_list ap; char soa_data[200]; UNUSED(dlzname); state = calloc(1, sizeof(struct dlz_example_data)); if (state == NULL) return (ISC_R_NOMEMORY); /* Fill in the helper functions */ va_start(ap, dbdata); while ((helper_name = va_arg(ap, const char *)) != NULL) { b9_add_helper(state, helper_name, va_arg(ap, void*)); } va_end(ap); if (argc < 2) { state->log(ISC_LOG_ERROR, "dlz_example: please specify a zone name"); return (ISC_R_FAILURE); } state->zone_name = strdup(argv[1]); sprintf(soa_data, "%s hostmaster.%s 123 900 600 86400 3600", state->zone_name, state->zone_name); add_name(state, &state->current[0], state->zone_name, "soa", 3600, soa_data); add_name(state, &state->current[0], state->zone_name, "ns", 3600, state->zone_name); add_name(state, &state->current[0], state->zone_name, "a", 1800, "10.53.0.1"); state->log(ISC_LOG_INFO, "dlz_example: started for zone %s", state->zone_name); *dbdata = state; return (ISC_R_SUCCESS); }
void checkTxt(namelist nl, char *filename) { FILE *f1; f1 = fopen(filename,"r"); char kw[32][10] = {"auto", "double", "int", "long", "break", "else", "long", "switch", "case", "enum", "register", "typedef", "char", "extern", "return", "union", "const", "float", "short", "unsigned", "continue", "for", "signed", "oid", "default", "goto", "sizeof", "volatile", "do", "if", "static", "while"}; char x; int wordi=0; if (ferror (f1)) printf("error reading file - %s\n",filename ); else { char word[NAMELEN]=""; x=fgetc(f1); while (x != EOF)// not EOF (!feof(f1)) { if ((isdigit(x)!=0 )|( isalpha(x)!=0 )) //INWORD proccessing { word[wordi]=x; wordi++; x =fgetc(f1); } else //if buffer full - wordi!=0 - save word ->> in namelist. else next char { if (wordi!=0) //not in word and buffer is full { int j,flag=0; word[wordi]='\0'; //NOTICE \0 at end of string //printf("%s \n",word); for (j=0;j<32;j++) //NOTICE check word is not keyword { if (! strcmp(word,kw[j])) { flag=1; j=32; } } if (!flag) //add word add_name(nl, word); else //keyword, dont add it flag=0; wordi=0; //c=fgetc(f1); } else //not in word and buffer is empty = > get next char { //printf("else else else -not a word and word buffer is 0) \n"); x =fgetc(f1); } } } } fclose(f1); }
void copy_name_list( NAME_LIST_HDR *header, const NAME_LIST *list ) { while (list) { add_name( header, &list->name[0] ); list = list->next; } }
static void add_preproc_option(int key, const char *arg) { char *opt = xmalloc(3 + strlen(arg)); sprintf(opt, "-%c%s", key, arg); add_name(opt); preprocess_option = 1; }
void MON_LABELS::add(u8 *address, char *name) { if (n_pairs >= align_by(n_pairs, 1024)) pairs = (MON_LABEL*)realloc(pairs, sizeof(MON_LABEL) * align_by(n_pairs+1, 1024)); pairs[n_pairs].address = address; pairs[n_pairs].name_offs = add_name(name); n_pairs++; }
static int tty_rename(ARCHD *arcn) { char tmpname[PAXPATHLEN+2]; int res; /* * prompt user for the replacement name for a file, keep trying until * we get some reasonable input. Archives may have more than one file * on them with the same name (from updates etc). We print verbose info * on the file so the user knows what is up. */ tty_prnt("\nATTENTION: %s interactive file rename operation.\n", argv0); for (;;) { ls_tty(arcn); tty_prnt("Input new name, or a \".\" to keep the old name, "); tty_prnt("or a \"return\" to skip this file.\n"); tty_prnt("Input > "); if (tty_read(tmpname, sizeof(tmpname)) < 0) return(-1); if (strcmp(tmpname, "..") == 0) { tty_prnt("Try again, illegal file name: ..\n"); continue; } if (strlen(tmpname) > PAXPATHLEN) { tty_prnt("Try again, file name too long\n"); continue; } break; } /* * empty file name, skips this file. a "." leaves it alone */ if (tmpname[0] == '\0') { tty_prnt("Skipping file.\n"); return(1); } if ((tmpname[0] == '.') && (tmpname[1] == '\0')) { tty_prnt("Processing continues, name unchanged.\n"); return(0); } /* * ok the name changed. We may run into links that point at this * file later. we have to remember where the user sent the file * in order to repair any links. */ tty_prnt("Processing continues, name changed to: %s\n", tmpname); res = add_name(arcn->name, arcn->nlen, tmpname); arcn->nlen = strlcpy(arcn->name, tmpname, sizeof(arcn->name)); if (arcn->nlen >= sizeof(arcn->name)) arcn->nlen = sizeof(arcn->name) - 1; /* XXX truncate? */ if (res < 0) return(-1); return(0); }
void inbound_nameslist (server *serv, char *chan, char *names) { session *sess; char name[NICKLEN]; int pos = 0; sess = find_channel (serv, chan); if (!sess) { EMIT_SIGNAL (XP_TE_USERSONCHAN, serv->server_session, chan, names, NULL, NULL, 0); return; } if (!sess->ignore_names) EMIT_SIGNAL (XP_TE_USERSONCHAN, sess, chan, names, NULL, NULL, 0); if (sess->end_of_names) { sess->end_of_names = FALSE; clear_user_list (sess); } while (1) { switch (*names) { case 0: name[pos] = 0; if (pos != 0) add_name (sess, name, 0); return; case ' ': name[pos] = 0; pos = 0; add_name (sess, name, 0); break; default: name[pos] = *names; if (pos < (NICKLEN-1)) pos++; } names++; } }
int main(int argc, char **argv) { if(argc == 1) { printf("please run this program with at least one argument.\n"); } else{ int i; char buffer[BUFLEN]; char* saved_words[]= {"int","char","if","else","while","for","return",(char*)0}; namelist file_words= make_namelist(); for (i=1; i<argc; ++i){ FILE *fptr; if ( (fptr = fopen(argv[i],"r")) == NULL) printf ("file %s couldn't be opened\n",argv[i]); else { char word[BUFLEN]; int ich = 0; int isaved = 0; int inword = 0; for(;;) { int ch = fgetc(fptr); if(feof(fptr)) break; if(inword) { if(isalpha(ch)) { // adding char to the word word[ich] = ch; ++ich; } else{ // just finished reading a word word[ich] = 0; ich = 0; inword = 0; if (!find_word(saved_words,word)){ add_name(file_words,word); } } } else { if(isalpha(ch)) { //for the first char of the word ungetc(ch,fptr); inword=1; } if (ch == '\"'){ ch = fgetc(fptr); while (ch != '\"') ch = fgetc(fptr); } } } } } sort_words(file_words); print_words(file_words); } return 0; }
static isc_result_t modrdataset(struct dlz_example_data *state, const char *name, const char *rdatastr, struct record *list) { char *full_name, *dclass, *type, *data, *ttlstr, *buf; char absolute[1024]; isc_result_t result; #if defined(WIN32) || defined(_REENTRANT) char *saveptr = NULL; #endif buf = strdup(rdatastr); if (buf == NULL) return (ISC_R_FAILURE); /* * The format is: * FULLNAME\tTTL\tDCLASS\tTYPE\tDATA * * The DATA field is space separated, and is in the data format * for the type used by dig */ full_name = STRTOK_R(buf, "\t", &saveptr); if (full_name == NULL) goto error; ttlstr = STRTOK_R(NULL, "\t", &saveptr); if (ttlstr == NULL) goto error; dclass = STRTOK_R(NULL, "\t", &saveptr); if (dclass == NULL) goto error; type = STRTOK_R(NULL, "\t", &saveptr); if (type == NULL) goto error; data = STRTOK_R(NULL, "\t", &saveptr); if (data == NULL) goto error; if (name[strlen(name) - 1] != '.') { snprintf(absolute, sizeof(absolute), "%s.", name); name = absolute; } result = add_name(state, list, name, type, strtoul(ttlstr, NULL, 10), data); free(buf); return (result); error: free(buf); return (ISC_R_FAILURE); }
static void add_hierarchy_to_namelist (char *path, dev_t device) { char *buffer = get_directory_contents (path, device); { struct name *name; for (name = name_list_head; name; name = name->next) if (strcmp (name->name, path) == 0) break; if (name) name->dir_contents = buffer ? buffer : "\0\0\0\0"; } if (buffer) { size_t name_length = strlen (path); size_t allocated_length = (name_length >= NAME_FIELD_SIZE ? name_length + NAME_FIELD_SIZE : NAME_FIELD_SIZE); char *name_buffer = xmalloc (allocated_length + 1); /* FIXME: + 2 above? */ char *string; size_t string_length; strcpy (name_buffer, path); if (name_buffer[name_length - 1] != '/') { name_buffer[name_length++] = '/'; name_buffer[name_length] = '\0'; } for (string = buffer; *string; string += string_length + 1) { string_length = strlen (string); if (*string == 'D') { if (name_length + string_length >= allocated_length) { while (name_length + string_length >= allocated_length) allocated_length += NAME_FIELD_SIZE; name_buffer = (char *) xrealloc (name_buffer, allocated_length + 1); } strcpy (name_buffer + name_length, string + 1); add_name (name_buffer); add_hierarchy_to_namelist (name_buffer, device); } } free (name_buffer); } }
void inbound_join (server *serv, char *chan, char *user, char *ip) { session *sess = find_channel (serv, chan); if (sess) { if (!sess->hide_join_part) EMIT_SIGNAL (XP_TE_JOIN, sess, user, chan, ip, NULL, 0); add_name (sess, user, ip); } }
/*-------------------------------------------------------------------------*/ void load_wiz_file (void) /* Load the old wizlist from the wizlist file and add it's data to * the wizlist already in memory. * * This function is called at driver start up. * TODO: Since the wizlist is saved from the mudlib, this function * TODO:: should be implemented on mudlib level, too. */ { char buff[1000]; FILE *f; if (wizlist_name[0] == '\0') return; f = fopen(wizlist_name, "r"); if (f == NULL) return; while (fgets(buff, sizeof buff, f) != NULL) { char *p; uint32 score; p = strchr(buff, ' '); if (p == 0) { fprintf(stderr, "%s Bad WIZLIST file '%s'.\n" , time_stamp(), wizlist_name); break; } *p = '\0'; p++; if (*p == '\0') { fprintf(stderr, "%s Bad WIZLIST file '%s'.\n" , time_stamp(), wizlist_name); break; } score = atoi(p); if (score > 0) { string_t * tmp; tmp = new_mstring(buff); add_name(tmp)->score += score; free_mstring(tmp); } } fclose(f); } /* load_wiz_file() */
void create_armour() { set_name("forcefield"); add_name("mag_shield_prot"); set_adj("magic"); set_long("A magical forcefield covering your whole body.\n"); add_prop(OBJ_I_NO_DROP, 1); add_prop(OBJ_I_IS_MAGIC_ARMOUR, 1); add_prop(OBJ_S_WIZINFO, "A magical shield to protect the wearer. Will " + "out before to long\n"); add_prop(MAGIC_AM_MAGIC, ({ 20, "abjured" }) );
forth_obj str_to_exp(char* str) { int tmp = atoi(str); forth_obj ret; if((str[0] != '0') && (tmp == 0)){//string set_sym(&ret, add_name(str)); }else{//num set_num(&ret, tmp); } return ret; }
int main(int argc, char **argv) { FILE *ret; int j, i, isEqual=0; namelist ourList = make_namelist(); char tempWord[64]; char *saveWords[] = {"auto", "double", "int", "long", "break", "else", "long", "switch", "case", "enum", "register", "typedef" ,"char", "extern", "return", "union", "const", "float", "short", "unsigned", "continue", "for","signed", "void", "default", "goto", "sizeof" ,"volatile", "do", "if" ,"static" ,"while" }; for (j=1; j < argc; ++j) { ret = fopen( argv[j], "r"); /*ret is a pointer to the file*/ while( fgetname(tempWord, 64, ret)) { isEqual = 0; for(i=0; i<32; ++i) { if(strcmp(tempWord, saveWords[i])!=0) { isEqual = isEqual+1; } if(isEqual==32) { /*tempWord not equal to any of the key words*/ add_name(ourList, tempWord); } } } fclose (ret); } qsort (ourList->names, ourList->size, sizeof(struct namestat), compare); for(i=0; i<ourList->size; ++i) { printf("%s ", ourList->names[i].name); printf("%d\n", ourList->names[i].count); } return 0; }
/* add a library to the list of delayed imports */ void add_delayed_import( const char *name ) { struct import *imp; char *fullname = get_dll_name( name, NULL ); add_name( &delayed_imports, fullname ); if ((imp = is_already_imported( fullname )) && !imp->delay) { imp->delay = 1; nb_delayed++; } free( fullname ); }
void MON_LABELS::clear(u8 *start, unsigned size) { unsigned dst = 0; for (unsigned src = 0; src < n_pairs; src++) if ((unsigned)(pairs[src].address - start) > size) pairs[dst++] = pairs[src]; n_pairs = dst; // pack `names' char *pnames = names; names = 0; names_size = 0; for (unsigned l = 0; l < n_pairs; l++) pairs[l].name_offs = add_name(pnames + pairs[l].name_offs); free(pnames); }
/*-------------------------------------------------------------------------*/ void save_error (const char *msg, const char *file, int line) /* A runtime error <msg> occured for object <file> in line number <line>. * Store this information in the wizlist so that the mudlib can handle * it later with the efun get_error_file(). * TODO: A proper runtime error handling could put this into the mudlib * TODO:: completely. */ { wiz_list_t *wl; char *copy, *p; string_t *name; size_t len; /* Get the wizard name and the wizlist entry. */ name = get_wiz_name(file); if (!name) return; wl = add_name(name); /* Set the file_name */ if (wl->file_name) free_mstring(wl->file_name); len = strlen(file); copy = alloca(len + 4); /* May add .c plus the null byte, and / */ *copy = '/'; strcpy(copy+1, file); /* If it is a cloned object, we have to find out what the file * name is, and add '.c'. */ if ( NULL != (p = strrchr(copy, '#')) || ((p = copy+len), *p++ != 'c') || p[-2] != '.' ) { p[0] = '.'; p[1] = 'c'; p[2] = '\0'; } wl->file_name = new_mstring(copy); /* Set the error_message */ if (wl->error_message) free_mstring(wl->error_message); wl->error_message = new_mstring(msg); /* Set the line_number */ wl->line_number = line; } /* save_error() */
tlibc_error_code_t tlibc_read_field_begin(tlibc_abstract_reader_t *self, const char *var_name) { tlibc_error_code_t ret; ret = add_name(self, var_name); if(ret != E_TLIBC_NOERROR) { return ret; } if(self->read_field_begin == NULL) { return E_TLIBC_NOERROR; } return self->read_field_begin(self, var_name); }
void do_components( void (*func)(void)) { /** Function: Handles COMPONENTS OF in an item Procedure: 1. IF no next token OR it's not 'OF' OR no next token OR item is not in table OR it's imported, syntax error IF no function Add token as a child of classname Return Save current file position 2. Go to where item starts Read tokens until '{' is found 3. Call function Go back to saved place in file Keep reading until ',' or '}' **/ struct name_table *ntbp; long pos; if (tell_pos(streams.str) < real_start) return; if (!get_token(0, token) || /* step 1 */ strcmp(token, of_w) || !get_token(0, token)) syntax(components_w); if (!func) { add_child(token, add_name(classname, (long)0, 0), 0, (long)-1, 0); *itemname = 'x'; /* to make the test for no itemname fail */ return; } if (!(ntbp = find_name(token))->name || !*ntbp->name || ntbp->pos < 0) syntax(components_w); pos = tell_pos(streams.str); curr_pos = ntbp->pos; fseek(streams.str, ntbp->pos, 0); /* step 2 */ for (*token = 0; get_token(0, token) && *token != '{';); if (*token != '{') syntax(components_w); state = SUB_ITEM; if (func) (*func)(); /* step 3 */ curr_pos = pos; fseek(streams.str, pos, 0); state = IN_ITEM; for (*token = 0; *token != ',' && *token != '}'; get_token(0, token)); end_item(); }
/* * End a transaction */ void dlz_closeversion(const char *zone, isc_boolean_t commit, void *dbdata, void **versionp) { struct dlz_example_data *state = (struct dlz_example_data *)dbdata; if (!state->transaction_started) { state->log(ISC_LOG_INFO, "dlz_example: transaction not started for zone %s", zone); *versionp = NULL; return; } state->transaction_started = ISC_FALSE; *versionp = NULL; if (commit) { int i; state->log(ISC_LOG_INFO, "dlz_example: committing transaction on zone %s", zone); for (i = 0; i < MAX_RECORDS; i++) { if (strlen(state->adds[i].name) > 0U) { add_name(state, &state->current[0], state->adds[i].name, state->adds[i].type, state->adds[i].ttl, state->adds[i].data); } } for (i = 0; i < MAX_RECORDS; i++) { if (strlen(state->deletes[i].name) > 0U) { del_name(state, &state->current[0], state->deletes[i].name, state->deletes[i].type, state->deletes[i].ttl, state->deletes[i].data); } } } else { state->log(ISC_LOG_INFO, "dlz_example: cancelling transaction on zone %s", zone); } memset(state->adds, 0, sizeof(state->adds)); memset(state->deletes, 0, sizeof(state->deletes)); }
int main(int argc, char **argv) { namelist nl = make_namelist(); int checks = 0; int i; add_name(nl, "foo"); add_name(nl, "bar"); add_name(nl, "foo"); for(i = 0; i!=nl->size; ++i) { if(!strcmp("foo", nl->names[i].name)) { assert(nl->names[i].count==2); checks|=1; } else if(!strcmp("bar", nl->names[i].name)) { assert(nl->names[i].count==1); checks|=2; } else { checks|=4; } } assert(checks==3); return 0; }
static void load_directory_fonts(const SkString& directory, unsigned int* count) { SkOSFile::Iter iter(directory.c_str(), ".ttf"); SkString name; while (iter.next(&name, false)) { SkString filename(directory); filename.append(name); bool isFixedWidth; SkString realname; SkTypeface::Style style = SkTypeface::kNormal; // avoid uninitialized warning if (!get_name_and_style(filename.c_str(), &realname, &style, &isFixedWidth)) { SkDebugf("------ can't load <%s> as a font\n", filename.c_str()); continue; } FamilyRec* family = find_familyrec(realname.c_str()); if (family && family->fFaces[style]) { continue; } // this constructor puts us into the global gFamilyHead llist FamilyTypeface* tf = SkNEW_ARGS(FileTypeface, (style, true, // system-font (cannot delete) family, // what family to join filename.c_str(), isFixedWidth) // filename ); if (NULL == family) { add_name(realname.c_str(), tf->getFamily()); } *count += 1; } SkOSFile::Iter dirIter(directory.c_str()); while (dirIter.next(&name, true)) { if (name.startsWith(".")) { continue; } SkString dirname(directory); dirname.append(name); dirname.append(SK_FONT_FILE_DIR_SEPERATOR); load_directory_fonts(dirname, count); } }
/* the rest of the pattern segments */ #endif /* ANSI_PROTOTYPES */ { char *saved_end = path_end; /* saved to be resored */ char *pat; /* current pattern segment */ struct stat st; /* to check if file exists */ #ifdef GLOBDEBUG ffprintf(STDDBG,"do_glob: path = '%s', pat = '%s'\n", main_path, *gpat ); #endif for ( ; (pat = *gpat) != 0 && no_glob(pat); gpat++ ) { #ifdef GLOBDEBUG ffprintf(STDDBG,"no_glob: path = '%s', pat = '%s'\n", main_path, pat ); #endif *path_end = '/'; (void)strcpy(path_end+1, pat); path_end += strlen(pat) + 1; if (GLOBSTAT(main_path, &st) != 0 ) { *saved_end = '\0'; return; } } if (pat) matchdir(path_end, gpat); else add_name(); *saved_end = '\0'; return; } static void #ifndef ANSI_PROTOTYPES matchdir(path_end, gpat) char *path_end; /* ptr to end of main_path */ char **gpat; /* the rest of the pattern segments */ #else /* ANSI_PROTOTYPES */ matchdir(char *path_end, char **gpat) /* ptr to end of main_path */ /* the rest of the pattern segments */ #endif /* ANSI_PROTOTYPES */ { char *x; /* scratch */ VOIDDIR *dirp; /* for directory reading */ VOIDDIRENT *dp; /* directory entry */ struct stat st; /* to determine files type */ #ifdef GLOBDEBUG ffprintf(STDDBG,"matchdir: path = '%s', pat = '%s'\n", main_path, *gpat ); #endif if ((dirp = OPENDIR(main_path)) == NULL) return; *path_end = '/'; while ((dp = READDIR(dirp)) != NULL) { char *dirname; x = dirname = GETNAME(dp); /* was dp->d_name */ if (*x == '.' && (*++x == '\0' || (*x == '.' && *++x == '\0'))) continue; if (*dirname == '.' && **gpat != '.') continue; (void)strcpy(path_end + 1, dirname); if (glob_match(*gpat, dirname)) { /* this is a match */ if ( *(gpat+1) == 0 ) { /* and it is the last */ add_name(); /* so eat it */ continue; } if (GLOBSTAT(main_path, &st) == 0 /* else not the last */ && (st.st_mode & S_IFMT) == S_IFDIR) do_glob(path_end + strlen(dirname) + 1, gpat + 1); } } (void)CLOSEDIR(dirp); *path_end = '\0'; }
// Step 1 static void find_names_types_use(painter_t* painter, reachable_types_t* types) { assert(painter != NULL); assert(types != NULL); size_t i = HASHMAP_BEGIN; size_t typemap_index = 0; uint64_t typemap_mask = 1; reachable_type_t* type; while((type = reachable_types_next(types, &i)) != NULL) { assert(typemap_index < painter->typemap_size); size_t j = HASHMAP_BEGIN; reachable_method_name_t* mn; while((mn = reachable_method_names_next(&type->methods, &j)) != NULL) { size_t k = HASHMAP_BEGIN; reachable_method_t* method; while((method = reachable_methods_next(&mn->r_methods, &k)) != NULL) { const char* name = method->name; name_record_t* name_rec = find_name(painter, name); if(name_rec == NULL) // This is the first use of this name name_rec = add_name(painter, name); // Mark this name as using the current type name_rec->type_map[typemap_index] |= typemap_mask; } } // Advance to next type bitmap entry typemap_mask <<= 1; if(typemap_mask == 0) { typemap_mask = 1; typemap_index++; } } }
static isc_result_t modrdataset(struct dlz_example_data *state, const char *name, const char *rdatastr, struct record *list) { char *full_name, *dclass, *type, *data, *ttlstr; char *buf = strdup(rdatastr); isc_result_t result; #if defined(WIN32) || defined(_REENTRANT) char *saveptr = NULL; #endif /* * The format is: * FULLNAME\tTTL\tDCLASS\tTYPE\tDATA * * The DATA field is space separated, and is in the data format * for the type used by dig */ full_name = STRTOK_R(buf, "\t", &saveptr); if (full_name == NULL) return (ISC_R_FAILURE); ttlstr = STRTOK_R(NULL, "\t", &saveptr); if (ttlstr == NULL) return (ISC_R_FAILURE); dclass = STRTOK_R(NULL, "\t", &saveptr); if (dclass == NULL) return (ISC_R_FAILURE); type = STRTOK_R(NULL, "\t", &saveptr); if (type == NULL) return (ISC_R_FAILURE); data = STRTOK_R(NULL, "\t", &saveptr); if (data == NULL) return (ISC_R_FAILURE); result = add_name(state, list, name, type, strtoul(ttlstr, NULL, 10), data); free(buf); return (result); }