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();
}
