double_hash_t* init_double_hash(int hs_two_pow) { double_hash_t* hash = NULL; int hash_size; if(hs_two_pow>MAX_HSIZE_TWO_POW || hs_two_pow<0) hash_size = MAX_HASH_SIZE; else hash_size = 1<<hs_two_pow; /* space for the double_hash is allocated in share memory */ hash = (double_hash_t*)shm_malloc(sizeof(double_hash_t)); if(hash == NULL) return NULL; if( (hash->dhash = init_hash(hash_size)) == NULL ) { shm_free(hash); return NULL; } if( (hash->chash = init_hash(hash_size)) == NULL ) { free_hash(hash->dhash, hash_size, ERASE_CELL); shm_free(hash); return NULL; } hash->hash_size = hash_size; return hash; }
struct vxlan_instance * create_vxlan_instance (u_int8_t * vni) { char cbuf[16]; u_int32_t vni32; struct vxlan_instance * vins; /* create socket and fdb */ vins = (struct vxlan_instance *) malloc (sizeof (struct vxlan_instance)); memset (vins, 0, sizeof (struct vxlan_instance)); memcpy (vins->vni, vni, VXLAN_VNISIZE); snprintf (cbuf, 16, "0x%02x%02x%02x", vins->vni[0],vins->vni[1], vins->vni[2]); vni32 = strtol (cbuf, NULL, 0); snprintf (vins->vxlan_tap_name, IFNAMSIZ, "%s%X", VXLAN_TUNNAME, vni32); vins->fdb = init_fdb (); vins->tap_sock = tap_alloc (vins->vxlan_tap_name); /* create out bound MAC/ARP/ND/RA access list */ init_hash (&vins->acl_mac, ETH_ALEN); init_hash (&vins->acl_ip4, sizeof (struct in_addr)); init_hash (&vins->acl_ip6, sizeof (struct in6_addr)); return vins; }
int main () { int n, num0[6]; while(~scanf("%d", &n)) { cur = 0; init_hash(); int temp, twins = 0; for(int i = 0; i < n; i ++) { for(int j = 0; j < 6; j ++) { scanf("%d", &temp); num0[j] = temp; } if(twins) continue; twins = search_hash(num0); } if(twins) printf("Twin snowflakes found.\n"); else printf("No two snowflakes are alike.\n"); } return 0; }
static void add_keyword (const char *name, hash_table *keywords) { if (name == NULL) default_keywords = false; else { const char *end; int argnum1; int argnum2; const char *colon; if (keywords->table == NULL) init_hash (keywords, 100); split_keywordspec (name, &end, &argnum1, &argnum2); /* The characters between name and end should form a valid C identifier. A colon means an invalid parse in split_keywordspec(). */ colon = strchr (name, ':'); if (colon == NULL || colon >= end) { if (argnum1 == 0) argnum1 = 1; insert_entry (keywords, name, end - name, (void *) (long) (argnum1 + (argnum2 << 10))); } } }
void tpie_init(int subsystems) { if (subsystems & MEMORY_MANAGER) init_memory_manager(); if (subsystems & DEFAULT_LOGGING) init_default_log(); if (subsystems & PRIMEDB) init_prime(); if (subsystems & CAPTURE_FRACTIONS) { init_fraction_db(true); init_execution_time_db(); } else if (subsystems & PROGRESS) { init_fraction_db(false); init_execution_time_db(); } if (subsystems & JOB_MANAGER) init_job(); if (subsystems & STREAMS) { init_stream_buffer_pool(); init_compressor(); } if (subsystems & HASH) init_hash(); }
int main() { struct test *dummy; size_t size = 13; HASHTABLE init = init_hash(dummy, size, (void *)casting); strcpy(point_one.name, "entry\0"); strcpy(point_sec.name, "hello\0"); strcpy(point_thi.name, "12345\0"); point_one.x = 5; point_one.y = 20; point_sec.x = 17; point_sec.y = 30; point_thi.x = 11; point_thi.y = 2350; insertHash(init, point_one.name, &point_one); insertHash(init, point_sec.name, &point_sec); insertHash(init, point_thi.name, &point_thi); dummy = getHash(init, point_sec.name); printf("Output Name: %s, x: %d, y: %d\n", dummy->name, dummy->x, dummy->y); return 1; }
int main(/* int argc, char **argv */) { ngx_pool_t *pool = NULL; ngx_array_t *array = NULL; ngx_hash_t *hash; printf("--------------------------------\n"); printf("create a new pool:\n"); printf("--------------------------------\n"); pool = ngx_create_pool(1024, &ngx_log); dump_pool(pool); printf("--------------------------------\n"); printf("create and add urls to it:\n"); printf("--------------------------------\n"); array = add_urls_to_array(pool); //in fact, here should validate array dump_hash_array(array); printf("--------------------------------\n"); printf("the pool:\n"); printf("--------------------------------\n"); dump_pool(pool); hash = init_hash(pool, array); if (hash == NULL) { printf("Failed to initialize hash!\n"); return -1; } printf("--------------------------------\n"); printf("the hash:\n"); printf("--------------------------------\n"); dump_hash(hash, array); printf("\n"); printf("--------------------------------\n"); printf("the pool:\n"); printf("--------------------------------\n"); dump_pool(pool); //find test printf("--------------------------------\n"); printf("find test:\n"); printf("--------------------------------\n"); find_test(hash, urls, Max_Num); printf("\n"); find_test(hash, urls2, Max_Num2); //release ngx_array_destroy(array); ngx_destroy_pool(pool); return 0; }
static void dissector_init_lay3(int (*fnt)(void *ptr)) { init_hash(ð_lay3); INSERT_HASH_PROTOS(icmp_ops, eth_lay3); INSERT_HASH_PROTOS(udp_ops, eth_lay3); INSERT_HASH_PROTOS(tcp_ops, eth_lay3); for_each_hash(ð_lay3, fnt); }
void begin(void) { init_hash(); init_data(); init_board(); setbuf(stdout, NULL); setbuf(stdin, NULL); }
int main(int argc, const char* argv[]) { struct simple_hash ht; init_hash(&ht,128); for (;;) { char buf[256]; if (fgets(buf, 256, stdin) == NULL) break; char *command = strtok(buf, whitespace); unsigned int key; unsigned int value; if (strcmp(command, "insert") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); sscanf(strtok(NULL, whitespace), "%u", &value); hash_insert(&ht,key,value); } else if (strcmp(command, "lookup") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); size_t value; int result; result=hash_lookup(&ht,key, &value); if (result==0) printf("%u\n", (unsigned int) value); else printf("None\n"); } else if (strcmp(command, "increment") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); hash_cell_insert(&ht,key)->value++; } else if (strcmp(command, "delete") == 0) { sscanf(strtok(NULL, whitespace), "%u", &key); hash_delete(&ht,key); } else if (strcmp(command, "clear") == 0) { clear_hash(&ht); } else if (strcmp(command, "compact") == 0) { compact_hash(&ht); } fflush(stdout); } // Dump entire table printf("{\n"); if(ht.m_zeroUsed) printf(" %u: %u,\n", ht.m_zeroCell.key, ht.m_zeroCell.value); for(size_t i=0;i<ht.m_arraySize;i++) if(ht.m_cells[i].key) printf(" %u: %u,\n", ht.m_cells[i].key, ht.m_cells[i].value); printf("}\n"); end_hash(&ht); return 0; }
static void type_add(char *name, char *value) { int h; stabtype *s; char sc =0; char *v; char *vr; char *split; if (!stab_type_init) { init_hash(); stab_type_init = 1; } /* Split the "value" up into a type name and a value */ split = strchr(value,'='); if (value[0] != '(') split = 0; if (split) { sc = *split; v = value; *split = 0; vr = split+1; } else { v = value; sc = 0; vr = 0; } h = thash(name); s = lnames[h]; while (s) { if (strcmp(s->name,name) == 0) { if (strcmp(s->value,v)) { s->value = wad_string_lookup(v); } goto add_more; } s = s->next; } s = deadnames[h]; if (!s) { s = (stabtype *) wad_malloc(sizeof(stabtype)); } else { deadnames[h] = s->next; } s->name = wad_string_lookup(name); s->value = wad_string_lookup(v); s->next = lnames[h]; s->visit = 0; lnames[h] = s; /* Now take a look at the value. If it is contains other types, we might be able to define more stuff */ add_more: if (vr) { /* There is a mapping to another type */ type_add(v,vr); } }
static void dissector_init_lay2(int (*fnt)(void *ptr)) { init_hash(ð_lay2); INSERT_HASH_PROTOS(arp_ops, eth_lay2); INSERT_HASH_PROTOS(vlan_ops, eth_lay2); INSERT_HASH_PROTOS(ipv4_ops, eth_lay2); INSERT_HASH_PROTOS(ipv6_ops, eth_lay2); for_each_hash(ð_lay2, fnt); }
static void init_sockaddr_mapper(void) { rwlock_init(&sockaddr_map_lock); rwlock_wr_lock(&sockaddr_map_lock); memset(&sockaddr_mapper, 0, sizeof(sockaddr_mapper)); init_hash(&sockaddr_mapper); rwlock_unlock(&sockaddr_map_lock); }
int main(int argc, char const *argv[]) { check_permission(); setup_signal_chld(); parseconf_load_file("ftpserver.conf"); print_conf(); init_hash(); //创建一个监听fd int listenfd = tcp_server(tunable_listen_address, tunable_listen_port); pid_t pid; session_t sess; session_init(&sess); p_sess = &sess; //配置全局变量 while(1) { struct sockaddr_in addr; int peerfd = accept_timeout(listenfd, &addr, tunable_accept_timeout); if(peerfd == -1 && errno == ETIMEDOUT) continue; else if(peerfd == -1) ERR_EXIT("accept_timeout"); //获取ip地址,并在hash中添加一条记录 uint32_t ip = addr.sin_addr.s_addr; sess.ip = ip; add_clients_to_hash(&sess, ip); if((pid = fork()) == -1) ERR_EXIT("fork"); else if(pid == 0) { close(listenfd); sess.peerfd = peerfd; limit_num_clients(&sess); session_begin(&sess); exit(EXIT_SUCCESS); } else { //pid_to_ip add_pid_ip_to_hash(pid, ip); close(peerfd); } } return 0; }
int main() { int i; scanf("%d %d", &n, &m); init_hash(); cnt = 0; for(i = 0;i < n; i++) scanf("%d %d", k + i, p + i); mid = n>>1; left(0, 0); right(0, mid); printf("%d\n", cnt); return 0; }
static void dissector_init_layer_2(int type) { init_hash(ð_lay2); INSERT_HASH_PROTOS(arp_ops, eth_lay2); INSERT_HASH_PROTOS(lldp_ops, eth_lay2); INSERT_HASH_PROTOS(vlan_ops, eth_lay2); INSERT_HASH_PROTOS(ipv4_ops, eth_lay2); INSERT_HASH_PROTOS(ipv6_ops, eth_lay2); INSERT_HASH_PROTOS(QinQ_ops, eth_lay2); INSERT_HASH_PROTOS(mpls_uc_ops, eth_lay2); for_each_hash_int(ð_lay2, dissector_set_print_type, type); }
void init_cpusched(unsigned int cpus) { rwlock_init(&map_lock); rwlock_wr_lock(&map_lock); cpu_len = cpus; cpu_assigned = xzmalloc(cpus * sizeof(*cpu_assigned)); memset(&mapper, 0, sizeof(mapper)); init_hash(&mapper); rwlock_unlock(&map_lock); }
/* *函数名称:public_init *函数功能:public module init *输入参数:none *输出参数:none *返回值: on success, return 0(YT_SUCCESS). on error, -1(YT_FAILED) is returned. */ int public_init() { INFO_PRINT("\n----->Public模块初始化..........\n"); //计数器 global_shared.retain_count ++; mempool_init(); init_hash(); log_init(); return YT_SUCCESSFUL; }
static bool init_multicast_group_table() { assert( multicast_groups == NULL ); multicast_groups = malloc( sizeof( struct multicast_group_table ) ); assert( multicast_groups != NULL ); memset( multicast_groups, 0, sizeof( struct multicast_group_table ) ); init_hash( &multicast_groups->groups, sizeof( struct in_addr ) ); pthread_mutexattr_t attr; pthread_mutexattr_init( &attr ); pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE_NP ); pthread_mutex_init( &multicast_groups->mutex, &attr ); return true; }
void global_setup( int use_random, int hash_bits ) { FILE *log_file; time_t timer; /* Clear the log file. No error handling done. */ #if defined(ANDROID) sprintf(log_file_path, "%s/%s", android_files_dir, LOG_FILE_NAME); #elif defined(__linux__) strcpy( log_file_path, LOG_FILE_NAME ); #else char directory_buffer[MAX_PATH_LENGTH]; getcwd( directory_buffer, MAX_PATH_LENGTH ); if ( directory_buffer[strlen( directory_buffer ) - 1] == '\\' ) sprintf( log_file_path, "%s%s", directory_buffer, LOG_FILE_NAME ); else sprintf( log_file_path, "%s\\%s", directory_buffer, LOG_FILE_NAME ); #endif if ( use_log_file ) { log_file = fopen( log_file_path, "w" ); if ( log_file != NULL ) { time( &timer ); fprintf( log_file, "%s %s\n", LOG_TEXT, ctime( &timer ) ); fprintf( log_file, "%s %s %s\n", ENGINE_TEXT, __DATE__, __TIME__ ); fclose( log_file ); } } if ( use_random ) { time( &timer ); my_srandom( timer ); } else my_srandom( 1 ); init_hash( hash_bits ); init_bitboard(); init_moves(); init_patterns(); init_coeffs(); init_timer(); init_probcut(); init_stable(); setup_search(); }
struct dfont * dfont_create(int width, int height) { int max_line = height / TINY_FONT; int max_char = max_line * width / TINY_FONT; size_t ssize = max_char * sizeof(struct hash_rect); size_t lsize = max_line * sizeof(struct font_line); struct dfont *df = (struct dfont *)malloc(sizeof(struct dfont) + ssize + lsize); df->width = width; df->height = height; df->max_line = 0; df->version = 0; INIT_LIST_HEAD(&df->time); df->freelist = (struct hash_rect *)(df+1); df->line = (struct font_line *)((intptr_t)df->freelist + ssize); init_hash(df, max_char); return df; }
static void dissector_init_layer_3(int type) { init_hash(ð_lay3); INSERT_HASH_PROTOS(icmpv4_ops, eth_lay3); INSERT_HASH_PROTOS(icmpv6_ops, eth_lay3); INSERT_HASH_PROTOS(igmp_ops, eth_lay3); INSERT_HASH_PROTOS(ip_auth_ops, eth_lay3); INSERT_HASH_PROTOS(ip_esp_ops, eth_lay3); INSERT_HASH_PROTOS(ipv6_dest_opts_ops, eth_lay3); INSERT_HASH_PROTOS(ipv6_fragm_ops, eth_lay3); INSERT_HASH_PROTOS(ipv6_hop_by_hop_ops, eth_lay3); INSERT_HASH_PROTOS(ipv6_in_ipv4_ops, eth_lay3); INSERT_HASH_PROTOS(ipv6_mobility_ops, eth_lay3); INSERT_HASH_PROTOS(ipv6_no_next_header_ops, eth_lay3); INSERT_HASH_PROTOS(ipv6_routing_ops, eth_lay3); INSERT_HASH_PROTOS(tcp_ops, eth_lay3); INSERT_HASH_PROTOS(udp_ops, eth_lay3); for_each_hash_int(ð_lay3, dissector_set_print_type, type); }
int common_init( void ) { if( init_hash() ) return 1; if( !(g_sesstab=kmalloc_cont_mol(sizeof(*g_sesstab))) ) { cleanup_hash(); return 1; } memset( g_sesstab, 0, sizeof(*g_sesstab) ); init_MUTEX_mol( &g_sesstab->lock ); if( arch_common_init() ) { free_MUTEX_mol( &g_sesstab->lock ); kfree_cont_mol( g_sesstab ); cleanup_hash(); return 1; } return 0; }
void csiebox_client_init( csiebox_client** client, int argc, char** argv) { csiebox_client* tmp = (csiebox_client*)malloc(sizeof(csiebox_client)); if (!tmp) { fprintf(stderr, "client malloc fail\n"); return; } memset(tmp, 0, sizeof(csiebox_client)); if (!parse_arg(tmp, argc, argv)) { fprintf(stderr, "Usage: %s [config file]\n", argv[0]); free(tmp); return; } int fd = client_start(tmp->arg.name, tmp->arg.server); if (fd < 0) { fprintf(stderr, "connect fail\n"); free(tmp); return; } tmp->conn_fd = fd; fd = inotify_init(); if (fd < 0) { fprintf(stderr, "inotify fail\n"); close(tmp->conn_fd); free(tmp); return; } tmp->inotify_fd = fd; if (!init_hash(&(tmp->inotify_hash), 100)) { destroy_hash(&(tmp->inotify_hash)); fprintf(stderr, "hash fail\n"); close(tmp->conn_fd); close(tmp->inotify_fd); free(tmp); } memset(tmp->root, 0, PATH_MAX); realpath(tmp->arg.path, tmp->root); *client = tmp; }
pdt_hash_t* pdt_init_hash(int hs_two_pow) { pdt_hash_t* hash = NULL; int hash_size; if(hs_two_pow>MAX_HSIZE_TWO_POW || hs_two_pow<0) hash_size = MAX_HASH_SIZE; else hash_size = 1<<hs_two_pow; /* space for the double_hash is allocated in share memory */ hash = (pdt_hash_t*)shm_malloc(sizeof(pdt_hash_t)); if(hash == NULL) { LOG(L_ERR, "PDT:pdt_init_hash: no more shm\n"); return NULL; } if(lock_init(&hash->diff_lock) == 0) { shm_free(hash); LOG(L_ERR, "PDT:pdt_init_hash: cannot init the diff lock\n"); return NULL; } if( (hash->dhash = init_hash(hash_size)) == NULL ) { lock_destroy(&hash->diff_lock); shm_free(hash); LOG(L_ERR, "PDT:pdt_init_hash: no more shm!\n"); return NULL; } hash->hash_size = hash_size; return hash; }
/* ARGSUSED */ DB * __hash_open(const char *file, int flags, int mode, const HASHINFO *info, /* Special directives for create */ int dflags) { HTAB *hashp; struct stat statbuf; DB *dbp; int bpages, hdrsize, new_table, nsegs, save_errno; if ((flags & O_ACCMODE) == O_WRONLY) { errno = EINVAL; return (NULL); } if (!(hashp = (HTAB *)calloc(1, sizeof(HTAB)))) return (NULL); hashp->fp = -1; /* * Even if user wants write only, we need to be able to read * the actual file, so we need to open it read/write. But, the * field in the hashp structure needs to be accurate so that * we can check accesses. */ hashp->flags = flags; if (file) { if ((hashp->fp = _open(file, flags | O_CLOEXEC, mode)) == -1) RETURN_ERROR(errno, error0); new_table = _fstat(hashp->fp, &statbuf) == 0 && statbuf.st_size == 0 && (flags & O_ACCMODE) != O_RDONLY; } else new_table = 1; if (new_table) { if (!(hashp = init_hash(hashp, file, info))) RETURN_ERROR(errno, error1); } else { /* Table already exists */ if (info && info->hash) hashp->hash = info->hash; else hashp->hash = __default_hash; hdrsize = _read(hashp->fp, &hashp->hdr, sizeof(HASHHDR)); #if BYTE_ORDER == LITTLE_ENDIAN swap_header(hashp); #endif if (hdrsize == -1) RETURN_ERROR(errno, error1); if (hdrsize != sizeof(HASHHDR)) RETURN_ERROR(EFTYPE, error1); /* Verify file type, versions and hash function */ if (hashp->MAGIC != HASHMAGIC) RETURN_ERROR(EFTYPE, error1); #define OLDHASHVERSION 1 if (hashp->VERSION != HASHVERSION && hashp->VERSION != OLDHASHVERSION) RETURN_ERROR(EFTYPE, error1); if ((int32_t)hashp->hash(CHARKEY, sizeof(CHARKEY)) != hashp->H_CHARKEY) RETURN_ERROR(EFTYPE, error1); /* * Figure out how many segments we need. Max_Bucket is the * maximum bucket number, so the number of buckets is * max_bucket + 1. */ nsegs = (hashp->MAX_BUCKET + 1 + hashp->SGSIZE - 1) / hashp->SGSIZE; if (alloc_segs(hashp, nsegs)) /* * If alloc_segs fails, table will have been destroyed * and errno will have been set. */ return (NULL); /* Read in bitmaps */ bpages = (hashp->SPARES[hashp->OVFL_POINT] + (hashp->BSIZE << BYTE_SHIFT) - 1) >> (hashp->BSHIFT + BYTE_SHIFT); hashp->nmaps = bpages; (void)memset(&hashp->mapp[0], 0, bpages * sizeof(u_int32_t *)); } /* Initialize Buffer Manager */ if (info && info->cachesize) __buf_init(hashp, info->cachesize); else __buf_init(hashp, DEF_BUFSIZE); hashp->new_file = new_table; hashp->save_file = file && (hashp->flags & O_RDWR); hashp->cbucket = -1; if (!(dbp = (DB *)malloc(sizeof(DB)))) { save_errno = errno; hdestroy(hashp); errno = save_errno; return (NULL); } dbp->internal = hashp; dbp->close = hash_close; dbp->del = hash_delete; dbp->fd = hash_fd; dbp->get = hash_get; dbp->put = hash_put; dbp->seq = hash_seq; dbp->sync = hash_sync; dbp->type = DB_HASH; #ifdef DEBUG (void)fprintf(stderr, "%s\n%s%p\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%d\n%s%x\n%s%x\n%s%d\n%s%d\n", "init_htab:", "TABLE POINTER ", hashp, "BUCKET SIZE ", hashp->BSIZE, "BUCKET SHIFT ", hashp->BSHIFT, "DIRECTORY SIZE ", hashp->DSIZE, "SEGMENT SIZE ", hashp->SGSIZE, "SEGMENT SHIFT ", hashp->SSHIFT, "FILL FACTOR ", hashp->FFACTOR, "MAX BUCKET ", hashp->MAX_BUCKET, "OVFL POINT ", hashp->OVFL_POINT, "LAST FREED ", hashp->LAST_FREED, "HIGH MASK ", hashp->HIGH_MASK, "LOW MASK ", hashp->LOW_MASK, "NSEGS ", hashp->nsegs, "NKEYS ", hashp->NKEYS); #endif #ifdef HASH_STATISTICS hash_overflows = hash_accesses = hash_collisions = hash_expansions = 0; #endif return (dbp); error1: if (hashp != NULL) (void)_close(hashp->fp); error0: free(hashp); errno = save_errno; return (NULL); }
int wad_search_stab(void *sp, int size, char *stabstr, WadFrame *f) { Stab *s; int ns; int i; int found = 0; char *file, *lastfile = 0; char srcfile[MAX_PATH]; char objfile[MAX_PATH]; /* It appears to be necessary to clear the types table on each new stabs section */ init_hash(); if (!f->sym_name) return 0; s = (Stab *) sp; /* Stabs data */ ns = size/sizeof(Stab); /* number of stabs */ srcfile[0] = 0; objfile[0] = 0; for (i = 0; i < ns; i++, s++) { if (wad_debug_mode & DEBUG_STABS) { /* wad_printf(" %10d %10x %10d %10d %10d: '%s'\n", s->n_strx, s->n_type, s->n_other, s->n_desc, s->n_value, stabstr+s->n_strx); */ } if (s->n_type == N_LSYM) { stab_symbol(s,stabstr); continue; } if ((s->n_type == N_UNDF)) { /* && (s->n_desc >= 0)) { */ /* New stabs section. We need to be a little careful here. Do a recursive search of the subsection. */ if (wad_search_stab(s+1,s->n_desc*sizeof(Stab), stabstr, f)) { return 1; } /* On solaris, each stabs section seems to increment the stab string pointer. On Linux, the linker seems to do a certain amount of optimization that results in a single string table. */ #ifdef WAD_SOLARIS stabstr += s->n_value; /* Update the string table location*/ #endif i += s->n_desc; s += s->n_desc; objfile[0] = 0; srcfile[0] = 0; continue; } else if (s->n_type == N_SO) { /* Source file specification */ /* Look for directory */ file = stabstr+s->n_strx; if (strlen(file) && (file[strlen(file)-1] == '/')) { wad_strcpy(srcfile,file); } else { wad_strcat(srcfile,file); } objfile[0] = 0; /* If we have a file match, we might be looking for a local symbol. If so, we'll go ahead and set the srcfile field of the frame */ /* We're going to check for a file match. Maybe we're looking for a local symbol */ if (f->sym_file && strcmp(f->sym_file,file) == 0) { found = 1; } lastfile = file; } else if (s->n_type == N_OBJ) { /* Object file specifier */ if (objfile[0]) { wad_strcat(objfile,"/"); } wad_strcat(objfile,stabstr+s->n_strx); } else if (s->n_type == N_FUN) { if (match_stab_symbol(f->sym_name, stabstr+s->n_strx, f->sym_nlen)) { if (!f->sym_file || (strcmp(f->sym_file,lastfile) == 0)) { int n; /* Go find debugging information for the function */ n = scan_function(s+1, stabstr, ns -i - 1, f); f->loc_srcfile = wad_string_lookup(srcfile); f->loc_objfile = wad_string_lookup(objfile); return 1; } } } } /* If found, but no other debugging information was filled in, go ahead and copy the source and objfile information */ if ((found) && (!f->debug_check)) { f->loc_srcfile = wad_string_lookup(srcfile); f->loc_objfile = wad_string_lookup(objfile); } return found; }
int main(int argc, char *argv[]) { char onewdbfr[512],onewdaft[512]; char onetagbfr[512],twotagbfr[512],onetagaft[512],twotagaft[512]; char *freshcharvar; Darray errorlist,temperrorkey,temperrorval; Registry errorlistcount,SEENTAGGING,WORDS; FILE *correct_file, *guess_file, *error_list,*correct_out; char line[5000]; /* input line buffer */ char **split_ptr,**split_ptr2; char wdpair[1024]; char *tempstr,*tempstr2; float CONTINUE = 10000.0; int count2,numwrong,lengthcount; unsigned int count; char globalprint[500]; char systemcall[500]; char forpasting[500]; char forpasting2[500]; float globalbest = 0.0; char flag[20]; Registry currentwd,currentwd2; Registry always,always2; Registry wdnexttag,wdnexttag2,wdprevtag,wdprevtag2; Registry rbigram,lbigram,rbigram2,lbigram2; Registry next1tag,next1tag2,prev1tag,prev1tag2; Registry next1or2tag,next1or2tag2,prev1or2tag,prev1or2tag2; Registry next1or2or3tag,next1or2or3tag2,prev1or2or3tag,prev1or2or3tag2; Registry next1wd,next1wd2,prev1wd,prev1wd2; Registry next1or2wd,next1or2wd2,prev1or2wd,prev1or2wd2; Registry nextbigram,nextbigram2,prevbigram,prevbigram2; Registry surroundtag,surroundtag2; Registry next2tag,next2tag2,prev2tag,prev2tag2; Registry next2wd,next2wd2,prev2wd,prev2wd2; char globaldif[20]; int printscore; FILE *allowedmovefile; char **perl_split_ptr,**perl_split_ptr2,*atempstr,atempstr2[1024]; char space[500]; SEENTAGGING = Registry_create(Registry_strcmp,Registry_strhash); Registry_size_hint(SEENTAGGING,GUESSNUMWORDS); WORDS = Registry_create(Registry_strcmp,Registry_strhash); Registry_size_hint(WORDS,GUESSNUMWORDS); allowedmovefile = fopen(argv[4], "r"); while(fgets(line,sizeof(line),allowedmovefile) != NULL) { if (not_just_blank(line)) { line[strlen(line) - 1] = '\0'; perl_split_ptr = perl_split(line); perl_split_ptr2 = perl_split_ptr; ++perl_split_ptr; atempstr= mystrdup(*perl_split_ptr2); Registry_add(WORDS,atempstr,(char *)1); while(*perl_split_ptr != NULL) { sprintf(space,"%s %s",*perl_split_ptr2, *perl_split_ptr); atempstr=mystrdup(space); Registry_add(SEENTAGGING,atempstr,(char *)1); ++perl_split_ptr; } free(*perl_split_ptr2); free(perl_split_ptr2); } } system("/bin/rm AANEWRESTRJUNKKK"); correct_tag_corpus = Darray_create(); Darray_hint(correct_tag_corpus,100,400000); word_corpus = Darray_create(); Darray_hint(word_corpus,100,400000); correct_file = fopen(argv[1],"r"); while(fgets(line,sizeof(line),correct_file) != NULL) { Darray_addh(correct_tag_corpus,staart); Darray_addh(correct_tag_corpus,staart); Darray_addh(word_corpus,staart); Darray_addh(word_corpus,staart); line[strlen(line)-1] = '\0'; split_ptr = perl_split_independent(line); while (*split_ptr != NULL) { Darray_addh(word_corpus,*split_ptr); while ((*(++*split_ptr)) != '/') { } **split_ptr = '\0'; Darray_addh(correct_tag_corpus,++*split_ptr); ++split_ptr; } } fclose(correct_file); printf("READ IN CORRECT FILE\n"); while(CONTINUE > THRESHOLD) { guess_tag_corpus = Darray_create(); Darray_hint(guess_tag_corpus,100,400000); guess_file = fopen(argv[2],"r"); while(fgets(line,sizeof(line),guess_file) != NULL) { Darray_addh(guess_tag_corpus,staart); Darray_addh(guess_tag_corpus,staart); line[strlen(line)-1] = '\0'; split_ptr = perl_split_independent(line); split_ptr2 = split_ptr; while (*split_ptr != NULL) { tempstr = strtok(*split_ptr,"/"); tempstr = strtok(NULL,"/"); tempstr2 = mystrdup(tempstr); Darray_addh(guess_tag_corpus,tempstr2); free(*split_ptr); ++split_ptr; } free(split_ptr2); } fclose(guess_file); printf("READ IN BAD FILE\n"); errorlist = Darray_create(); Darray_hint(errorlist,10,500); temperrorkey = Darray_create(); temperrorval = Darray_create(); Darray_hint(temperrorkey,10,500); Darray_hint(temperrorval,10,500); init_hash(&errorlistcount,500); printscore=0; for(count=0;count<Darray_len(guess_tag_corpus);++count) { if (! is_tagged_with((char *)Darray_get(correct_tag_corpus,count),(char *)Darray_get(guess_tag_corpus,count))) { ++printscore; freshcharvar = mystrdup(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count))); sprintf(forpasting,"%s %s",freshcharvar, (char *)Darray_get(correct_tag_corpus,count)); increment_array_create(&errorlistcount,forpasting); } } error_list = fopen("AANEWRESTRJUNKKK","a"); Registry_fetch_contents(errorlistcount,temperrorkey,temperrorval); for (count=0;count<Darray_len(temperrorkey);++count) { if (*(int *)(char *)Darray_get(temperrorval,count) > THRESHOLD) /*Darray_addh(errorlist,tempstr);*/ fprintf(error_list,"%d %s\n",*(int *)(char *)Darray_get(temperrorval,count), (char *)Darray_get(temperrorkey,count)); free((char *)Darray_get(temperrorval,count)); free((char *)Darray_get(temperrorkey,count)); } fclose(error_list); Darray_destroy(temperrorval); Darray_destroy(temperrorkey); Registry_destroy(errorlistcount); printf("NUM ERRORS: %d\n",printscore); /* shoud sort error list !!!!!!!*/ system("cat AANEWRESTRJUNKKK | sort -rn > AANEWRESTRJUNKKK2"); system("mv AANEWRESTRJUNKKK2 AANEWRESTRJUNKKK"); error_list = fopen("AANEWRESTRJUNKKK","r"); while(fgets(line,sizeof(line),error_list) != NULL) { line[strlen(line)-1] = '\0'; tempstr = mystrdup(line); Darray_addh(errorlist,tempstr); } fclose(error_list); system("/bin/rm AANEWRESTRJUNKKK"); globalbest= 0; strcpy(globalprint,""); for (count=0;count<Darray_len(errorlist);++count) { localbest =0; strcpy(localbestthing,""); /*printf("ERROR LIST GUY: %s\n",(char *)Darray_get(errorlist,count)); */ split_ptr = perl_split_independent((char *)Darray_get(errorlist,count)); /*printf("ERRORLISTGUY: %s %s %s\n",split_ptr[0],split_ptr[1],split_ptr[2]);*/ wrong = split_ptr[1]; right = split_ptr[2]; numwrong = atoi(split_ptr[0]); if (numwrong > THRESHOLD3) { printf("WRONG,RI: %s %s\n",wrong,right); printf("GLOBALBEST, GLOBALPRINT, GLOBALDIF: %f %s %s\n",globalbest,globalprint,globaldif); init_hash(&always,NUMTAGS/2); init_hash(&always2,NUMTAGS/2); init_hash(&rbigram,(NUMWDS*NUMWDS)/4); init_hash(&lbigram,(NUMWDS*NUMWDS)/4); init_hash(&rbigram2,(NUMWDS*NUMWDS)/4); init_hash(&lbigram2,(NUMWDS*NUMWDS)/4); init_hash(&wdnexttag,(NUMWDS*NUMTAGS)/4); init_hash(&wdnexttag2,(NUMWDS*NUMTAGS)/4); init_hash(&wdprevtag,(NUMWDS*NUMTAGS)/4); init_hash(&wdprevtag2,(NUMWDS*NUMTAGS)/4); init_hash(&next1tag,NUMTAGS/2); init_hash(&next1tag2,NUMTAGS/2); init_hash(&prev1tag,NUMTAGS/2); init_hash(&prev1tag2,NUMTAGS/2); init_hash(&next1or2tag,NUMTAGS/2); init_hash(&next1or2tag2,NUMTAGS/2); init_hash(&prev1or2tag,NUMTAGS/2); init_hash(&prev1or2tag2,NUMTAGS/2); init_hash(&next1wd,NUMWDS/2); init_hash(&next1wd2,NUMWDS/2); init_hash(&prev1wd,NUMWDS/2); init_hash(&prev1wd2,NUMWDS/2); init_hash(¤twd,NUMWDS/2); init_hash(¤twd2,NUMWDS/2); init_hash(&next1or2wd,NUMWDS/2); init_hash(&next1or2wd2,NUMWDS/2); init_hash(&prev1or2wd,NUMWDS/2); init_hash(&prev1or2wd2,NUMWDS/2); init_hash(&next1or2or3tag,NUMTAGS/2); init_hash(&next1or2or3tag2,NUMTAGS/2); init_hash(&prev1or2or3tag,NUMTAGS/2); init_hash(&prev1or2or3tag2,NUMTAGS/2); init_hash(&nextbigram,NUMTAGS); init_hash(&nextbigram2,NUMTAGS); init_hash(&prevbigram,NUMTAGS); init_hash(&prevbigram2,NUMTAGS); init_hash(&surroundtag,NUMTAGS); init_hash(&surroundtag2,NUMTAGS); init_hash(&next2tag,NUMTAGS/2); init_hash(&next2tag2,NUMTAGS/2); init_hash(&prev2tag,NUMTAGS/2); init_hash(&prev2tag2,NUMTAGS/2); init_hash(&next2wd,NUMWDS/2); init_hash(&next2wd2,NUMWDS/2); init_hash(&prev2wd,NUMWDS/2); init_hash(&prev2wd2,NUMWDS/2); lengthcount = Darray_len(correct_tag_corpus); for(count2=0;count2<lengthcount;++count2){ sprintf(atempstr2,"%s %s",(char *)Darray_get(word_corpus,count2),right); if (Registry_get(WORDS,(char *)Darray_get(word_corpus,count2)) && ! Registry_get(SEENTAGGING,atempstr2)) strcpy(flag,"NOMATCH"); else if (strcmp((char *)Darray_get(correct_tag_corpus,count2),right) == 0 && (strcmp (first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2)),wrong) == 0) && (! is_tagged_with(right,(char *)Darray_get(guess_tag_corpus,count2)))) strcpy(flag,"BADMATCH"); else if (strcmp((char *)Darray_get(correct_tag_corpus,count2),right) != 0 && (strcmp (first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2)),wrong) == 0) && (! is_tagged_with(right,(char *)Darray_get(guess_tag_corpus,count2)))) strcpy(flag,"GOODMATCH"); else strcpy(flag,"NOMATCH"); if (strcmp(flag,"BADMATCH") == 0) { increment_array(&always,"DUMMY"); increment_array(¤twd,(char *)Darray_get(word_corpus,count2)); if (count2 != lengthcount-1) { strcpy(onewdaft,(char *)Darray_get(word_corpus,count2+1)); strcpy(onetagaft, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); sprintf(wdpair,"%s %s",(char *)Darray_get(word_corpus,count2), (char *)Darray_get(word_corpus,count2+1)); increment_array_create(&rbigram,wdpair); sprintf(wdpair,"%s %s",(char *)Darray_get(word_corpus,count2), first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); increment_array_create(&wdnexttag,wdpair); increment_array_create(&next1or2tag, first_tag_nospace( (char *)Darray_get(guess_tag_corpus,count2+1))); increment_array_create(&next1or2or3tag, first_tag_nospace( (char *)Darray_get(guess_tag_corpus,count2+1))); increment_array_create(&next1tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); increment_array(&next1wd,(char *)Darray_get(word_corpus,count2+1)); increment_array(&next1or2wd,(char *)Darray_get(word_corpus,count2+1)); } if (count2 < lengthcount-2) { strcpy(twotagaft,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); strcpy(forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); sprintf(forpasting,"%s %s",forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); increment_array_create(&nextbigram,forpasting); increment_array_create(&next2tag,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); increment_array(&next2wd,(char *)Darray_get(word_corpus,count2+2)); if (strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2)), onetagaft) != 0) { increment_array_create(&next1or2tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); increment_array_create(&next1or2or3tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); } if (strcmp((char *)Darray_get(word_corpus,count2+2),onewdaft) != 0) increment_array(&next1or2wd,(char *)Darray_get(word_corpus,count2+2)); } if (count2 < lengthcount-3) { if (strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+3)),onetagaft) != 0 && strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+3)),twotagaft) != 0) increment_array_create(&next1or2or3tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+3))); } if (count2 != 0) { strcpy(onewdbfr,(char *)Darray_get(word_corpus,count2-1)); strcpy(onetagbfr,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); sprintf(wdpair,"%s %s",(char *)Darray_get(word_corpus,count2-1), (char *)Darray_get(word_corpus,count2)); increment_array_create(&lbigram,wdpair); sprintf(wdpair,"%s %s",first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1)), (char *)Darray_get(word_corpus,count2)); increment_array_create(&wdprevtag,wdpair); increment_array_create(&prev1tag,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); increment_array(&prev1wd,(char *)Darray_get(word_corpus,count2-1)); increment_array(&prev1or2wd,(char *)Darray_get(word_corpus,count2-1)); increment_array_create(&prev1or2tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); increment_array_create(&prev1or2or3tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); if (count2 < lengthcount-1) { strcpy(forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); sprintf(forpasting,"%s %s",forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); increment_array_create(&surroundtag,forpasting); } } if (count2 > 1) { strcpy(twotagbfr,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); strcpy(forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); sprintf(forpasting,"%s %s",forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); increment_array_create(&prevbigram,forpasting); increment_array_create(&prev2tag,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); increment_array(&prev2wd,(char *)Darray_get(word_corpus,count2-2)); if (strcmp(first_tag_nospace( (char *)Darray_get(guess_tag_corpus,count2-2)),onetagbfr) != 0){ increment_array_create(&prev1or2tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); increment_array_create(&prev1or2or3tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); } if (strcmp((char *)Darray_get(word_corpus,count2-2),onewdbfr) != 0) increment_array(&prev1or2wd,(char *)Darray_get(word_corpus,count2-2)); } if (count2 > 2) { if (strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-3)),onetagbfr) != 0 && strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-3)),twotagbfr) != 0) increment_array_create(&prev1or2or3tag, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-3))); } } else if (strcmp(flag,"GOODMATCH") == 0) { increment_array(&always2,"DUMMY"); increment_array(¤twd2,(char *)Darray_get(word_corpus,count2)); if (count2 != lengthcount-1) { strcpy(onewdaft,(char *)Darray_get(word_corpus,count2+1)); strcpy(onetagaft,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); sprintf(wdpair,"%s %s",(char *)Darray_get(word_corpus,count2), (char *)Darray_get(word_corpus,count2+1)); increment_array_create(&rbigram2,wdpair); sprintf(wdpair,"%s %s",(char *)Darray_get(word_corpus,count2), first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); increment_array_create(&wdnexttag2,wdpair); increment_array_create(&next1tag2,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); increment_array(&next1wd2,(char *)Darray_get(word_corpus,count2+1)); increment_array(&next1or2wd2,(char *)Darray_get(word_corpus,count2+1)); increment_array_create(&next1or2tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); increment_array_create(&next1or2or3tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); } if (count2 < lengthcount-2) { strcpy(twotagaft,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); strcpy(forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); sprintf(forpasting,"%s %s",forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); increment_array_create(&nextbigram2,forpasting); increment_array_create(&next2tag2,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); increment_array(&next2wd2,(char *)Darray_get(word_corpus,count2+2)); if (strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2)),onetagaft) !=0) { increment_array_create(&next1or2tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); increment_array_create(&next1or2or3tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+2))); } if (strcmp((char *)Darray_get(word_corpus,count2+2),onewdaft) !=0) increment_array(&next1or2wd2,(char *)Darray_get(word_corpus,count2+2)); } if (count2 < lengthcount-3) { if (strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+3)),onetagaft) !=0 && strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+3)),twotagaft) !=0 ) increment_array_create(&next1or2or3tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+3))); } if (count2 != 0) { strcpy(onewdbfr,(char *)Darray_get(word_corpus,count2-1)); strcpy(onetagbfr,(char *)Darray_get(guess_tag_corpus,count2-1)); sprintf(wdpair,"%s %s",(char *)Darray_get(word_corpus,count2-1), (char *)Darray_get(word_corpus,count2)); increment_array_create(&lbigram2,wdpair); sprintf(wdpair,"%s %s",first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1)), (char *)Darray_get(word_corpus,count2)); increment_array_create(&wdprevtag2,wdpair); increment_array_create(&prev1tag2,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); increment_array(&prev1wd2,(char *)Darray_get(word_corpus,count2-1)); increment_array(&prev1or2wd2,(char *)Darray_get(word_corpus,count2-1)); increment_array_create(&prev1or2tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); increment_array_create(&prev1or2or3tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); if (count2 < lengthcount-1) { strcpy(forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); sprintf(forpasting,"%s %s",forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2+1))); increment_array_create(&surroundtag2,forpasting); } } if (count2 >1 ) { strcpy(twotagbfr,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); strcpy(forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); sprintf(forpasting,"%s %s",forpasting2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-1))); increment_array_create(&prevbigram2,forpasting); increment_array_create(&prev2tag2,first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); increment_array(&prev2wd2,(char *)Darray_get(word_corpus,count2-2)); if (strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2)),onetagbfr) != 0){ increment_array_create(&prev1or2tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); increment_array_create(&prev1or2or3tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-2))); } if (strcmp((char *)Darray_get(word_corpus,count2-2),onewdbfr) != 0) increment_array(&prev1or2wd2,(char *)Darray_get(word_corpus,count2-2)); } if (count2 > 2) { if (strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-3)),onetagbfr) != 0 && strcmp(first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-3)),twotagbfr) != 0) increment_array_create(&prev1or2or3tag2, first_tag_nospace((char *)Darray_get(guess_tag_corpus,count2-3))); } } } check_counts(&always,&always2,"ALWAYS"); check_counts(&prev1tag,&prev1tag2,"PREVTAG"); check_counts(&next1tag,&next1tag2,"NEXTTAG"); check_counts(&next1or2tag,&next1or2tag2,"NEXT1OR2TAG"); check_counts(&prev1or2tag,&prev1or2tag2,"PREV1OR2TAG"); check_counts(&next1wd,&next1wd2,"NEXTWD"); check_counts(¤twd,¤twd2,"CURRENTWD"); check_counts(&prev1wd,&prev1wd2,"PREVWD"); check_counts(&rbigram,&rbigram2,"RBIGRAM"); check_counts(&lbigram,&lbigram2,"LBIGRAM"); check_counts(&wdnexttag,&wdnexttag2,"WDNEXTTAG"); check_counts(&wdprevtag,&wdprevtag2,"WDPREVTAG"); check_counts(&next1or2wd,&next1or2wd2,"NEXT1OR2WD"); check_counts(&prev1or2wd,&prev1or2wd2,"PREV1OR2WD"); check_counts(&next1or2or3tag,&next1or2or3tag2,"NEXT1OR2OR3TAG"); check_counts(&prev1or2or3tag,&prev1or2or3tag2,"PREV1OR2OR3TAG"); check_counts(&prevbigram,&prevbigram2,"PREVBIGRAM"); check_counts(&nextbigram,&nextbigram2,"NEXTBIGRAM"); check_counts(&surroundtag,&surroundtag2,"SURROUNDTAG"); check_counts(&next2tag,&next2tag2,"NEXT2TAG"); check_counts(&prev2tag,&prev2tag2,"PREV2TAG"); check_counts(&next2wd,&next2wd2,"NEXT2WD"); check_counts(&prev2wd,&prev2wd2,"PREV2WD"); if (localbest > globalbest) { globalbest = localbest; strcpy(globaldif,localdif); strcpy(globalprint,localbestthing);} } } free(split_ptr[0]); free(split_ptr[1]); free(split_ptr[2]); free(split_ptr); for (count=0;count<strlen(globalprint);++count) if (*(globalprint+count) == '\'') *(globalprint+count) = '\b'; sprintf(systemcall,"cat %s | fix-kbest-rule-learn \'%s\' %s > aanewmynewtagggs", argv[2],globalprint,argv[4]); system(systemcall); for (count=0;count<strlen(globalprint);++count) if (*(globalprint+count) == '\b') *(globalprint+count) = '\''; sprintf(systemcall,"mv aanewmynewtagggs %s",argv[2]); system(systemcall); correct_out = fopen(argv[3],"a"); fprintf(correct_out,"%s\n",globalprint); /* fprintf(correct_out,"%d %s %s\n",globalbest,globalprint,globaldif);*/ fclose(correct_out); CONTINUE = globalbest; for (count=0;count<Darray_len(guess_tag_corpus);++count) if (strcmp((tempstr=(char *)Darray_get(guess_tag_corpus,count)),"STAART") != 0) free(tempstr); Darray_destroy(guess_tag_corpus); for (count=0;count<Darray_len(errorlist);++count) free((char *)Darray_get(errorlist,count)); Darray_destroy(errorlist); } return 0; }
int main(int argc, char *argv[]) { time_t delay = 0; aConfItem* aconf; if(geteuid() == 0) { fprintf(stderr, "ERROR: Don't run ircd as root!\n"); return -1; } /* * save server boot time right away, so getrusage works correctly */ if ((CurrentTime = time(0)) == -1) { fprintf(stderr, "ERROR: Clock Failure: %s\n", strerror(errno)); exit(errno); } /* * Setup corefile size immediately after boot */ setup_corefile(); /* * set initialVMTop before we allocate any memory */ initialVMTop = get_vm_top(); /* * Initialize the Blockheap allocator */ initBlockHeap(); ServerRunning = 0; memset(&me, 0, sizeof(me)); GlobalClientList = &me; /* Pointer to beginning of Client list */ cold_start = YES; /* set when server first starts up */ memset(&Count, 0, sizeof(Count)); Count.server = 1; /* us */ initialize_global_set_options(); #ifdef REJECT_HOLD reject_held_fds = 0; #endif ConfigFileEntry.dpath = DPATH; ConfigFileEntry.configfile = CPATH; /* Server configuration file */ #ifdef KPATH ConfigFileEntry.klinefile = KPATH; /* Server kline file */ #else ConfigFileEntry.klinefile = CPATH; #endif /* KPATH */ #ifdef DLPATH ConfigFileEntry.dlinefile = DLPATH; #else ConfigFileEntry.dlinefile = CPATH; #endif /* DLPATH */ #ifdef GLINES ConfigFileEntry.glinefile = GLINEFILE; #endif #ifdef ZIP_LINKS /* Make sure the include files match the library version number. */ /* configure takes care of looking for zlib and zlibVersion(). */ if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) { fprintf(stderr, "WARNING: zlib include files differ from library.\n"); fprintf(stderr, "WARNING: ZIPLINKS may fail!\n"); fprintf(stderr, "WARNING: library %s, include files %s\n", zlibVersion(), ZLIB_VERSION); } #endif myargv = argv; umask(077); /* better safe than sorry --SRB */ parse_command_line(argc, argv); if (chdir(ConfigFileEntry.dpath)) { perror("chdir"); exit(-1); } /* * Check if daemon is already running */ check_pidfile(); init_sys(bootDaemon); init_log(logFileName); setup_signals(); initialize_message_files(); isupport = make_isupport(); dbuf_init(); /* set up some dbuf stuff to control paging */ init_hash(); clear_scache_hash_table(); /* server cache name table */ clear_ip_hash_table(); /* client host ip hash table */ clear_Dline_table(); /* d line tree */ initlists(); initclass(); initwhowas(); init_stats(); init_tree_parse(msgtab); /* tree parse code (orabidoo) */ fdlist_init(); init_netio(); read_conf_files(YES); /* cold start init conf files */ aconf = find_me(); if (EmptyString(me.name)) strncpy_irc(me.name, aconf->host, HOSTLEN); strncpy_irc(me.host, aconf->host, HOSTLEN); me.fd = -1; me.from = &me; me.servptr = &me; SetMe(&me); make_server(&me); me.serv->up = me.name; me.lasttime = me.since = me.firsttime = CurrentTime; add_to_client_hash_table(me.name, &me); check_class(); write_pidfile(); log(L_NOTICE, "Server Ready"); ServerRunning = 1; while (ServerRunning) { usleep(100000); do_adns_io(); delay = io_loop(delay); do_adns_io(); } return 0; }
int cmd_describe(int argc, const char **argv, const char *prefix) { int contains = 0; struct option options[] = { OPT_BOOLEAN(0, "contains", &contains, N_("find the tag that comes after the commit")), OPT_BOOLEAN(0, "debug", &debug, N_("debug search strategy on stderr")), OPT_BOOLEAN(0, "all", &all, N_("use any ref")), OPT_BOOLEAN(0, "tags", &tags, N_("use any tag, even unannotated")), OPT_BOOLEAN(0, "long", &longformat, N_("always use long format")), OPT__ABBREV(&abbrev), OPT_SET_INT(0, "exact-match", &max_candidates, N_("only output exact matches"), 0), OPT_INTEGER(0, "candidates", &max_candidates, N_("consider <n> most recent tags (default: 10)")), OPT_STRING(0, "match", &pattern, N_("pattern"), N_("only consider tags matching <pattern>")), OPT_BOOLEAN(0, "always", &always, N_("show abbreviated commit object as fallback")), {OPTION_STRING, 0, "dirty", &dirty, N_("mark"), N_("append <mark> on dirty working tree (default: \"-dirty\")"), PARSE_OPT_OPTARG, NULL, (intptr_t) "-dirty"}, OPT_END(), }; git_config(git_default_config, NULL); argc = parse_options(argc, argv, prefix, options, describe_usage, 0); if (abbrev < 0) abbrev = DEFAULT_ABBREV; if (max_candidates < 0) max_candidates = 0; else if (max_candidates > MAX_TAGS) max_candidates = MAX_TAGS; save_commit_buffer = 0; if (longformat && abbrev == 0) die(_("--long is incompatible with --abbrev=0")); if (contains) { const char **args = xmalloc((7 + argc) * sizeof(char *)); int i = 0; args[i++] = "name-rev"; args[i++] = "--name-only"; args[i++] = "--no-undefined"; if (always) args[i++] = "--always"; if (!all) { args[i++] = "--tags"; if (pattern) { char *s = xmalloc(strlen("--refs=refs/tags/") + strlen(pattern) + 1); sprintf(s, "--refs=refs/tags/%s", pattern); args[i++] = s; } } memcpy(args + i, argv, argc * sizeof(char *)); args[i + argc] = NULL; return cmd_name_rev(i + argc, args, prefix); } init_hash(&names); for_each_rawref(get_name, NULL); if (!names.nr && !always) die(_("No names found, cannot describe anything.")); if (argc == 0) { if (dirty) { static struct lock_file index_lock; int fd; read_cache_preload(NULL); refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, NULL, NULL, NULL); fd = hold_locked_index(&index_lock, 0); if (0 <= fd) update_index_if_able(&the_index, &index_lock); if (!cmd_diff_index(ARRAY_SIZE(diff_index_args) - 1, diff_index_args, prefix)) dirty = NULL; } describe("HEAD", 1); } else if (dirty) { die(_("--dirty is incompatible with committishes")); } else { while (argc-- > 0) { describe(*argv++, argc == 0); } } return 0; }