static int u_get_name(char **name, const char *u_name) { /* Valid for PPC, but why is strnlen_user() defined differently from the strnlen() library call? This one includes the \0 at the end. */ int len = strnlen_user(u_name, DPM_NAME_SIZE); int ret; if (len > DPM_NAME_SIZE) { trace("Name too long\n"); return -EINVAL; } if (!(*name = (char *) kmalloc(len, GFP_KERNEL))) { trace("No memory\n"); return -ENOMEM; } if (copy_from_user(*name, u_name, len)) { trace("u_get_name fault\n"); ret = -EFAULT; goto free_name; } if (check_name(*name)) { trace("name doesn't check out\n"); ret = EINVAL; goto free_name; } return 0; free_name: free_name(*name); return ret; }
static void free_names(char **names, int n) { while (n) free_name(names[--n]); kfree(names); }
void name_gather (void) { /* Buffer able to hold a single name. */ static struct name *buffer = NULL; struct name_elt *ep; if (same_order_option) { static int change_dir; while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR) change_dir = chdir_arg (xstrdup (ep->v.name)); if (ep) { free_name (buffer); buffer = make_name (ep->v.name); buffer->change_dir = change_dir; buffer->next = 0; buffer->found_count = 0; buffer->matching_flags = matching_flags; buffer->directory = NULL; buffer->parent = NULL; buffer->cmdline = true; namelist = nametail = buffer; } else if (change_dir) addname (0, change_dir, false, NULL); } else { /* Non sorted names -- read them all in. */ int change_dir = 0; for (;;) { int change_dir0 = change_dir; while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR) change_dir = chdir_arg (xstrdup (ep->v.name)); if (ep) addname (ep->v.name, change_dir, true, NULL); else { if (change_dir != change_dir0) addname (NULL, change_dir, false, NULL); break; } } } }
static void delsmopts(char *name) { struct smopts_s *sp; struct smopts_s **last_link; last_link = &smoptstbl[hashcase(name)]; for (sp = *last_link; sp; sp = sp->s_link) { if (strcasecmp(sp->s_name, name) == 0) { *last_link = sp->s_link; free_name(sp->s_smopts); free(sp); } } }
static int u_dpm_create_class(const char *u_name, char **u_op_names, unsigned nops) { int ret; char *name; char **op_names; if ((ret = u_get_name(&name, u_name))) return ret; if ((ret = u_get_names(&op_names, u_op_names, nops))) goto free_name; ret = dpm_create_class(name, op_names, nops); free_names(op_names, nops); free_name: free_name(name); return ret; }
static int u_dpm_create_policy(const char *u_name, char **u_class_names) { int ret; char *name; char **class_names; trace("u_dpm_create_policy"); if ((ret = u_get_name(&name, u_name))) return ret; if ((ret = u_get_names(&class_names, u_class_names, DPM_STATES))) goto free_name; ret = dpm_create_policy(name, class_names); free_names(class_names, DPM_STATES); free_name: free_name(name); return ret; }
static int u_dpm_get_opt_stats(char *u_name, struct dpm_param *params) { int ret; struct dpm_stats stats, *p; char *name; if ((ret = u_get_name(&name, u_name))) return ret; if ((ret = dpm_get_opt_stats(name, &stats))) goto out; if (copy_from_user(&p, ¶ms->stats, sizeof (struct dpm_stats *)) || copy_to_user(p, &stats, sizeof (struct dpm_stats))) { ret = -EFAULT; } out: free_name(name); return ret; }
static int u_dpm_create_opt(const char *u_name, const dpm_md_pp_t * u_md_pp) { int ret; char *name; dpm_md_pp_t *md_pp; if ((ret = u_get_name(&name, u_name))) return ret; ret = -ENOMEM; if (!(md_pp = kmalloc(DPM_PP_SIZE, GFP_KERNEL))) goto free_name; ret = -EFAULT; if (copy_from_user(md_pp, u_md_pp, DPM_PP_SIZE)) goto free_all; ret = dpm_create_opt(name, md_pp); free_all: kfree(md_pp); free_name: free_name(name); return ret; }
void collect_and_sort_names (void) { struct name *name; struct name *next_name, *prev_name; int num_names; struct stat statbuf; Hash_table *nametab; name_gather (); if (!namelist) addname (".", 0, false, NULL); if (listed_incremental_option) { switch (chdir_count ()) { case 0: break; case 1: if (namelist->change_dir == 0) USAGE_ERROR ((0, 0, _("Using -C option inside file list is not " "allowed with --listed-incremental"))); break; default: USAGE_ERROR ((0, 0, _("Only one -C option is allowed with " "--listed-incremental"))); } read_directory_file (); } num_names = 0; for (name = namelist; name; name = name->next, num_names++) { if (name->found_count || name->directory) continue; if (name->matching_flags & EXCLUDE_WILDCARDS) /* NOTE: EXCLUDE_ANCHORED is not relevant here */ /* FIXME: just skip regexps for now */ continue; chdir_do (name->change_dir); if (name->name[0] == 0) continue; if (deref_stat (dereference_option, name->name, &statbuf) != 0) { stat_diag (name->name); continue; } if (S_ISDIR (statbuf.st_mode)) { name->found_count++; add_hierarchy_to_namelist (name, statbuf.st_dev, true); } } namelist = merge_sort (namelist, num_names, compare_names); num_names = 0; nametab = hash_initialize (0, 0, name_hash, name_compare, NULL); for (name = namelist; name; name = next_name) { next_name = name->next; name->caname = normalize_filename (name->name); if (prev_name) { struct name *p = hash_lookup (nametab, name); if (p) { /* Keep the one listed in the command line */ if (!name->parent) { if (p->child) rebase_child_list (p->child, name); /* FIXME: remove_directory (p->caname); ? */ remname (p); free_name (p); num_names--; } else { if (name->child) rebase_child_list (name->child, p); /* FIXME: remove_directory (name->caname); ? */ remname (name); free_name (name); continue; } } } name->found_count = 0; if (!hash_insert (nametab, name)) xalloc_die (); prev_name = name; num_names++; } nametail = prev_name; hash_free (nametab); namelist = merge_sort (namelist, num_names, compare_names_found); if (listed_incremental_option) { for (name = namelist; name && name->name[0] == 0; name++) ; if (name) append_incremental_renames (name->directory); } }
main(int argc, char **argv) { int i, j, k, l, m, n, centro[200], len_chroseq[100]; int maxi; int num_seq; char **chrname, **repnames; int num_chro; int *counts, maxc; SEGMENT *segment; int num_segment; int *repeats, num_repeats; char name[1000], temp[1000], c; double id; FILE *fp; readpar(); initenv(argc, argv); /* Input chromsomal information */ chrname = alloc_name(100, 100); fp = ckopen(lenfile, "r"); num_chro = read_chro_centro(chrname, len_chroseq, centro, fp); fclose(fp); nchro = findgenname(chriname, chrname, num_chro); /* input segments */ segment = (SEGMENT *) ckalloc(60000 * sizeof(SEGMENT)); fp = stdin; num_segment = input_segment(segment, chrname, num_chro, fp); /* sort the segments */ /* qsort((void *) segment, num_segment, sizeof(SEGMENT), (void *) segcompar); */ /* Define repeats from sub-repeats */ repeats = (int *) ckalloc(num_segment * sizeof(int)); num_repeats = 0; counts = (int *) ckalloc(10000 * num_segment * sizeof(int)); n = m = 0; j = 0; for(i = 0; i < num_segment; i ++) { if(i == num_segment - 1 || segment[i + 1].pos[0] > segment[i].pos[1] + min_length || segment[i + 1].chro != segment[i].chro) { repeats[num_repeats ++] = i; if(segment[i].chro == nchro) j ++; } if(segment[i].pos[1] - segment[i].pos[0] < min_length) continue; counts[segment[i].eq_pos[0]] ++; if(segment[i].eq_pos[0] > n) n = segment[i].eq_pos[0]; } m += n; k = maxc = 0; for(i = 0; i < m; i ++) { if(counts[i] > 1) k ++; if(counts[i] > maxc) { maxi = i; maxc = counts[i]; } } printf("m %d k %d\n", m, k); printf("%d repeats (%s %d) %d subrepeats %d max_multip subrepeats index %d.\n", num_repeats, chriname, j, k, maxc, maxi); free((void *) counts); chrname = free_name(chrname, 100); free((void *) repeats); free((void *) segment); }
main(int argc, char **argv) { int i, j, k, l, m, n; int dist[20]; int reads; int num_vertex, num_class, num_edge; int *len_seq, num_seq, num_remain; int **num_pa; char **src_seq, **src_name; char temp[100]; ALIGN **eq_class, *align; EDGE **edge, *edge1, *edge2, *bal_edge1, *bal_edge2; PATH *path; int num_path; NODES **vertex, *begin, *node, *node_next, **start_node; LIST **list; READINTERVAL *readinterval; POSITION *position; FILE *fp, *fp1; readpar(); random1(&idum); initenv(argc, argv); printf("%d %d %d\n", sizeof(POSITION), sizeof(NODES), sizeof(LIST)); /* Input the length of the genome (required) */ len_seq = (int *) ckalloc(2 * MAX_NUM * sizeof(int)); src_name = alloc_name(MAX_NUM, 100); fp = ckopen(lenfile, "r"); num_seq = readlen(fp, len_seq, src_name); fclose(fp); src_seq = (char **) ckalloc(2 * num_seq * sizeof(char *)); l = 0; printf("Genome length: "); for(i = 0; i < num_seq; i ++) { l += len_seq[i]; printf("%d ", len_seq[i]); } printf("\n"); printf("Total length: %d\n", l); /* Make reverse complements of input sequences rev(i) --> i + num_seq */ for(i = 0; i < num_seq; i ++) { len_seq[i + num_seq] = len_seq[i]; src_seq[i] = (char *) ckalloc(len_seq[i] * sizeof(char)); src_seq[i + num_seq] = (char *) ckalloc(len_seq[i] * sizeof(char)); for(j = 0; j < len_seq[i]; j ++) { src_seq[num_seq + i][j] = rev(src_seq[i][len_seq[i] - j - 1]); } } /* Input equivalent readintervales between reads -- see the format of the equivalent readinterval files */ printf("Read equivalent readintervales...\n"); eq_class = (ALIGN **) ckalloc(2 * num_seq * sizeof(ALIGN *)); fp = ckopen(inpfile, "r"); num_class = readclass(eq_class, num_seq, fp); fclose(fp); printf("# equivalent readintervales input: %d\n", num_class); /* for(i = 0; i < 2 * num_seq; i ++) { align = eq_class[i]; while(align) { printf("See: \n"); output_align(align, src_name, src_seq, len_seq, num_seq); getchar(); align = align -> next; } } */ /* Initialize the nodes: each position in each read is assigned as a new node. An array of "list" is set up for each read */ list = (LIST **) ckalloc(2 * num_seq * sizeof(LIST *)); for(i = 0; i < 2 * num_seq; i ++) { list[i] = (LIST *) ckalloc(len_seq[i] * sizeof(LIST)); } printf("intitialize nodes...\n"); initialize(list, len_seq, num_seq); printf("done.\n"); n = countnode(list, len_seq, 2 * num_seq); printf("# of nodes before merge: %d\n", n); /* Glue together two nodes if their corresponding positions are defined as equivalent in a pairwise alignment */ printf("Merge...\n"); merge(num_seq, len_seq, eq_class, num_class, list); printf("done.\n"); for(i = 0; i < num_seq; i ++) { while(eq_class[i]) { eq_class[i] = free_align(eq_class[i]); } } free((void **) eq_class); /* Compute the width of each node */ for(i = 0; i < 2 * num_seq; i ++) { for(j = 0; j < len_seq[i]; j ++) { if(!list[i][j].node -> visit) { list[i][j].node -> num_path = countthickness(list[i][j].node); list[i][j].node -> visit = 1; } } } cleannode(list, len_seq, 2 * num_seq); n = countnode(list, len_seq, 2 * num_seq); printf("# of nodes after merge: %d\n", n); /* Add edges to the graph */ edge = (EDGE **) ckalloc(n * sizeof(EDGE *)); num_edge = graph(num_seq, len_seq, list, edge); printf("# edges: %d\n", num_edge); start_node = (NODES **) ckalloc(num_seq * sizeof(NODES *)); for(i = 0; i < num_seq; i ++) { if(len_seq[i] > 0) { start_node[i] = list[i][0].node; } else { start_node[i] = (NODES *) NULL; } } for(i = 0; i < 2 * num_seq; i ++) { free((void *) list[i]); } free((void **) list); vertex = (NODES **) ckalloc(2 * num_edge * sizeof(NODES *)); num_vertex = count_vertex(edge, num_edge, vertex); free((void **) edge); num_pa = (int **) ckalloc(MAX_BRA * sizeof(int *)); for(i = 0; i < MAX_BRA; i ++) { num_pa[i] = (int *) ckalloc(MAX_BRA * sizeof(int)); } num_edge = count_edge_simp(vertex, num_vertex, num_pa); printf("%d vertices %d edges (%d source %d sinks) remained.\n", num_vertex, num_edge, num_pa[0][1], num_pa[1][0]); /* Assign the complementary edges of each edge */ for(i = 0; i < num_vertex; i ++) { for(j = 0; j < vertex[i] -> num_nextedge; j ++) { edge1 = vertex[i] -> nextedge[j]; edge1 -> bal_edge = find_bal_edge(edge1, len_seq, num_seq, i); } } /* Remove bulges in the graph */ printf("Shave...\n"); num_vertex = shave_graph(vertex, num_vertex); printf("done.\n"); /* Remove cycles shorter than some threshold in the graph */ /* printf("Shaving graph...\n"); num_vertex = rem_cycle(vertex, num_vertex); printf("done.\n%d vertices remained.\n", num_vertex); */ /* remove short edges */ /* printf("Remove shortedges...\n"); num_vertex = rem_short_edge(vertex, num_vertex, len_seq); printf("done.\n%d vertices remained.\n", num_vertex); fflush(stdout); */ num_edge = count_edge_simp(vertex, num_vertex, num_pa); printf("%d vertices %d edges (%d source %d sinks) remained.\n", num_vertex, num_edge, num_pa[0][1], num_pa[1][0]); fflush(stdout); /* Allocate the spaces for paths */ printf("Allocating paths...\n"); for(i = 0; i < num_vertex; i ++) { vertex[i] -> num_path = 0; } /* Build sequence paths */ printf("Define paths...\n"); m = 0; for(i = 0; i < num_vertex; i ++) { for(j = 0; j < vertex[i] -> num_nextedge; j ++) { m += vertex[i] -> nextedge[j] -> multip; } } path = (PATH *) ckalloc(2 * num_seq * sizeof(PATH)); for(i = 0; i < 2 * num_seq; i ++) { path[i].edge = (EDGE **) ckalloc(m * sizeof(EDGE *)); } num_path = readpath(start_node, path, num_seq); free((void **) start_node); num_edge = count_edge_simp(vertex, num_vertex, num_pa); m = l = 0; for(i = 0; i < num_vertex; i ++) { for(j = 0; j < vertex[i] -> num_nextedge; j ++) { l += vertex[i] -> nextedge[j] -> length; if(vertex[i] -> nextedge[j] -> length > m) { m = vertex[i] -> nextedge[j] -> length; } } } printf("%d vertics %d edges (%d source %d sinks) remained: total length %d (maximal %d).\n", num_vertex, num_edge, num_pa[0][1], num_pa[1][0], l, m); fflush(stdout); /* Make consensus of edges */ initial_edge(vertex, num_vertex, src_seq, num_seq); printf("edge initialed\n"); /* Output sequence path */ n = 0; for(i = 0; i < num_vertex; i ++) { vertex[i] -> visit = i; for(j = 0; j < vertex[i] -> num_nextedge; j ++) { vertex[i] -> nextedge[j] -> start_cover = n; n ++; } } for(m = 0; m < num_seq; m ++) { printf("len_path %d\n", path[m].len_path); printf("Sequence%d: ", m + 1); for(i = 0; i < path[m].len_path; i ++) { printf("%d -- %d(%d,%d) --> ", path[m].edge[i] -> begin -> visit, path[m].edge[i] -> start_cover, path[m].edge[i] -> multip, path[m].edge[i] -> length); if(i % 5 == 4) { printf("\n"); } } if(path[m].len_path > 0) { printf("%d\n", path[m].edge[i - 1] -> end -> visit); } else { printf("\n"); } fflush(stdout); } /* Output graph & contigs */ sprintf(temp, "%s.edge", seqfile); fp = ckopen(temp, "w"); sprintf(temp, "%s.graph", seqfile); fp1 = ckopen(temp, "w"); write_graph(vertex, num_vertex, fp, fp1); fclose(fp); fclose(fp1); /* Output read intervals in each edge */ sprintf(temp, "%s.intv", seqfile); fp = ckopen(temp, "w"); write_interval(vertex, num_vertex, fp); fclose(fp); /* Output graphviz format graph */ sprintf(temp, "%s", outfile); fp = ckopen(temp, "w"); output_graph(vertex, num_vertex, fp); fclose(fp); for(i = 0; i < MAX_BRA; i ++) { free((void *) num_pa[i]); } free((void **) num_pa); for(i = 0; i < 2 * num_seq; i ++) { if(path[i].len_path > 0) { free((void **) path[i].edge); } } free((void *) path); free_graph(vertex, num_vertex); for(i = 0; i < 2 * num_seq; i ++) { free((void *) src_seq[i]); } free((void **) src_seq); free_name(src_name, MAX_NUM); free((void *) len_seq); }
main(int argc, char **argv) { int i, j, k, l, m, n, len_seq[100], reallen[100]; char **chrname; int *dir, **breaks, **colorindex, base[2]; char **brchrname; int *multip, *multip2, *repeat_length, num_repeat, *startpos, *numsegment; int num_ins, *insertpos, *insertlen; int global_scale; SEGMENT *segment, segment0; long int START_POS; int num_segment; int **repeats; int range[2]; int num_chro; char name[1000], temp[1000], c; char pt; FILE *fp, *fp1; if(argc < 4) { printf("Usage: makefig intv_file output_file(ps format) chrolistfile\n"); exit(-1); } chrname = alloc_name(100, 100); fp = ckopen(argv[3], "r"); num_chro = readchrolist(len_seq, chrname, reallen, fp); fclose(fp); segment = (SEGMENT *) ckalloc(20000 * sizeof(SEGMENT)); fp = ckopen(argv[1], "r"); num_segment = input_segment(segment, chrname, num_chro, fp); fclose(fp); /* Sort the segments */ qsort((void *) segment, num_segment, sizeof(SEGMENT), (void *) segcompar); /* for(i = 0; i < num_segment; i ++) { printf("aftersort segment %d %d %d\n", segment[i].pos[0], segment[i].pos[1], segment[i].eq_pos[1]); } getchar(); */ /* Compute multiplicity of each sub-repeat */ repeat_length = (int *) ckalloc(20000 * sizeof(int)); multip = (int *) ckalloc(20000 * sizeof(int)); num_repeat = 0; k = 0; for(i = 0; i < num_segment; i ++) { repeat_length[segment[i].eq_pos[0] - 1] = segment[i].length; multip[segment[i].eq_pos[0] - 1] ++; if(segment[i].eq_pos[0] > num_repeat) { num_repeat = segment[i].eq_pos[0]; } } printf("num_repeat %d\n", num_repeat); global_scale = 25; multip2 = (int *) ckalloc(num_repeat * sizeof(int)); repeats = (int **) ckalloc(num_repeat * sizeof(int *)); for(i = 0; i < num_repeat; i ++) { repeats[i] = (int *) ckalloc((1 + multip[i]) * sizeof(int)); } startpos = (int *) ckalloc(num_segment * sizeof(int)); numsegment = (int *) ckalloc(num_segment * sizeof(int)); breaks = (int **) ckalloc(num_segment * sizeof(int *)); brchrname = (char **) ckalloc(num_segment * sizeof(char *)); colorindex = (int **) ckalloc(num_segment * sizeof(int *)); for(i = 0; i < num_segment; i ++) { breaks[i] = (int *) ckalloc(num_segment * sizeof(int)); brchrname[i] = (char *) ckalloc(100 * sizeof(char)); colorindex[i] = (int *) ckalloc(num_segment * sizeof(int)); } dir = (int *) ckalloc(num_segment * sizeof(int)); k = m = 0; fp = ckopen(argv[2], "w"); prt_Header(fp, "Tang Hai-xu", "OUTPUT", "2-21-2004", 0); prt_Macro(fp); scale[0] = 0.7; scale[1] = 0.8; change_scale(fp, scale); base[0] = 50; base[1] = 850; for(i = 0; i < num_segment; i ++) { if(i == num_segment - 1 || segment[i + 1].pos[0] > segment[i].pos[1] + min_length || segment[i + 1].chro != segment[i].chro) { for(j = k; j <= i; j ++) { breaks[m][j - k + 1] += segment[j].pos[1] - segment[k].pos[0] + 1; colorindex[m][j - k] = segment[j].eq_pos[0]; dir[j - k] = segment[j].eq_pos[1]; repeats[segment[j].eq_pos[0] - 1][multip2[segment[j].eq_pos[0] - 1] ++] = m; } startpos[m] = range[0] = segment[k].pos[0]; numsegment[m] = i - k + 1; strcpy(brchrname[m], chrname[segment[i].chro]); range[1] = segment[i].pos[1]; sprintf(name, "R%d", m + 1); l = output_region(fp, base, name, chrname[segment[k].chro], range, global_scale, breaks[m], i - k + 2, colorindex[m], dir); m ++; base[0] = 50; base[1] -= 25; if(base[1] < 150) { showpage(fp); fprintf(fp, "%%%%Page: P%d\n", npages); npages ++; change_scale(fp, scale); base[0] = 50; base[1] = 850; } k = i + 1; } } showpage(fp); fprintf(fp, "%%%%Page: P%d\n", npages); npages ++; change_scale(fp, scale); fflush(fp); for(i = 0; i < num_repeat; i ++) { if(multip[i] != multip2[i]) { printf("i %d multip %d %d\n", i, multip[i], multip2[i]); exit(0); } } output_length_legend(fp); output_legend(fp, repeat_length, multip, num_repeat, repeats); showpage(fp); fprintf(fp, "%%%%Page: P%d\n", npages); npages ++; change_scale(fp, scale); output_repeat_legend(fp, startpos, breaks, numsegment, colorindex, brchrname, m); showpage(fp); page_trailer(fp); restore_scale(fp); prt_Trailer(fp, k + 1); fclose(fp); printf("%d regions output.\n", m); chrname = free_name(chrname, 100); for(i = 0; i < num_repeat; i ++) { free((void *) repeats[i]); } free((void **) repeats); free((void *) repeat_length); for(i = 0; i < num_segment; i ++) { free((void *) brchrname[i]); free((void *) breaks[i]); free((void *) colorindex[i]); } free((void *) multip); free((void *) multip2); free((void **) brchrname); free((void **) breaks); free((void **) colorindex); free((void *) startpos); free((void *) numsegment); free((void *) dir); free((void *) segment); }
GangWorker::~GangWorker() { free_name(); }