static void show_run(const struct run *run) { max_line_length = Page_Width / 2 - 1; max_line_length_UTF8 = max_line_length * FONT_SIZE; /* The animals came in two by two ... */ const struct chunk *cnk0 = &run->rn_chunk0; const struct chunk *cnk1 = &run->rn_chunk1; size_t nl_cnt0 = cnk0->ch_last.ps_nl_cnt - cnk0->ch_first.ps_nl_cnt; size_t nl_cnt1 = cnk1->ch_last.ps_nl_cnt - cnk1->ch_first.ps_nl_cnt; FILE *f0; FILE *f1; /* display heading of chunk */ if (!is_set_option('d')) { /* no assumptions about the lengths of the file names! */ size_t size = run->rn_size; int pos = print_header(cnk0); print_spaces(max_line_length - pos); print_char('|'); pos = print_header(cnk1); print_spaces(max_line_length - pos - length_size_t(size) - 2); fprintf(Output_File, "[%s]\n", size_t2string(size)); } else { /* diff-like format */ (void)print_header(cnk0); print_char('\n'); (void)print_header(cnk1); print_char('\n'); } /* stop if that suffices */ if (is_set_option('n')) return; /* ... had enough so soon ... */ /* open the files that hold the chunks */ f0 = open_chunk(cnk0); f1 = open_chunk(cnk1); /* display the chunks in the required format */ if (!is_set_option('d')) { /* print 2-column format */ while (nl_cnt0 != 0 || nl_cnt1 != 0) { int pos_UTF8 = 0; if (nl_cnt0) { pos_UTF8 = print_UTF8_line(f0); nl_cnt0--; } print_UTF8_spaces(max_line_length_UTF8 - pos_UTF8); print_char('|'); if (nl_cnt1) { (void)print_UTF8_line(f1); nl_cnt1--; } print_char('\n'); } } else { /* display the chunks in a diff(1)-like format */ while (nl_cnt0--) { show_1C_line(f0, "<"); } (void)print_string("---\n"); while (nl_cnt1--) { show_1C_line(f1, ">"); } } /* close the pertinent files */ fclose(f0); fclose(f1); }
static void check_gt(args_t *args) { int i,ret, *gt2ipl = NULL, m_gt2ipl = 0, *gt_arr = NULL, ngt_arr = 0; int fake_pls = args->no_PLs; // Initialize things: check which tags are defined in the header, sample names etc. if ( bcf_hdr_id2int(args->gt_hdr, BCF_DT_ID, "GT")<0 ) error("[E::%s] GT not present in the header of %s?\n", __func__, args->files->readers[1].fname); if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "PL")<0 ) { if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "GT")<0 ) error("[E::%s] Neither PL nor GT present in the header of %s\n", __func__, args->files->readers[0].fname); if ( !args->no_PLs ) fprintf(pysamerr,"Warning: PL not present in the header of %s, using GT instead\n", args->files->readers[0].fname); fake_pls = 1; } FILE *fp = args->plot ? open_file(NULL, "w", "%s.tab", args->plot) : stdout; print_header(args, fp); int tgt_isample = -1, query_isample = 0; if ( args->target_sample ) { tgt_isample = bcf_hdr_id2int(args->gt_hdr, BCF_DT_SAMPLE, args->target_sample); if ( tgt_isample<0 ) error("No such sample in %s: [%s]\n", args->files->readers[1].fname, args->target_sample); } if ( args->all_sites ) { if ( tgt_isample==-1 ) { fprintf(pysamerr,"No target sample selected for comparison, using the first sample in %s: %s\n", args->gt_fname,args->gt_hdr->samples[0]); tgt_isample = 0; } } if ( args->query_sample ) { query_isample = bcf_hdr_id2int(args->sm_hdr, BCF_DT_SAMPLE, args->query_sample); if ( query_isample<0 ) error("No such sample in %s: [%s]\n", args->files->readers[0].fname, args->query_sample); } if ( args->all_sites ) fprintf(fp, "# [1]SC, Site by Site Comparison\t[2]Chromosome\t[3]Position\t[4]-g alleles\t[5]-g GT (%s)\t[6]match log LK\t[7]Query alleles\t[8-]Query PLs (%s)\n", args->gt_hdr->samples[tgt_isample],args->sm_hdr->samples[query_isample]); // Main loop float prev_lk = 0; while ( (ret=bcf_sr_next_line(args->files)) ) { if ( ret!=2 ) continue; bcf1_t *sm_line = args->files->readers[0].buffer[0]; // the query file bcf1_t *gt_line = args->files->readers[1].buffer[0]; // the -g target file bcf_unpack(sm_line, BCF_UN_FMT); bcf_unpack(gt_line, BCF_UN_FMT); // Init mapping from target genotype index to the sample's PL fields int n_gt2ipl = gt_line->n_allele*(gt_line->n_allele + 1)/2; if ( n_gt2ipl > m_gt2ipl ) { m_gt2ipl = n_gt2ipl; gt2ipl = (int*) realloc(gt2ipl, sizeof(int)*m_gt2ipl); } if ( !init_gt2ipl(args, gt_line, sm_line, gt2ipl, n_gt2ipl) ) continue; // Target genotypes int ngt, npl; if ( (ngt=bcf_get_genotypes(args->gt_hdr, gt_line, >_arr, &ngt_arr)) <= 0 ) error("GT not present at %s:%d?", args->gt_hdr->id[BCF_DT_CTG][gt_line->rid].key, gt_line->pos+1); ngt /= bcf_hdr_nsamples(args->gt_hdr); if ( ngt!=2 ) continue; // checking only diploid genotypes // Sample PLs if ( !fake_pls ) { if ( (npl=bcf_get_format_int32(args->sm_hdr, sm_line, "PL", &args->pl_arr, &args->npl_arr)) <= 0 ) { if ( sm_line->n_allele==1 ) { // PL values may not be present when ALT=. (mpileup/bcftools output), in that case // switch automatically to GT at these sites npl = fake_PLs(args, args->sm_hdr, sm_line); } else error("PL not present at %s:%d?\n", args->sm_hdr->id[BCF_DT_CTG][sm_line->rid].key, sm_line->pos+1); } else npl /= bcf_hdr_nsamples(args->sm_hdr); } else npl = fake_PLs(args, args->sm_hdr, sm_line); // Calculate likelihoods for all samples, assuming diploid genotypes // For faster access to genotype likelihoods (PLs) of the query sample int max_ipl, *pl_ptr = args->pl_arr + query_isample*npl; double sum_pl = 0; // for converting PLs to probs for (max_ipl=0; max_ipl<npl; max_ipl++) { if ( pl_ptr[max_ipl]==bcf_int32_vector_end ) break; if ( pl_ptr[max_ipl]==bcf_int32_missing ) continue; sum_pl += pow(10, -0.1*pl_ptr[max_ipl]); } if ( sum_pl==0 ) continue; // no PLs present if ( fake_pls && args->no_PLs==1 ) sum_pl = -1; // The main stats: concordance of the query sample with the target -g samples for (i=0; i<bcf_hdr_nsamples(args->gt_hdr); i++) { int *gt_ptr = gt_arr + i*ngt; if ( gt_ptr[1]==bcf_int32_vector_end ) continue; // skip haploid genotypes if ( bcf_gt_is_missing(gt_ptr[0]) || bcf_gt_is_missing(gt_ptr[1]) ) continue; int a = bcf_gt_allele(gt_ptr[0]); int b = bcf_gt_allele(gt_ptr[1]); if ( args->hom_only && a!=b ) continue; // heterozygous genotype int igt_tgt = igt_tgt = bcf_alleles2gt(a,b); // genotype index in the target file int igt_qry = gt2ipl[igt_tgt]; // corresponding genotype in query file if ( igt_qry>=max_ipl || pl_ptr[igt_qry]<0 ) continue; // genotype not present in query sample: haploid or missing args->lks[i] += sum_pl<0 ? -pl_ptr[igt_qry] : log(pow(10, -0.1*pl_ptr[igt_qry])/sum_pl); args->sites[i]++; } if ( args->all_sites ) { // Print LKs at all sites for debugging int *gt_ptr = gt_arr + tgt_isample*ngt; if ( gt_ptr[1]==bcf_int32_vector_end ) continue; // skip haploid genotypes int a = bcf_gt_allele(gt_ptr[0]); int b = bcf_gt_allele(gt_ptr[1]); if ( args->hom_only && a!=b ) continue; // heterozygous genotype fprintf(fp, "SC\t%s\t%d", args->gt_hdr->id[BCF_DT_CTG][gt_line->rid].key, gt_line->pos+1); for (i=0; i<gt_line->n_allele; i++) fprintf(fp, "%c%s", i==0?'\t':',', gt_line->d.allele[i]); fprintf(fp, "\t%s/%s", a>=0 ? gt_line->d.allele[a] : ".", b>=0 ? gt_line->d.allele[b] : "."); fprintf(fp, "\t%f", args->lks[query_isample]-prev_lk); prev_lk = args->lks[query_isample]; int igt, *pl_ptr = args->pl_arr + query_isample*npl; // PLs of the query sample for (i=0; i<sm_line->n_allele; i++) fprintf(fp, "%c%s", i==0?'\t':',', sm_line->d.allele[i]); for (igt=0; igt<npl; igt++) if ( pl_ptr[igt]==bcf_int32_vector_end ) break; else if ( pl_ptr[igt]==bcf_int32_missing ) fprintf(fp, "."); else fprintf(fp, "\t%d", pl_ptr[igt]); fprintf(fp, "\n"); } } free(gt2ipl); free(gt_arr); free(args->pl_arr); free(args->tmp_arr); // To be able to plot total discordance (=number of mismatching GTs with -G1) in the same // plot as discordance per site, the latter must be scaled to the same range int nsamples = bcf_hdr_nsamples(args->gt_hdr); double extreme_lk = 0, extreme_lk_per_site = 0; for (i=0; i<nsamples; i++) { if ( args->lks[i] < extreme_lk ) extreme_lk = args->lks[i]; if ( args->sites[i] && args->lks[i]/args->sites[i] < extreme_lk_per_site ) extreme_lk_per_site = args->lks[i]/args->sites[i]; } // Sorted output double **p = (double**) malloc(sizeof(double*)*nsamples); for (i=0; i<nsamples; i++) p[i] = &args->lks[i]; qsort(p, nsamples, sizeof(int*), cmp_doubleptr); fprintf(fp, "# [1]CN\t[2]Discordance with %s (total)\t[3]Discordance (avg score per site)\t[4]Number of sites compared\t[5]Sample\t[6]Sample ID\n", args->sm_hdr->samples[query_isample]); for (i=0; i<nsamples; i++) { int idx = p[i] - args->lks; double per_site = 0; if ( args->sites[idx] ) { if ( args->sites[idx] && extreme_lk_per_site ) { per_site = args->lks[idx]/args->sites[idx]; per_site *= extreme_lk / extreme_lk_per_site; } else per_site = 0; } fprintf(fp, "CN\t%e\t%e\t%.0f\t%s\t%d\n", fabs(args->lks[idx]), fabs(per_site), args->sites[idx], args->gt_hdr->samples[idx], i); } if ( args->plot ) { fclose(fp); plot_check(args, args->target_sample ? args->target_sample : "", args->sm_hdr->samples[query_isample]); } }
/* void protocol1 * buffer* recv_buffer - buffer containing the message sent by the client to the proxy * server_stat* status - status and general information from the server * Processes the recv_buf as the class protocol dictates */ void protocol1(buffer* recv_buf, server_stat* status){ struct timeval timeout; struct timeval timeout_0; // timeouts timeout.tv_sec = 1; timeout.tv_usec = 0; timeout_0.tv_sec = 0; timeout_0.tv_usec = 0; timeout_setup(status->udp_sock, timeout); // giant mess of conditionals fprintf(stdout, "\tversion 1 protocol\n"); int error = 0; header msg_header = extract_header(recv_buf); if (status->connected == 0) { if (check_pass(&msg_header, 0)) { if (get_command(&msg_header) == CONNECT) { fprintf(stdout, "\tReplying with password\n"); status->connected = 1; msg_header.data[1] = status->password; insert_header(recv_buf, msg_header); if (udp_send(recv_buf, status) < 0) { fprintf(stderr, "sendto()\n"); } } else { fprintf(stderr, "ERROR: Unexpected Command\n"); error = -2; } } else { fprintf(stderr, "ERROR: Incorrect Password\n"); } } else if (status->connected == 1) { if (check_pass(&msg_header, status->password)) { if (get_command(&msg_header) == CONNECT) { status->connected = 2; timeout_setup(status->udp_sock, timeout_0); fprintf(stdout, "\tConnected to a client\n"); } else { fprintf(stderr, "ERROR: Unexpected Command\n"); error = -2; } } else { fprintf(stderr, "ERROR: Incorrect Password\n"); error = -2; } } else { if (!check_pass(&msg_header, status->password)) { fprintf(stderr, "ERROR: Incorrect Password\n"); error = -2; } else { fprintf(stdout, "\t\tReceived Message:\n"); print_header(recv_buf); switch (get_command(&msg_header)) { case CONNECT: fprintf(stderr, "ERROR: Unexpected Command\n"); error = -2; break; case QUIT: quit(recv_buf, status); timeout_setup(status->udp_sock, timeout_0); break; default: error = request_command(recv_buf, status); break; } } } if (error == -2) { fprintf(stderr, "ERROR: Invalid client request\n"); send_error(status, CLIENT_ERROR); } else if (error == -1) { fprintf(stderr, "ERROR: Problem with http response\n"); send_error(status, HTTP_ERROR); } }
int main(int argc, char **argv) { int rval = 0; double *x = 0; struct CG *cg = 0; struct LP lp; char *column_types = 0; rval = parse_args(argc, argv); if (rval) return 1; if (LOG_FILENAME[0]) { LOG_FILE = fopen(LOG_FILENAME, "w"); abort_if(!LOG_FILE, "could not open log file"); } print_header(argc, argv); STATS_init(); STATS_set_input_filename(PROBLEM_FILENAME); rval = LP_open(&lp); abort_if(rval, "LP_open failed"); rval = LP_create(&lp, "multirow"); abort_if(rval, "LP_create failed"); rval = LP_read_problem(&lp, PROBLEM_FILENAME); abort_if(rval, "LP_read_problem failed"); int ncols = LP_get_num_cols(&lp); int nrows = LP_get_num_rows(&lp); log_info(" %d rows, %d cols\n", nrows, ncols); x = (double *) malloc(ncols * sizeof(double)); abort_if(!x, "could not allocate x"); if (!KEEP_INTEGRALITY) { column_types = (char *) malloc(ncols * sizeof(char)); abort_if(!column_types, "could not allocate column_types"); log_info("Storing column types...\n"); rval = LP_get_column_types(&lp, column_types); abort_if(rval, "LP_get_column_types failed"); log_info("Relaxing integrality...\n"); rval = LP_relax(&lp); abort_if(rval, "LP_relax failed"); log_info("Disabling presolve...\n"); LP_disable_presolve(&lp); } if(BASIS_FILENAME[0]) { rval = LP_read_basis(&lp, BASIS_FILENAME); abort_if(rval, "LP_read_basis failed"); } log_info("Optimizing...\n"); int infeasible; rval = LP_optimize(&lp, &infeasible); abort_if(rval, "LP_optimize failed"); double obj; rval = LP_get_obj_val(&lp, &obj); abort_if(rval, "LP_get_obj_val failed"); log_info(" opt = %lf\n", obj); STATS_set_obj_value(obj); STATS_finish_round(); if(OUTPUT_BASIS_FILENAME[0]) { rval = LP_write_basis(&lp, OUTPUT_BASIS_FILENAME); abort_if(rval, "LP_write_basis failed"); } if(GENERATE_MIR || GENERATE_GREEDY) { cg = (struct CG *) malloc(sizeof(struct CG)); abort_if(!cg, "could not allocate cg"); log_info("Reading tableau rows...\n"); rval = CG_init(&lp, column_types, cg); abort_if(rval, "CG_init failed"); if (strlen(KNOWN_SOLUTION_FILENAME) > 0) { rval = LP_read_solution(&lp, KNOWN_SOLUTION_FILENAME, x); abort_if(rval, "LP_read_solution failed"); rval = CG_set_integral_solution(cg, x); abort_if(rval, "CG_set_integral_solution failed"); } rval = LP_get_x(&lp, x); abort_if(rval, "LP_get_x failed"); rval = CG_set_basic_solution(cg, x); abort_if(rval, "CG_set_basic_solution failed"); if (GENERATE_MIR) { log_info("Adding MIR cuts...\n"); rval = CG_add_single_row_cuts( cg, (SingleRowGeneratorCallback) MIR_generate_cut); abort_if(rval, "CG_add_single_row_cuts failed"); log_info("Optimizing...\n"); rval = LP_optimize(&lp, &infeasible); abort_if(rval, "LP_optimize failed"); rval = LP_get_obj_val(&lp, &obj); abort_if(rval, "LP_get_obj_val failed"); log_info(" opt = %lf\n", obj); STATS_set_obj_value(obj); STATS_finish_round(); } if (GENERATE_GREEDY) { for(int k = MIN_N_ROWS; k <= MAX_N_ROWS; k++) { log_info("Adding greedy intersection cuts (%d rows)...\n", k); rval = CG_add_multirow_cuts(cg, k, (MultirowGeneratorCallback) GREEDY_generate_cut); abort_if(rval, "CG_add_multirow_cuts failed"); } log_info("Optimizing...\n"); rval = LP_optimize(&lp, &infeasible); abort_if(rval, "LP_optimize failed"); rval = LP_get_obj_val(&lp, &obj); abort_if(rval, "LP_get_obj_val failed"); log_info(" opt = %lf\n", obj); STATS_set_obj_value(obj); STATS_finish_round(); } CG_free(cg); } if(OUTPUT_SOLUTION_FILENAME[0]) { rval = LP_write_solution(&lp, OUTPUT_SOLUTION_FILENAME); abort_if(rval, "LP_write_solution failed"); } if(STATS_FILENAME[0]) { log_info("Writing stats to file %s...\n", STATS_FILENAME); rval = STATS_print_yaml(STATS_FILENAME); abort_if(rval, "STATS_print_yaml failed"); } CLEANUP: if (LOG_FILE) fclose(LOG_FILE); if (x) free(x); if (column_types) free(column_types); LP_free(&lp); return rval; }
int main(int argc, char **argv) { char id[7]; int32_t l; uint16_t s; int verbose = 0; int32_t offset; int foundnullsegment = 0; int version; int32_t segmentcontentlength = 0; int nsegments = 0; int32_t headerlength = 0; int32_t objectlength = 0; printf("RDOFF dump utility, version %s\n", PROGRAM_VERSION); printf("RDOFF2 revision %s\n", RDOFF2_REVISION); puts("Copyright (c) 1996,99 Julian R Hall\n" "Improvements and fixes (c) 2002-2004 RET & COM Research."); if (argc < 2) { fputs("Usage: rdfdump [-v] <filename>\n", stderr); exit(1); } rdoff_init(); if (!strcmp(argv[1], "-v")) { verbose = 1; if (argc < 3) { fputs("required parameter missing\n", stderr); exit(1); } argv++; } infile = fopen(argv[1], "rb"); if (!infile) { fprintf(stderr, "rdfdump: Could not open %s\n", argv[1]); exit(1); } nasm_read(id, 6, infile); if (strncmp(id, "RDOFF", 5)) { fputs("rdfdump: File does not contain valid RDOFF header\n", stderr); exit(1); } printf("File %s: RDOFF version %c\n\n", argv[1], id[5]); if (id[5] < '1' || id[5] > '2') { fprintf(stderr, "rdfdump: unknown RDOFF version '%c'\n", id[5]); exit(1); } version = id[5] - '0'; if (version > 1) { nasm_read(&l, 4, infile); objectlength = translateint32_t(l); printf("Object content size: %"PRId32" bytes\n", objectlength); } nasm_read(&l, 4, infile); headerlength = translateint32_t(l); printf("Header (%"PRId32" bytes):\n", headerlength); print_header(headerlength, version); if (version == 1) { nasm_read(&l, 4, infile); l = translateint32_t(l); printf("\nText segment length = %"PRId32" bytes\n", l); offset = 0; while (l--) { nasm_read(id, 1, infile); if (verbose) { if (offset % 16 == 0) printf("\n%08"PRIx32" ", offset); printf(" %02x", (int)(uint8_t)id[0]); offset++; } } if (verbose) printf("\n\n"); nasm_read(&l, 4, infile); l = translateint32_t(l); printf("Data segment length = %"PRId32" bytes\n", l); if (verbose) { offset = 0; while (l--) { nasm_read(id, 1, infile); if (offset % 16 == 0) printf("\n%08"PRIx32" ", offset); printf(" %02x", (int)(uint8_t)id[0]); offset++; } printf("\n"); } } else { do { nasm_read(&s, 2, infile); s = translateint16_t(s); if (!s) { printf("\nNULL segment\n"); foundnullsegment = 1; break; } printf("\nSegment:\n Type = %04X (%s)\n", (int)s, translatesegmenttype(s)); nsegments++; nasm_read(&s, 2, infile); printf(" Number = %04X\n", (int)translateint16_t(s)); nasm_read(&s, 2, infile); printf(" Resrvd = %04X\n", (int)translateint16_t(s)); nasm_read(&l, 4, infile); l = translateint32_t(l); printf(" Length = %"PRId32" bytes\n", l); segmentcontentlength += l; offset = 0; while (l--) { nasm_read(id, 1, infile); if (verbose) { if (offset % 16 == 0) printf("\n%08"PRIx32" ", offset); printf(" %02x", (int)(uint8_t)id[0]); offset++; } } if (verbose) printf("\n"); } while (!feof(infile)); if (!foundnullsegment) printf("\nWarning: unexpected end of file - " "NULL segment not found\n"); printf("\nTotal number of segments: %d\n", nsegments); printf("Total segment content length: %"PRId32" bytes\n", segmentcontentlength); /* calculate what the total object content length should have been */ l = segmentcontentlength + 10 * (nsegments + 1) + headerlength + 4; if (l != objectlength) printf("Warning: actual object length (%"PRId32") != " "stored object length (%"PRId32")\n", l, objectlength); } fclose(infile); return 0; }
void line_break(void) { int *d, ch; int spg = 1, rspg = 1, spgs = 0, gap = 0; if (line_ptr == 0) return; if (current_line == 0) print_header(); if (page_length > 12 && current_line + pending_nl > page_length - 6) { print_footer(); print_header(); } if (current_line) current_line += 1 + pending_nl; for (; pending_nl > 0; pending_nl--) fprintf(ofd, "\n"); if (right_adjust < 0) { int over = right_margin - left_indent - (line_ptr - line); #ifdef SPLATTER fprintf(ofd, ">Gaps=%d, Over=%d, ", gaps_on_line, over); #endif if (gaps_on_line && over) { spg = rspg = 1 + over / gaps_on_line; over = over % gaps_on_line; if (over) { if (current_line % 2) { spgs = over; spg++; } else { spgs = gaps_on_line - over; rspg++; } } } #ifdef SPLATTER fprintf(ofd, " (%d,%d) sw=%d\n", spg, rspg, spgs); #endif right_adjust = 1; } *line_ptr = 0; if (*line) for (ch = left_indent; ch > 0; ch--) fputc(' ', ofd); for (d = line; *d; d++) { ch = *d; if ((ch & 0xFF) == 0) { int i; if (gap++ < spgs) i = spg; else i = rspg; for (; i > 0; i--) fputc(' ', ofd); } else switch (ch >> 8) { case 2: fputc(ch & 0xFF, ofd); fputc('\b', ofd); fputc(ch & 0xFF, ofd); break; case 3: fputc('_', ofd); fputc('\b', ofd); fputc(ch & 0xFF, ofd); break; default: fputc(ch & 0xFF, ofd); break; } } fputc('\n', ofd); line_ptr = 0; if (next_line_indent > 0) left_indent = next_line_indent; next_line_indent = -1; gaps_on_line = 0; }
int main(int argc, char *argv[]) { const char *filename = NULL; const char *ufile = NULL; int error = 0; int c, fd, ufd; ctf_data_t cd; const ctf_preamble_t *pp; ctf_header_t *hp; Elf *elf; GElf_Ehdr ehdr; (void) elf_version(EV_CURRENT); for (opterr = 0; optind < argc; optind++) { while ((c = getopt(argc, argv, "dfhlsStu:")) != (int)EOF) { switch (c) { case 'd': flags |= F_DATA; break; case 'f': flags |= F_FUNC; break; case 'h': flags |= F_HDR; break; case 'l': flags |= F_LABEL; break; case 's': flags |= F_STR; break; case 'S': flags |= F_STATS; break; case 't': flags |= F_TYPES; break; case 'u': ufile = optarg; break; default: if (optopt == '?') return (print_usage(stdout, 1)); warn("illegal option -- %c\n", optopt); return (print_usage(stderr, 0)); } } if (optind < argc) { if (filename != NULL) return (print_usage(stderr, 0)); filename = argv[optind]; } } if (filename == NULL) return (print_usage(stderr, 0)); if (flags == 0 && ufile == NULL) flags = F_ALLMSK; if ((fd = open(filename, O_RDONLY)) == -1) die("failed to open %s", filename); if ((elf = elf_begin(fd, ELF_C_READ, NULL)) != NULL && gelf_getehdr(elf, &ehdr) != NULL) { Elf_Data *dp; Elf_Scn *ctfscn = findelfscn(elf, &ehdr, ".SUNW_ctf"); Elf_Scn *symscn; GElf_Shdr ctfshdr; if (ctfscn == NULL || (dp = elf_getdata(ctfscn, NULL)) == NULL) die("%s does not contain .SUNW_ctf data\n", filename); cd.cd_ctfdata = dp->d_buf; cd.cd_ctflen = dp->d_size; /* * If the sh_link field of the CTF section header is non-zero * it indicates which section contains the symbol table that * should be used. We default to the .symtab section if sh_link * is zero or if there's an error reading the section header. */ if (gelf_getshdr(ctfscn, &ctfshdr) != NULL && ctfshdr.sh_link != 0) { symscn = elf_getscn(elf, ctfshdr.sh_link); } else { symscn = findelfscn(elf, &ehdr, ".symtab"); } /* If we found a symbol table, find the corresponding strings */ if (symscn != NULL) { GElf_Shdr shdr; Elf_Scn *symstrscn; if (gelf_getshdr(symscn, &shdr) != NULL) { symstrscn = elf_getscn(elf, shdr.sh_link); cd.cd_nsyms = shdr.sh_size / shdr.sh_entsize; cd.cd_symdata = elf_getdata(symscn, NULL); cd.cd_strdata = elf_getdata(symstrscn, NULL); } } } else { struct stat st; if (fstat(fd, &st) == -1) die("failed to fstat %s", filename); cd.cd_ctflen = st.st_size; cd.cd_ctfdata = mmap(NULL, cd.cd_ctflen, PROT_READ, MAP_PRIVATE, fd, 0); if (cd.cd_ctfdata == MAP_FAILED) die("failed to mmap %s", filename); } /* * Get a pointer to the CTF data buffer and interpret the first portion * as a ctf_header_t. Validate the magic number and size. */ if (cd.cd_ctflen < sizeof (ctf_preamble_t)) die("%s does not contain a CTF preamble\n", filename); /* LINTED - pointer alignment */ pp = (const ctf_preamble_t *)cd.cd_ctfdata; if (pp->ctp_magic != CTF_MAGIC) die("%s does not appear to contain CTF data\n", filename); if (pp->ctp_version == CTF_VERSION) { /* LINTED - pointer alignment */ hp = (ctf_header_t *)cd.cd_ctfdata; cd.cd_ctfdata = (caddr_t)cd.cd_ctfdata + sizeof (ctf_header_t); if (cd.cd_ctflen < sizeof (ctf_header_t)) { die("%s does not contain a v%d CTF header\n", filename, CTF_VERSION); } } else { die("%s contains unsupported CTF version %d\n", filename, pp->ctp_version); } /* * If the data buffer is compressed, then malloc a buffer large enough * to hold the decompressed data, and use zlib to decompress it. */ if (hp->cth_flags & CTF_F_COMPRESS) { z_stream zstr; void *buf; int rc; if ((buf = malloc(hp->cth_stroff + hp->cth_strlen)) == NULL) die("failed to allocate decompression buffer"); bzero(&zstr, sizeof (z_stream)); zstr.next_in = (void *)cd.cd_ctfdata; zstr.avail_in = cd.cd_ctflen; zstr.next_out = buf; zstr.avail_out = hp->cth_stroff + hp->cth_strlen; if ((rc = inflateInit(&zstr)) != Z_OK) die("failed to initialize zlib: %s\n", zError(rc)); if ((rc = inflate(&zstr, Z_FINISH)) != Z_STREAM_END) die("failed to decompress CTF data: %s\n", zError(rc)); if ((rc = inflateEnd(&zstr)) != Z_OK) die("failed to finish decompression: %s\n", zError(rc)); if (zstr.total_out != hp->cth_stroff + hp->cth_strlen) die("CTF data is corrupt -- short decompression\n"); cd.cd_ctfdata = buf; cd.cd_ctflen = hp->cth_stroff + hp->cth_strlen; } if (flags & F_HDR) error |= print_header(hp, &cd); if (flags & (F_LABEL)) error |= print_labeltable(hp, &cd); if (flags & (F_DATA | F_STATS)) error |= read_data(hp, &cd); if (flags & (F_FUNC | F_STATS)) error |= read_funcs(hp, &cd); if (flags & (F_TYPES | F_STATS)) error |= read_types(hp, &cd); if (flags & (F_STR | F_STATS)) error |= read_strtab(hp, &cd); if (flags & F_STATS) error |= print_stats(); /* * If the -u option is specified, write the uncompressed CTF data to a * raw CTF file. CTF data can already be extracted compressed by * applying elfdump -w -N .SUNW_ctf to an ELF file, so we don't bother. */ if (ufile != NULL) { ctf_header_t h; bcopy(hp, &h, sizeof (h)); h.cth_flags &= ~CTF_F_COMPRESS; if ((ufd = open(ufile, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0 || write(ufd, &h, sizeof (h)) != sizeof (h) || write(ufd, cd.cd_ctfdata, cd.cd_ctflen) != cd.cd_ctflen) { warn("failed to write CTF data to '%s'", ufile); error |= E_ERROR; } (void) close(ufd); } if (elf != NULL) (void) elf_end(elf); (void) close(fd); return (error); }
int main(int argc, char *argv[]) { int i = 0; char* file_name = NULL; LASReaderH reader = NULL; LASHeaderH header = NULL; LASWriterH writer = NULL; int check_points = FALSE; int repair_header = FALSE; int change_header = FALSE; int repair_bounding_box = FALSE; int use_stdin = FALSE; int update_return_counts = FALSE; int skip_vlr = FALSE; int wkt = FALSE; char *system_identifier = NULL; char *generating_software = NULL; unsigned char file_creation_day = 0; unsigned char file_creation_year = 0; int err = 0; LASPointSummary* summary = NULL; for (i = 1; i < argc; i++) { if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"--version") == 0) { char* ver = LAS_GetFullVersion(); fprintf(stderr,"%s", ver); LASString_Free(ver); exit(0); } else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"--help") == 0) { usage(); exit(0); } else if (strcmp(argv[i],"--input") == 0 || strcmp(argv[i],"-input") == 0 || strcmp(argv[i],"-i") == 0 || strcmp(argv[i],"-in") == 0) { i++; file_name = argv[i]; } else if (strcmp(argv[i], "--points") == 0 || strcmp(argv[i], "--check") == 0 || strcmp(argv[i], "--check_points") == 0 || strcmp(argv[i], "-c") == 0 || strcmp(argv[i], "-points") == 0 || strcmp(argv[i], "-check") == 0 || strcmp(argv[i], "-check_points") == 0) { check_points = TRUE; } else if (strcmp(argv[i], "--nocheck") == 0 || strcmp(argv[i], "-nocheck") == 0) { check_points = FALSE; } else if (strcmp(argv[i], "--stdin") == 0 || strcmp(argv[i], "-ilas") == 0) { use_stdin = TRUE; } else if (strcmp(argv[i], "--repair") == 0 || strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "-repair_header") == 0 || strcmp(argv[i], "-repair") == 0) { repair_header = TRUE; check_points = TRUE; } else if (strcmp(argv[i], "--repair_bb") == 0 || strcmp(argv[i], "--repair_bounding_box") == 0 || strcmp(argv[i], "--repair_boundingbox") == 0 || strcmp(argv[i], "-repair_bb") == 0 || strcmp(argv[i], "-repair_bounding_box") == 0 || strcmp(argv[i], "-repair_boundingbox") == 0 || strcmp(argv[i], "-repair") == 0 || strcmp(argv[i], "-rb") == 0) { repair_bounding_box = TRUE; check_points = TRUE; } else if (strcmp(argv[i],"--system_identifier") == 0 || strcmp(argv[i],"-system_identifier") == 0 || strcmp(argv[i],"-s") == 0 || strcmp(argv[i],"-sys_id") == 0) { i++; system_identifier = (char*) malloc(31 * sizeof(char)); strcpy(system_identifier, argv[i]); change_header = TRUE; } else if (strcmp(argv[i],"--generating_software") == 0 || strcmp(argv[i],"-generating_software") == 0 || strcmp(argv[i],"-g") == 0 || strcmp(argv[i],"-gen_soft") == 0) { i++; generating_software = (char*) malloc(31*sizeof(char)); strcpy(generating_software, argv[i]); change_header = TRUE; } else if (strcmp(argv[i],"--file_creation") == 0 || strcmp(argv[i],"-file_creation") == 0) { /* XXX - mloskot: Consider replacing atoi with strtol, see http://www.iso-9899.info/wiki/Converting */ i++; file_creation_day = (unsigned char)atoi(argv[i]); i++; file_creation_year = (unsigned char)atoi(argv[i]); change_header = TRUE; } else if (strcmp(argv[i],"--skip_vlr") == 0 || strcmp(argv[i],"--no_vlr") == 0) { skip_vlr = TRUE; } else if (strcmp(argv[i],"--wkt") == 0) { wkt = TRUE; } else if (file_name == NULL) { file_name = argv[i]; } else { usage(); fprintf(stderr, "ERROR: unknown argument '%s'\n",argv[i]); exit(1); } } if (use_stdin) { file_name = "stdin"; } if (!file_name) { LASError_Print("No filename was provided to be opened"); usage(); exit(1); } reader = LASReader_Create(file_name); if (!reader) { LASError_Print("Could not open file "); exit(1); } header = LASReader_GetHeader(reader); if (!header) { LASError_Print("Could not get LASHeader "); exit(1); } print_header(stdout, header, file_name, skip_vlr, wkt); if (change_header) { if (system_identifier) { err = LASHeader_SetSystemId (header, system_identifier); if (err) LASError_Print("Could not set SystemId"); } if (generating_software) { err = LASHeader_SetSoftwareId(header, generating_software); if (err) LASError_Print("Could not set SoftwareId"); } if ( file_creation_day || file_creation_year) { err = LASHeader_SetCreationDOY(header, file_creation_day); if (err) LASError_Print("Could not set file creation day"); err = LASHeader_SetCreationYear(header, file_creation_year); if (err) LASError_Print("Could not set file creation year"); } /* We need to wipe out the reader and make a writer. */ if (reader) { LASReader_Destroy(reader); reader = NULL; } writer = LASWriter_Create(file_name, header, LAS_MODE_APPEND); if (!writer) { LASError_Print("Problem creating LASWriterH object"); LASHeader_Destroy(header); header = NULL; exit(1); } if (writer) LASWriter_Destroy(writer); writer = NULL; if (header) LASHeader_Destroy(header); header = NULL; } if (check_points) { if (!reader) { reader = LASReader_Create(file_name); if (!reader) { LASError_Print("Could not open file "); exit(1); } } if (! header) { header = LASReader_GetHeader(reader); if (!header) { LASError_Print("Could not get LASHeader "); exit(1); } } if (!summary) summary = SummarizePoints(reader); print_point_summary(stdout, summary, header); if (repair_header) { fprintf(stdout, "\n---------------------------------------------------------\n"); fprintf(stdout, " Repair Summary\n"); fprintf(stdout, "---------------------------------------------------------\n"); if (use_stdin) { LASError_Print("Cannot update header information on piped input!"); exit(1); } if (! header) { header = LASReader_GetHeader(reader); if (!header) { LASError_Print("Could not get LASHeader "); exit(1); } } if (! repair_bounding_box) { if ( LASHeader_GetMinX(header) != LASPoint_GetX(summary->pmin) ) repair_bounding_box = TRUE; if ( LASHeader_GetMinY(header) != LASPoint_GetY(summary->pmin) ) repair_bounding_box = TRUE; if ( LASHeader_GetMinZ(header) != LASPoint_GetZ(summary->pmin) ) repair_bounding_box = TRUE; if ( LASHeader_GetMaxX(header) != LASPoint_GetX(summary->pmax) ) repair_bounding_box = TRUE; if ( LASHeader_GetMaxY(header) != LASPoint_GetY(summary->pmax) ) repair_bounding_box = TRUE; if ( LASHeader_GetMaxZ(header) != LASPoint_GetZ(summary->pmax) ) repair_bounding_box = TRUE; } if (repair_bounding_box) { fprintf(stdout, " Reparing Bounding Box...\n"); err = LASHeader_SetMin( header, LASPoint_GetX(summary->pmin), LASPoint_GetY(summary->pmin), LASPoint_GetZ(summary->pmin) ); if (err) { LASError_Print("Could not set minimum for header "); exit(1); } err = LASHeader_SetMax( header, LASPoint_GetX(summary->pmax), LASPoint_GetY(summary->pmax), LASPoint_GetZ(summary->pmax) ); if (err) { LASError_Print("Could not set minimum for header "); exit(1); } } for (i = 0; i < 5; i++) { if (LASHeader_GetPointRecordsByReturnCount(header, i) != summary->number_of_points_by_return[i]) { update_return_counts = TRUE; break; } } if (update_return_counts) { fprintf(stdout, " Reparing Point Count by Return...\n"); for (i = 0; i < 5; i++) { LASHeader_SetPointRecordsByReturnCount( header, i, summary->number_of_points_by_return[i]); } } if (reader) { LASReader_Destroy(reader); reader = NULL; } writer = LASWriter_Create(file_name, header, LAS_MODE_APPEND); if (!writer) { LASError_Print("Problem creating LASWriterH object for append"); LASHeader_Destroy(header); header = NULL; exit(1); } LASWriter_Destroy(writer); writer = NULL; LASHeader_Destroy(header); header = NULL; } if (summary) { LASPoint_Destroy(summary->pmin); LASPoint_Destroy(summary->pmax); free(summary); } } if (reader) LASReader_Destroy(reader); if (header) LASHeader_Destroy(header); #ifdef HAVE_GDAL /* Various GDAL related cleanups */ #ifdef OSRCleanup OSRCleanup(); #endif CPLFinderClean(); CPLFreeConfig(); CPLCleanupTLS(); #endif return 0; }
int snake_game::start_game() { std::vector<std::pair<int, int> > vSnakeBody; std::map<int, std::map<int, bool> > mSnakeBody; int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0; int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0; WINDOW *w_snake = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX); print_header(w_snake); //Snake start position vSnakeBody.push_back(std::make_pair(FULL_SCREEN_HEIGHT / 2, FULL_SCREEN_WIDTH / 2)); mSnakeBody[FULL_SCREEN_HEIGHT / 2][FULL_SCREEN_WIDTH / 2] = true; mvwputch(w_snake, vSnakeBody[vSnakeBody.size() - 1].first, vSnakeBody.back().second, c_white, '#'); //Snake start direction int iDirY = 0; int iDirX = 1; //Snake start length size_t iSnakeBody = 10; //GameSpeed aka inputdelay/timeout int iGameSpeed = 100; //Score int iScore = 0; int iFruitPosY = 0; int iFruitPosX = 0; //Draw Score print_score(w_snake, iScore); long ch; InputEvent input; do { //Check if we hit a border if (vSnakeBody[vSnakeBody.size() - 1].first + iDirY == 0) { vSnakeBody.push_back(std::make_pair(vSnakeBody[vSnakeBody.size() - 1].first + iDirY + FULL_SCREEN_HEIGHT - 2, vSnakeBody[vSnakeBody.size() - 1].second + iDirX)); } else if (vSnakeBody[vSnakeBody.size() - 1].first + iDirY == FULL_SCREEN_HEIGHT - 1) { vSnakeBody.push_back(std::make_pair(vSnakeBody[vSnakeBody.size() - 1].first + iDirY - FULL_SCREEN_HEIGHT + 2, vSnakeBody[vSnakeBody.size() - 1].second + iDirX)); } else if (vSnakeBody[vSnakeBody.size() - 1].second + iDirX == 0) { vSnakeBody.push_back(std::make_pair(vSnakeBody[vSnakeBody.size() - 1].first + iDirY, vSnakeBody[vSnakeBody.size() - 1].second + iDirX + FULL_SCREEN_WIDTH - 2)); } else if (vSnakeBody[vSnakeBody.size() - 1].second + iDirX == FULL_SCREEN_WIDTH - 1) { vSnakeBody.push_back(std::make_pair(vSnakeBody[vSnakeBody.size() - 1].first + iDirY, vSnakeBody[vSnakeBody.size() - 1].second + iDirX - FULL_SCREEN_WIDTH + 2)); } else { vSnakeBody.push_back(std::make_pair(vSnakeBody[vSnakeBody.size() - 1].first + iDirY, vSnakeBody[vSnakeBody.size() - 1].second + iDirX)); } //Check if we hit ourself if (mSnakeBody[vSnakeBody[vSnakeBody.size() - 1].first][vSnakeBody[vSnakeBody.size() - 1].second]) { //We are dead :( break; } else { //Add new position to map mSnakeBody[vSnakeBody[vSnakeBody.size() - 1].first][vSnakeBody[vSnakeBody.size() - 1].second] = true; } //Have we eaten the forbidden fruit? if (vSnakeBody[vSnakeBody.size() - 1].first == iFruitPosY && vSnakeBody[vSnakeBody.size() - 1].second == iFruitPosX) { iScore += 500; iSnakeBody += 10; iGameSpeed -= 3; print_score(w_snake, iScore); iFruitPosY = 0; iFruitPosX = 0; } //Check if we are longer than our max size if (vSnakeBody.size() > iSnakeBody) { mSnakeBody[vSnakeBody[0].first][vSnakeBody[0].second] = false; mvwputch(w_snake, vSnakeBody[0].first, vSnakeBody[0].second, c_black, ' '); vSnakeBody.erase(vSnakeBody.begin(), vSnakeBody.begin() + 1); } //Draw Snake mvwputch(w_snake, vSnakeBody[vSnakeBody.size() - 1].first, vSnakeBody[vSnakeBody.size() - 1].second, c_white, '#'); mvwputch(w_snake, vSnakeBody[vSnakeBody.size() - 2].first, vSnakeBody[vSnakeBody.size() - 2].second, c_ltgray, '#'); //On full length add a fruit if (iFruitPosY == 0 && iFruitPosY == 0) { do { iFruitPosY = rng(1, FULL_SCREEN_HEIGHT - 2); iFruitPosX = rng(1, FULL_SCREEN_WIDTH - 2); } while (mSnakeBody[iFruitPosY][iFruitPosX]); mvwputch(w_snake, iFruitPosY, iFruitPosX, c_ltred, '*'); } wrefresh(w_snake); //Check input timeout(iGameSpeed); ch = getch(); input = get_input(ch); timeout(-1); switch (input) { case DirectionN: /* up */ if (iDirY != 1) { iDirY = -1; iDirX = 0; } break; case DirectionS: /* down */ if (iDirY != -1) { iDirY = 1; iDirX = 0; } break; case DirectionW: /* left */ if (iDirX != 1) { iDirY = 0; iDirX = -1; } break; case DirectionE: /* right */ if (iDirX != -1) { iDirY = 0; iDirX = 1; } break; case Cancel: return iScore; break; default: break; } } while (true); snake_over(w_snake, iScore); return iScore; }
int dr_writer_init (FILE * pfile) { print_header (pfile); return 0; }
int main () { int file_size , padding = 0; HEADER bmp_header; INFO_HEADER bmp_info_header; COLOR_PALLET *bgr_pallete = malloc (sizeof( COLOR_PALLET ) * CHAR_RANGE); unsigned char *data_buffer , *out_buffer ; char *file_name ; FILE *in_file = NULL; file_name = get_file_name (); in_file = fopen ( file_name , "rb" ); if (in_file == NULL) { printf("file opening failed\n"); return 1; } if ( fread ( &bmp_header , sizeof ( HEADER ) , 1 , in_file) < 1 ) { printf("Some issue in reading file\n"); return 0; } if ( fread ( &bmp_info_header , sizeof ( INFO_HEADER ) , 1 , in_file) < 1 ) { printf("Some issue in reading file\n"); return 1; } print_header( bmp_header , bmp_info_header ); //checking if the image is bmp or not if ( bmp_header.signature != BMP_SIGNATURE ) { printf("no a bmp\n"); return 1; } if ( bmp_info_header.bits_per_pixel != RGB_SIZE ) { printf("already in greysacle\n"); return 1; } if ( fseek ( in_file , bmp_header.offset , SEEK_SET ) == -1 ) { printf("file operation failed\n"); return 1; } file_size = bmp_info_header.image_data_size ; //based on file_size allocate memory data_buffer = malloc (sizeof (char) * file_size + 1 ); if (data_buffer == NULL) { printf("malloc Failed\n"); return 1; } *(data_buffer + file_size) = CHAR_NULL; //read the data into buffer if ( fread ( data_buffer , sizeof(char) , file_size , in_file ) < file_size ) { printf("Some issue in reading file\n"); fclose (in_file); free (data_buffer); return 1; } if ( fclose ( in_file ) == 0 ) { printf("File not closing\n" ); } out_buffer = covert_to_mono ( data_buffer , file_size , bmp_info_header); if ( ( bmp_info_header.image_width * 3 ) % 4 != 0) padding = 4 - ( ( bmp_info_header.image_width * 3 ) % 4 ); //change the header details bmp_header.offset = COLOR_PALLET_SIZE + HEADER_SIZE; bmp_header.bmp_file_size = HEADER_SIZE + ( bmp_info_header.image_width * bmp_info_header.image_height ) + ( padding * bmp_info_header.image_height ) + COLOR_PALLET_SIZE; bmp_info_header.bits_per_pixel = 8; bmp_info_header.image_data_size =( bmp_info_header.image_width * bmp_info_header.image_height ) + ( padding * bmp_info_header.image_height ); print_header( bmp_header , bmp_info_header ); //get bgr pallete get_color_pallet ( bgr_pallete ); to_file (out_buffer, bmp_header , bmp_info_header , bgr_pallete , bmp_info_header.image_data_size) ; free (data_buffer); data_buffer = NULL; free ( out_buffer ); out_buffer = NULL; free (bgr_pallete); bgr_pallete = NULL; return 0; }
void print_program() { #ifdef DEBUG fprintf(stdout, "starting print program...\n"); #endif output = fopen("output_a.out.c", "w"); if(!output){ fprintf(stderr, "error in print_program\n"); exit(0); } print_header(); print_func_decaration(); print_safety_guard(); print_print_pc(); //yang unsigned instsize = 0; unsigned int globalsize = 0; globalsize = print_dependence_data_to_file(); //////// for(PROGRAM::iterator it = g_current_program->begin();//dump functions it != g_current_program->end();it++){ #ifdef WINDOWS_NAKED fprintf(output, "__declspec( naked ) "); #endif if(g_main_pc == it->first){ fprintf(output, "void main(){\n"); //Hush.b //extern variables in dst #ifdef DEBUG fprintf(stderr, "----dst_map size is %d\n", dst_map.size()); #endif #if 0 if(!dst_map.empty()){ for(map<unsigned int, Dst_item*>::iterator it= dst_map.begin(); it!=dst_map.end();it++){ fprintf(output, "extern %s;\n", it->second->name); } } #endif fprintf(output, "output=fopen(\"log\", \"w\");\n"); //Hush.e }else{ fprintf(output, "int func_0x%x(){\n", it->first); } #ifdef DEBUG fprintf(stderr, "----function start pc:%x\t%x\n", it->first, it->second); #endif g_current_func = it->second; print_func(it->second); fprintf(output, "}\n"); instsize += it->second->size(); } fclose(output); #ifdef STATISTICS fprintf(stderr, "program:%s\n", PEMU_binary_name); fprintf(stderr, "number of executed inst:\t%d\n", g_inst_num); fprintf(stderr, "symbolized addresses %d\n", g_symbol_nums); fprintf(stderr, "direct jmp:\t%d\njcc:\t%d\ndirect call:\t%d\ndata:\t%d\ndis:\t%d\nimm:\t%d\n", g_jmp_num, g_jcc_num, g_call_num, g_dump_data, g_dis_nums, g_imm_nums); fprintf(stderr, "checks num:%d\n", g_check_nums); #endif }
int main( int argc, char** argv ) { GetOptContext ctx; init_getopt_context( &ctx ); char c; while( (c = getopt( argc, argv, "?i:o:a:de:x:lrh:v", &ctx )) != -1 ) { switch( c ) { case 'i': g_inputFileName = ctx.optarg; break; case 'o': g_outputFileName = ctx.optarg; break; case 'e': if( strcmp( ctx.optarg, "big" ) == 0 ) g_swapEndian = true; else if( strcmp( ctx.optarg, "little" ) == 0 ) g_swapEndian = false; else { fprintf( stderr, "error: unknown argument for option -e: %s\n", ctx.optarg ); return -1; } break; case 'a': g_asmFileName = ctx.optarg; break; case 'l': g_printIncludes = true; break; case 'v': /* verbose, print extra funny stuff! */ break; case 'h': g_outputHeaderName = ctx.optarg; break; case ':': print_usage(); return -1; break; case '?': print_usage(); return 0; break; } } if(ctx.optind != argc) { fprintf( stdout, "%s: unexpected argument '%s'\n", argv[0], argv[ctx.optind] ); print_usage(); return -1; } int returnCode = 0; if( !g_inputFileName ) { returnCode = -1; fprintf( stderr, "error: No input file given.\n" ); } // Convert all \ to / in the input file name, in order to // aid the include path translation for( char* p = g_inputFileName; p && *p; ++p ) { if( *p == '\\' ) *p = '/'; } if( returnCode == 0 ) { Allocator a; a.m_Alloc = &allocate_memory; a.m_Free = &free_memory; BehaviorTreeContext btc = create_bt_context( a ); ParserContextFunctions pcf; pcf.m_Read = &read_file; pcf.m_Error = &parser_error; pcf.m_Warning = &parser_warning; pcf.m_Translate = &parser_translate_include; ParsingInfo pi; pi.m_Name = g_inputFileName; pi.m_File = fopen( pi.m_Name, "r" ); if( !pi.m_File ) { fprintf( stderr, "%s(0): error: unable to open input file \"%s\" for reading.\n", g_inputFileName, pi.m_Name ); returnCode = -1; } if( returnCode == 0 ) { ParserContext pc = create_parser_context( btc ); set_extra( pc, &pi ); set_current( pc, pi.m_Name ); returnCode = parse( pc, &pcf ); destroy( pc ); } if( pi.m_File ) fclose( pi.m_File ); Include* include = get_first_include( btc ); while( returnCode == 0 && include ) { pi.m_Name = include->m_Name; pi.m_File = fopen( pi.m_Name, "r" ); if( !pi.m_File ) { fprintf( stderr, "%s(%d): error: unable to open include file \"%s\" for reading.\n", include->m_Parent, include->m_LineNo, pi.m_Name ); returnCode = -1; break; } ParserContext pc = create_parser_context( btc ); set_extra( pc, &pi ); set_current( pc, pi.m_Name ); returnCode = parse( pc, &pcf ); destroy( pc ); if( pi.m_File ) fclose( pi.m_File ); if( returnCode != 0 ) break; include = include->m_Next; } include = get_first_include( btc ); while( returnCode == 0 && include && g_printIncludes ) { printf( "%s\n", include->m_Name ); include = include->m_Next; } if( g_outputHeaderName && returnCode == 0 ) { FILE* header = fopen( g_outputHeaderName, "w" ); if( !header ) { fprintf( stderr, "%s(0): error: Unable to open output file %s for writing.\n", g_inputFileName, g_outputHeaderName ); returnCode = -1; } else { returnCode = print_header( header, g_inputFileName, btc ); if( returnCode != 0 ) fprintf( stderr, "%s(0): error: unspecified error when writing header %s.\n", g_inputFileName, g_outputHeaderName ); fclose( header ); } } if( g_outputFileName && returnCode == 0 ) { Program p; unsigned int debug_hash = hashlittle( "debug_info" ); Parameter* debug_param = find_by_hash( get_options( btc ), debug_hash ); if( debug_param ) p.m_I.SetGenerateDebugInfo( as_integer( *debug_param ) ); returnCode = setup( btc, &p ); if( returnCode == 0 ) { returnCode = generate( &p ); if( returnCode != 0 ) fprintf( stderr, "%s(0): error: Internal compiler error in generate.\n", g_inputFileName ); } else { fprintf( stderr, "%s(0): error: Internal compiler error in setup.\n", g_inputFileName ); } teardown( &p ); if( returnCode == 0 ) { g_outputFile = fopen( g_outputFileName, "wb" ); if( !g_outputFile ) { fprintf( stderr, "%s(0): error: Unable to open output file %s for writing.\n", g_inputFileName, g_outputFileName ); returnCode = -2; } if( returnCode == 0 ) returnCode = save_program( g_outputFile, g_swapEndian, &p ); if( returnCode != 0 ) { fprintf( stderr, "%s(0): error: Failed to write output file %s.\n", g_inputFileName, g_outputFileName ); returnCode = -5; } } if( !g_asmFileName ) { unsigned int hash = hashlittle( "force_asm" ); Parameter* force_asm = find_by_hash( get_options( btc ), hash ); if( force_asm && as_bool( *force_asm ) ) { unsigned int len = strlen( g_outputFileName ); g_asmFileNameMemory = (char*)malloc( len + 5 ); memcpy( g_asmFileNameMemory, g_outputFileName, len ); g_asmFileNameMemory[len + 0] = '.'; g_asmFileNameMemory[len + 1] = 'a'; g_asmFileNameMemory[len + 2] = 's'; g_asmFileNameMemory[len + 3] = 'm'; g_asmFileNameMemory[len + 4] = 0; g_asmFileName = g_asmFileNameMemory; } } if( returnCode == 0 && g_asmFileName ) { FILE* asmFile = fopen( g_asmFileName, "w" ); if( !asmFile ) { fprintf( stderr, "%s(0): error: Unable to open assembly file %s for writing.\n", g_inputFileName, g_asmFileName ); returnCode = -1; } else { print_program( asmFile, &p ); fclose( asmFile ); } } } destroy( btc ); } if( g_asmFileNameMemory ) free( g_asmFileNameMemory ); if( g_outputFile ) fclose( g_outputFile ); return returnCode; }
void diff_archive (void) { struct stat stat_data; int name_length; int status; errno = EPIPE; /* FIXME: errno should be read-only */ /* FIXME: remove perrors */ set_next_block_after (current_header); decode_header (current_header, ¤t_stat, ¤t_format, 1); /* Print the block from `current_header' and `current_stat'. */ if (verbose_option) { if (now_verifying) fprintf (stdlis, _("Verify ")); print_header (); } switch (current_header->header.typeflag) { default: WARN ((0, 0, _("Unknown file type '%c' for %s, diffed as normal file"), current_header->header.typeflag, current_file_name)); /* Fall through. */ case AREGTYPE: case REGTYPE: case GNUTYPE_SPARSE: case CONTTYPE: /* Appears to be a file. See if it's really a directory. */ name_length = strlen (current_file_name) - 1; if (current_file_name[name_length] == PATHSEP) goto really_dir; if (!get_stat_data (&stat_data)) { if (current_header->oldgnu_header.isextended) skip_extended_headers (); skip_file ((long) current_stat.st_size); goto quit; } if (!S_ISREG (stat_data.st_mode)) { report_difference (_("Not a regular file")); skip_file ((long) current_stat.st_size); goto quit; } stat_data.st_mode &= 07777; if (stat_data.st_mode != current_stat.st_mode) report_difference (_("Mode differs")); #if !MSDOS && !WIN32 /* stat() in djgpp's C library gives a constant number of 42 as the uid and gid of a file. So, comparing an FTP'ed archive just after unpack would fail on MSDOS. */ if (stat_data.st_uid != current_stat.st_uid) report_difference (_("Uid differs")); if (stat_data.st_gid != current_stat.st_gid) report_difference (_("Gid differs")); #endif if (stat_data.st_mtime != current_stat.st_mtime) report_difference (_("Mod time differs")); if (current_header->header.typeflag != GNUTYPE_SPARSE && stat_data.st_size != current_stat.st_size) { report_difference (_("Size differs")); skip_file ((long) current_stat.st_size); goto quit; } diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY); if (diff_handle < 0 && !absolute_names_option) { char *tmpbuf = xmalloc (strlen (current_file_name) + 2); *tmpbuf = PATHSEP; strcpy (tmpbuf + 1, current_file_name); diff_handle = open (tmpbuf, O_NDELAY | O_RDONLY); free (tmpbuf); } if (diff_handle < 0) { ERROR ((0, errno, _("Cannot open %s"), current_file_name)); if (current_header->oldgnu_header.isextended) skip_extended_headers (); skip_file ((long) current_stat.st_size); report_difference (NULL); goto quit; } /* Need to treat sparse files completely differently here. */ if (current_header->header.typeflag == GNUTYPE_SPARSE) diff_sparse_files (current_stat.st_size); else { if (multi_volume_option) { assign_string (&save_name, current_file_name); save_totsize = current_stat.st_size; /* save_sizeleft is set in read_and_process. */ } read_and_process ((long) (current_stat.st_size), process_rawdata); if (multi_volume_option) assign_string (&save_name, NULL); } status = close (diff_handle); if (status < 0) ERROR ((0, errno, _("Error while closing %s"), current_file_name)); quit: break; #if !MSDOS case LNKTYPE: { dev_t dev; ino_t ino; if (!get_stat_data (&stat_data)) break; dev = stat_data.st_dev; ino = stat_data.st_ino; status = stat (current_link_name, &stat_data); if (status < 0) { if (errno == ENOENT) report_difference (_("Does not exist")); else { WARN ((0, errno, _("Cannot stat file %s"), current_file_name)); report_difference (NULL); } break; } if (stat_data.st_dev != dev || stat_data.st_ino != ino) { char *message = (char *) xmalloc (MESSAGE_BUFFER_SIZE + strlen (current_link_name)); sprintf (message, _("Not linked to %s"), current_link_name); report_difference (message); free (message); break; } break; } #endif /* not MSDOS */ #ifdef S_ISLNK case SYMTYPE: { char linkbuf[NAME_FIELD_SIZE + 3]; /* FIXME: may be too short. */ status = readlink (current_file_name, linkbuf, (sizeof linkbuf) - 1); if (status < 0) { if (errno == ENOENT) report_difference (_("No such file or directory")); else { WARN ((0, errno, _("Cannot read link %s"), current_file_name)); report_difference (NULL); } break; } linkbuf[status] = '\0'; /* null-terminate it */ if (strncmp (current_link_name, linkbuf, (size_t) status) != 0) report_difference (_("Symlink differs")); break; } #endif /* not S_ISLNK */ #ifdef S_IFCHR case CHRTYPE: current_stat.st_mode |= S_IFCHR; goto check_node; #endif /* not S_IFCHR */ #ifdef S_IFBLK /* If local system doesn't support block devices, use default case. */ case BLKTYPE: current_stat.st_mode |= S_IFBLK; goto check_node; #endif /* not S_IFBLK */ #ifdef S_ISFIFO /* If local system doesn't support FIFOs, use default case. */ case FIFOTYPE: # ifdef S_IFIFO current_stat.st_mode |= S_IFIFO; # endif current_stat.st_rdev = 0; /* FIXME: do we need this? */ goto check_node; #endif /* S_ISFIFO */ check_node: /* FIXME: deal with umask. */ if (!get_stat_data (&stat_data)) break; if (current_stat.st_rdev != stat_data.st_rdev) { report_difference (_("Device numbers changed")); break; } if ( #ifdef S_IFMT current_stat.st_mode != stat_data.st_mode #else /* POSIX lossage. */ (current_stat.st_mode & 07777) != (stat_data.st_mode & 07777) #endif ) { report_difference (_("Mode or device-type changed")); break; } break; case GNUTYPE_DUMPDIR: { char *dumpdir_buffer = get_directory_contents (current_file_name, 0); if (multi_volume_option) { assign_string (&save_name, current_file_name); save_totsize = current_stat.st_size; /* save_sizeleft is set in read_and_process. */ } if (dumpdir_buffer) { dumpdir_cursor = dumpdir_buffer; read_and_process ((long) (current_stat.st_size), process_dumpdir); free (dumpdir_buffer); } else read_and_process ((long) (current_stat.st_size), process_noop); if (multi_volume_option) assign_string (&save_name, NULL); /* Fall through. */ } case DIRTYPE: /* Check for trailing /. */ name_length = strlen (current_file_name) - 1; really_dir: while (name_length && current_file_name[name_length] == PATHSEP) current_file_name[name_length--] = '\0'; /* zap / */ if (!get_stat_data (&stat_data)) break; if (!S_ISDIR (stat_data.st_mode)) { report_difference (_("No longer a directory")); break; } if ((stat_data.st_mode & 07777) != (current_stat.st_mode & 07777)) report_difference (_("Mode differs")); break; case GNUTYPE_VOLHDR: break; case GNUTYPE_MULTIVOL: { off_t offset; name_length = strlen (current_file_name) - 1; if (current_file_name[name_length] == PATHSEP) goto really_dir; if (!get_stat_data (&stat_data)) break; if (!S_ISREG (stat_data.st_mode)) { report_difference (_("Not a regular file")); skip_file ((long) current_stat.st_size); break; } stat_data.st_mode &= 07777; offset = from_oct (1 + 12, current_header->oldgnu_header.offset); if (stat_data.st_size != current_stat.st_size + offset) { report_difference (_("Size differs")); skip_file ((long) current_stat.st_size); break; } diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY); if (diff_handle < 0) { WARN ((0, errno, _("Cannot open file %s"), current_file_name)); report_difference (NULL); skip_file ((long) current_stat.st_size); break; } status = lseek (diff_handle, offset, 0); if (status != offset) { WARN ((0, errno, _("Cannot seek to %ld in file %s"), offset, current_file_name)); report_difference (NULL); break; } if (multi_volume_option) { assign_string (&save_name, current_file_name); save_totsize = stat_data.st_size; /* save_sizeleft is set in read_and_process. */ } read_and_process ((long) (current_stat.st_size), process_rawdata); if (multi_volume_option) assign_string (&save_name, NULL); status = close (diff_handle); if (status < 0) ERROR ((0, errno, _("Error while closing %s"), current_file_name)); break; } } }
unsigned int results_lcl ( const char * filename, /* output filename */ struct TSeq * t, /* text */ unsigned int n, /* length of t */ struct TSeq * p, /* pattern */ unsigned int m, /* length of p */ double max_score, unsigned int * gaps_pos, unsigned int l, unsigned int * gaps_len, unsigned int * where, unsigned int istart, unsigned int iend, unsigned int jstart, unsigned int jend, unsigned int swap, unsigned int matrix, double gap_penalty, double ext_penalty, int L ) { FILE * output; char * seqa; //sequence a with the inserted gaps unsigned int aa; unsigned int ii; char * seqb; //sequence b with the inserted gaps unsigned int bb; unsigned int jj; char * mark_mis; //a string with the mismatches marked as '|' (and the matches as ' ') unsigned int min_mis = 0; //the number of mismatches in the alignment unsigned int mm = 0; char * Cmark_mis; //cropped sequences char * Cseqa; char * Cseqb; unsigned int i; /* Here we calculate the number of gaps and their total length */ unsigned int numgaps = 0; unsigned int gapslength = 0; for ( i = 0; i < l; i ++ ) { if ( gaps_len[i] > 0 ) { numgaps++; gapslength += gaps_len[i]; } } /* dynamic memory allocation for the 3 sequences */ if ( ! ( seqa = ( char * ) calloc ( n + gapslength + 1, sizeof ( char ) ) ) ) { fprintf ( stderr, "Error: seqa could not be allocated!!!\n" ); return ( 0 ); } if ( ! ( seqb = ( char * ) calloc ( n + gapslength + 1, sizeof ( char ) ) ) ) { fprintf ( stderr, "Error: seqb could not be allocated!!!\n" ); return ( 0 ); } if ( ! ( mark_mis = ( char* ) calloc ( n + gapslength + 1, sizeof( char ) ) ) ) { fprintf ( stderr, "Error: mark_mis could not be allocated!!!\n" ); return ( 0 ); } if ( ! ( Cseqa = ( char * ) calloc ( n + gapslength + 1, sizeof ( char ) ) ) ) { fprintf ( stderr, "Error: seqa could not be allocated!!!\n" ); return ( 0 ); } if ( ! ( Cseqb = ( char * ) calloc ( n + gapslength + 1, sizeof ( char ) ) ) ) { fprintf ( stderr, "Error: seqb could not be allocated!!!\n" ); return ( 0 ); } if ( ! ( Cmark_mis = ( char* ) calloc ( n + gapslength + 1, sizeof( char ) ) ) ) { fprintf ( stderr, "Error: mark_mis could not be allocated!!!\n" ); return ( 0 ); } /* Here we open the output file */ if ( ! ( output = fopen ( filename, "w" ) ) ) { fprintf ( stderr, "Error: cannot open file %s!!!\n", filename ); return ( 0 ); } /* Here we print the header */ print_header ( output, filename, matrix, gap_penalty, ext_penalty, L ); #if 0 fprintf ( stderr, "%s\n", t->data ); fprintf ( stderr, "%s\n", p->data ); getchar(); #endif /* Here we go through the gaps to create the 2 sequences */ int g; unsigned int gapsuma = 0; //currently added gap length in seqa unsigned int gapsumb = 0; //currently added gap length in seqb ii = aa = jj = bb = 0; for ( g = numgaps - 1; g >= 0; g-- ) { if ( gaps_len[g] > 0 ) { unsigned int gpos = gaps_pos[g]; unsigned int glen = gaps_len[g]; if ( where[g] == 1 ) { /* Add the letters before the gap */ for ( ; ii < gpos; ii++, aa++ ) seqa[aa] = t -> data[ii]; /* Add the gap */ for ( ; aa < ii + gapsuma + glen; aa++ ) seqa[aa] = '-'; gapsuma += glen; } if ( where[g] == 2 ) { /* Add the letters before the gap */ for ( ; jj < gpos; jj++, bb++ ) seqb[bb] = p -> data[jj]; /* Add the gap */ for ( ; bb < jj + gapsumb + glen; bb++ ) seqb[bb] = '-'; gapsumb += glen; } } } /* Add what is left from both */ for ( ; ii < istart; ii++, aa++ ) seqa[aa] = t -> data[ii]; seqa[aa] = '\0'; for ( ; jj < jstart; jj++, bb++ ) seqb[bb] = p -> data[jj]; seqb[bb] = '\0'; #if 0 fprintf ( stderr, "%s\n", seqa ); fprintf ( stderr, "%s\n", seqb ); getchar(); #endif /* Crop the alignment */ strncat ( &Cseqa[0], &seqa[iend-1], strlen(seqa) - iend + 1 ); strncat ( &Cseqb[0], &seqb[jend-1], strlen(seqb) - jend + 1 ); #if 0 fprintf ( stderr, "%s\n", Cseqa ); fprintf ( stderr, "%s\n", Cseqb ); getchar(); #endif /* Here we create the match/mismatch sequence */ unsigned int alignlen = min ( strlen( Cseqa ), strlen( Cseqb ) ); for ( ; mm < alignlen; mm++ ) { if ( Cseqa[mm] == '-' || Cseqb[mm] == '-' ) mark_mis[mm] = ' '; else if ( Cseqa[mm] == Cseqb[mm] ) mark_mis[mm] = '|'; else { mark_mis[mm] = '.'; } } mark_mis[mm] = '\0'; unsigned int first = 0; unsigned int last = 0; for ( ii = 0; ii < mm; ii++ ) { if ( mark_mis[ii] == '|' ) // If the number of characters read is equal to where the traceback ends then we have found the pos of the first aligned pair { first = last = ii; break; } } for ( ; i < mm; i++ ) { if ( mark_mis[i] == '|' ) // The position of the last aligner pair is simply the last match in the match/mismatch sequence last = i; } // Now we are ready to crop the sequences based on first and last variables -- We also count the mismatches aa = bb = mm = 0; for ( ii = first; ii <= last; ii++ ) { Cseqa[aa]=Cseqa[ii]; aa++; Cseqb[bb]=Cseqb[ii]; bb++; Cmark_mis[mm]=mark_mis[ii]; if ( Cmark_mis[mm] == '.' ) min_mis++; mm++; } Cseqa[aa] = 0; Cseqb[bb] = 0; Cmark_mis[mm] = 0; #if 0 fprintf ( stderr, "%s\n", Cseqa ); fprintf ( stderr, "%s\n", Cmark_mis ); fprintf ( stderr, "%s\n", Cseqb ); getchar(); #endif free ( t -> data ); t -> data = Cseqa; free ( p -> data ); p -> data = Cseqb; iend = iend + first; jend = jend + first; if ( ! swap ) { wrap_lcl ( t, iend - 1, p, jend - 1, Cmark_mis, LINE_LNG, output ); } else { wrap_lcl ( p, jend - 1, t, iend - 1, Cmark_mis, LINE_LNG, output ); } fprintf ( output, "\n" ); fprintf ( output, "Alignment score: %lf\n", max_score ); fprintf ( output, "Number of mismatches: %d\n", min_mis ); fprintf ( output, "Number of gaps: %d\n", numgaps ); fprintf ( output, "Length of gaps: %d\n", gapslength ); if ( fclose ( output ) ) fprintf ( stderr, "Error: cannot close file %s!!!\n", filename ); free ( seqa ); free ( seqb ); free ( mark_mis ); free ( Cseqa ); free ( Cseqb ); free ( Cmark_mis ); return ( 1 ); }
int main(int argc, char **argv) { char id[UUID_STR_LEN + 1]; int cf_index, ret, type; Octstr *os, *store_type, *store_location, *status; Msg *msg; CfgGroup *grp; conf_file = NULL; gwlib_init(); //This can be overwritten with the -v flag at runtime log_set_output_level(DEFAULT_LOG_LEVEL); cf_index = get_and_set_debugs(argc, argv, check_args); if (argv[cf_index] == NULL) { print_usage(argv[0]); goto error; } if (conf_file == NULL) conf_file = octstr_create("kannel.conf"); cfg = cfg_create(conf_file); if (cfg_read(cfg) == -1) panic(0, "Couldn't read configuration from `%s'.", octstr_get_cstr(conf_file)); info(0, "1"); grp = cfg_get_single_group(cfg, octstr_imm("core")); if (grp == NULL) { printf("FATAL: Could not load Kannel's core group. Exiting.\n"); return 2; } store_location = cfg_get(grp, octstr_imm("store-location")); store_type = cfg_get(grp, octstr_imm("store-type")); store_init(store_type, store_location, -1, msg_pack, msg_unpack_wrapper); switch (command) { case COMMAND_LIST: printf("Listing records %d -> %d\n", list_from+1, list_limit); print_header(); store_load(print_msg); if (counter == 0) { printf("|%60s%14s%60s|\n", "", "Store is Empty", ""); } print_sep(); break; case COMMAND_DELETE: store_load(msg_count); msg = msg_create(ack); msg->ack.nack = ack_failed; msg->ack.time = time(NULL); uuid_parse(octstr_get_cstr(param_1), msg->ack.id); ret = store_save(msg); if (ret == 0) { printf("Deleted message %s\n", octstr_get_cstr(param_1)); counter--; } else { printf("Could not delete message %s\n", octstr_get_cstr(param_1)); } msg_destroy(msg); break; case COMMAND_EXPORT: counter = 0; type = 0; list = gwlist_create(); store_load(msg_push); printf("Exporting %ld messages...\n", gwlist_len(list)); if ((octstr_compare(param_1, octstr_imm("file")) == 0) || (octstr_compare(param_1, octstr_imm("spool")) == 0)) { store_shutdown(); store_init(param_1, param_2, -1, msg_pack, msg_unpack_wrapper); store_load(msg_count); while ((os = gwlist_extract_first(list)) != NULL) { msg = msg_unpack_wrapper(os); if (msg != NULL) { ret = store_save(msg); if (ret == 0) { counter++; } else { printf("Error saving message\n"); } } else { printf("Error extracting message\n"); } msg_destroy(msg); } status = NULL; } else if (octstr_compare(param_1, octstr_imm("text")) == 0) { status = store_status(BBSTATUS_TEXT); } else if (octstr_compare(param_1, octstr_imm("html")) == 0) { status = store_status(BBSTATUS_HTML); } else if (octstr_compare(param_1, octstr_imm("xml")) == 0) { status = store_status(BBSTATUS_XML); } else { status = NULL; } if (status != NULL) { file = fopen(octstr_get_cstr(param_2), "w"); if (file == NULL) { error(errno, "Failed to open '%s' for writing, cannot create output file", octstr_get_cstr(param_2)); return -1; } octstr_print(file, status); fflush(file); if (file != NULL) fclose(file); //printf("%s", octstr_get_cstr(status)); } gwlist_destroy(list, octstr_destroy_item); break; default: break; } octstr_destroy(store_type); octstr_destroy(store_location); cfg_destroy(cfg); store_shutdown(); error: gwlib_shutdown(); return 1; }
/* Creates the output file with the alignment */ unsigned int results ( const char * filename, /* output filename */ struct TSeq * t, /* text */ unsigned int n, /* length of t */ struct TSeq * p, /* pattern */ unsigned int m, /* length of p */ double max_score, unsigned int * gaps_pos, unsigned int l, unsigned int * gaps_len, unsigned int * where, unsigned int swap, unsigned int matrix, double gap_penalty, double ext_penalty, int L ) { FILE * output; unsigned int min_mis = 0; //the number of mismatches in the alignment char * seqa; //sequence a with the inserted gaps unsigned int aa = 0; unsigned int ii = 0; char * seqb; //sequence b with the inserted gaps unsigned int bb = 0; unsigned int jj = 0; char * mark_mis; //a string with the mismatches marked as '|' (and the matches as ' ') unsigned int mm = 0; unsigned int i; /* Here we calculate the number of gaps and their total length */ unsigned int numgaps = 0; unsigned int gapslength = 0; for ( i = 0; i < l; i ++ ) { if ( gaps_len[i] > 0 ) { numgaps++; gapslength += gaps_len[i]; } } //fprintf( stderr, "Score: %.2f Gaps: %d Length: %d\n", max_score, numgaps, gapslength ); /* dynamic memory allocation for the 3 sequences */ if ( ! ( seqa = ( char * ) calloc ( n + gapslength + 1, sizeof ( char ) ) ) ) { fprintf ( stderr, "Error: seqa could not be allocated!!!\n" ); return ( 0 ); } if ( ! ( seqb = ( char * ) calloc ( n + gapslength + 1, sizeof ( char ) ) ) ) { fprintf ( stderr, "Error: seqb could not be allocated!!!\n" ); return ( 0 ); } if ( ! ( mark_mis = ( char* ) calloc ( n + gapslength + 1, sizeof( char ) ) ) ) { fprintf ( stderr, "Error: mark_mis could not be allocated!!!\n" ); return ( 0 ); } /* Here we open the output file */ if ( ! ( output = fopen ( filename, "w" ) ) ) { fprintf ( stderr, "Error: cannot open file %s!!!\n", filename ); return ( 0 ); } /* Here we print the header */ print_header ( output, filename, matrix, gap_penalty, ext_penalty, L ); /* Here we go through the gaps to create the 2 sequences */ int g; unsigned int gapsuma = 0; //currently added gap length in seqa unsigned int gapsumb = 0; //currently added gap length in seqb for ( g = numgaps - 1; g >=0; g-- ) { if ( gaps_len[g] > 0 ) { unsigned int gpos = gaps_pos[g]; unsigned int glen = gaps_len[g]; if ( where[g] == 1 ) { /* Add the letters before the gap */ for ( ; ii < gpos; ii++, aa++ ) seqa[aa] = t -> data[ii]; /* Add the gap */ for ( ; aa < ii + gapsuma + glen; aa++ ) seqa[aa] = '-'; gapsuma += glen; } if ( where[g] == 2 ) { /* Add the letters before the gap */ for ( ; jj < gpos; jj++, bb++ ) seqb[bb] = p -> data[jj]; /* Add the gap */ for ( ; bb < jj + gapsumb + glen; bb++ ) seqb[bb] = '-'; gapsumb += glen; } } } /* Add what is left from both */ for ( ; ii < n; ii++, aa++ ) seqa[aa] = t -> data[ii]; seqa[aa] = '\0'; for ( ; jj < m; jj++, bb++ ) seqb[bb] = p -> data[jj]; seqb[bb] = '\0'; unsigned int alignlen = min ( aa, bb); for ( ; mm < alignlen; mm++ ) { if ( seqa[mm] == '-' || seqb[mm] == '-' ) mark_mis[mm] = ' '; else if ( seqa[mm] == seqb[mm] ) mark_mis[mm] = '|'; else { min_mis++; mark_mis[mm] = '.'; } } mark_mis[mm] = '\0'; free ( t -> data ); t -> data = seqa; free ( p -> data ); p -> data = seqb; if ( ! swap ) { wrap ( t, p, mark_mis, LINE_LNG, output ); } else { wrap ( p, t, mark_mis, LINE_LNG, output ); } fprintf ( output, "\n" ); fprintf ( output, "Alignment score: %lf\n", max_score ); fprintf ( output, "Number of mismatches: %d\n", min_mis ); fprintf ( output, "Number of gaps: %d\n", numgaps ); fprintf ( output, "Length of gaps: %d\n", gapslength ); if ( fclose ( output ) ) fprintf ( stderr, "Error: cannot close file %s!!!\n", filename ); free ( seqa ); free ( seqb ); free ( mark_mis ); return ( 1 ); }
void* readFile(void *arg) { struct readThreadArgs *rTA = (struct readThreadArgs*) arg; LASReaderH reader = NULL; LASHeaderH header = NULL; LASPointH p = NULL; unsigned int index = 0; int read_index = 0; char *file_name_in = NULL; int i, j; while(1) { file_name_in = NULL; /*Get next file to read*/ MT_set_lock(&dataLock); file_name_in = files_name_in[files_in_index]; if (file_name_in == NULL) { MT_unset_lock(&dataLock); return NULL; } read_index = (files_in_index % rTA->num_read_threads); files_in_index++; struct writeT *dataWriteTT = (struct writeT*) malloc(sizeof(struct writeT)*rTA->num_of_entries); /*Lets read the data*/ reader = LASReader_Create(file_name_in); if (!reader) { LASError_Print("Unable to read file"); MT_unset_lock(&dataLock); exit(1); } MT_unset_lock(&dataLock); header = LASReader_GetHeader(reader); if (!header) { LASError_Print("Unable to fetch header for file"); exit(1); } if (verbose) { print_header(stderr, header, file_name_in); } /*Allocate arrays for the columns*/ long num_points = LASHeader_GetPointRecordsCount(header); for (i = 0; i < rTA->num_of_entries; i++) { dataWriteTT[i].num_points = num_points; dataWriteTT[i].values = malloc(entriesType[i]*num_points); dataWriteTT[i].type = entriesType[i]; } /*Changes for Oscar's new Morton code function*/ //unsigned int factorX = (unsigned int) (LASHeader_GetOffsetX(header) / LASHeader_GetScaleX(header)); //unsigned int factorY = (unsigned int) (LASHeader_GetOffsetY(header) / LASHeader_GetScaleY(header)); /*Compute factors to add to X and Y and cehck sanity of generated codes*/ double file_scale_x = LASHeader_GetScaleX(header); double file_scale_y = LASHeader_GetScaleY(header); double file_scale_z = LASHeader_GetScaleZ(header); //printf("The scales are x:%lf y:%lf z:%lf\n", file_scale_x, file_scale_y, file_scale_z); /* scaled offsets to add for the morton encoding */ int64_t factorX = ((int64_t) (LASHeader_GetOffsetX(header) / file_scale_x)) - rTA->global_offset_x; int64_t factorY = ((int64_t) (LASHeader_GetOffsetY(header) / file_scale_y)) - rTA->global_offset_y; if (rTA->check) { // Check specified scales are like in the LAS file if (fabs(rTA->scale_x - file_scale_x) > TOLERANCE){ fprintf(stderr, "ERROR: x scale in input file (%lf) does not match specified x scale (%lf)\n",file_scale_x, rTA->scale_x); exit(1); } if (fabs(rTA->scale_y - file_scale_y) > TOLERANCE){ fprintf(stderr, "ERROR: y scale in input file (%lf) does not match specified y scale (%lf)\n",file_scale_y, rTA->scale_y); exit(1); } /* Check that the extent of the file (taking into account the global offset) * is within 0,2^31 */ double check_min_x = 1.0 + LASHeader_GetMinX(header) - (((double) rTA->global_offset_x) * rTA->scale_x); if (check_min_x < TOLERANCE) { fprintf(stderr, "ERROR: Specied X global offset is too large. (MinX - (GlobalX*ScaleX)) < 0\n"); exit(1); } double check_min_y = 1.0 + LASHeader_GetMinY(header) - (((double) rTA->global_offset_y) * rTA->scale_y); if (check_min_y < TOLERANCE) { fprintf(stderr, "ERROR: Specied Y global offset is too large. (MinY - (GlobalY*ScaleY)) < 0\n"); exit(1); } double check_max_x = LASHeader_GetMaxX(header) - (((double) rTA->global_offset_x) * rTA->scale_x); if (check_max_x > (MAX_INT_31 * rTA->scale_x)) { fprintf(stderr, "ERROR: Specied X global offset is too small. (MaxX - (GlobalX*ScaleX)) > (2^31)*ScaleX\n"); exit(1); } double check_max_y = LASHeader_GetMaxY(header) - (((double) rTA->global_offset_y) * rTA->scale_y); if (check_max_y > (MAX_INT_31 * rTA->scale_y)) { fprintf(stderr, "ERROR: Specied Y global offset is too small. (MaxY - (GlobalY*ScaleY)) > (2^31)*ScaleY\n"); exit(1); } } p = LASReader_GetNextPoint(reader); index = 0; while (p) { if (skip_invalid && !LASPoint_IsValid(p)) { if (verbose) { LASError_Print("Skipping writing invalid point..."); } p = LASReader_GetNextPoint(reader); index -=1; continue; } LASColorH color = NULL; for (j = 0; j < rTA->num_of_entries; j++) { uint64_t res; switch (entries[j]) { case ENTRY_x: case ENTRY_y: case ENTRY_z: ((double*) dataWriteTT[j].values)[index] = entriesFunc[j](p); //printf(" Point is:%lf\n", ((double*) dataWriteTT[j].values)[index]); break; case ENTRY_X: ((int*) dataWriteTT[j].values)[index] = entriesFunc[j](p) / file_scale_x; break; case ENTRY_Y: ((int*) dataWriteTT[j].values)[index] = entriesFunc[j](p) / file_scale_y; break; case ENTRY_Z: ((int*) dataWriteTT[j].values)[index] = entriesFunc[j](p) / file_scale_z; break; case ENTRY_k: entriesFunc[j](&res, p, factorX, factorY); ((int64_t*)dataWriteTT[j].values)[index] = res; break; case ENTRY_R: case ENTRY_G: case ENTRY_B: color = (color == NULL) ? LASPoint_GetColor(p) : color; dataWriteTT[j].values[index] = (double) entriesFunc[j](color); break; case ENTRY_M: dataWriteTT[j].values[index] = index; break; default: LASError_Print("las2col:readFile: Invalid Entry."); } } if (color != NULL) LASColor_Destroy(color); p = LASReader_GetNextPoint(reader); index +=1; } if (verbose) printf("Num of points:%d %ld for file:%s \n", index, num_points, file_name_in); /*Give the data to the writer threads*/ MT_set_lock(&dataLock); LASHeader_Destroy(header); header = NULL; LASReader_Destroy(reader); reader = NULL; /*TODO: make sure you are not overtaking other reading threads*/ while (data[read_index] != NULL) { MT_cond_wait(&readCond, &dataLock); } data[read_index] = dataWriteTT; /*Wake up the main*/ pthread_cond_broadcast(&mainCond); MT_unset_lock(&dataLock); } return NULL; }
int main(int argc, char *argv[]) { char cmd = '_'; unsigned char no_header = 0; int long_opt_ind = 0; int long_opt_val = 0; static struct option long_opts[] = { { "wii", no_argument, 0, 'w' }, { "neo2", no_argument, 0, 'q' }, { "neo3", no_argument, 0, 'z' }, { "sim", required_argument, 0, 's' }, { "config", required_argument, 0, 'd' }, { "gui", no_argument, 0, 'g' }, { "accel", no_argument, 0, 'a' }, { "new", required_argument, 0, 'n' }, { "view", required_argument, 0, 'o' }, { "train", required_argument, 0, 'e' }, { "record", required_argument, 0, 'r' }, { "upload", required_argument, 0, 'u' }, { "verbose", no_argument, 0, 'p' }, { "confirm", no_argument, 0, 'c' }, { "no-header", no_argument, 0, 'H' }, { "version", no_argument, 0, 'v' }, { "help", no_argument, 0, 'h' }, { 0, 0, 0, 0 } }; g_mode = console; g_dev = dev_none; dir[0] = '\0'; file[0] = '\0'; verbose = 0; confirm = 0; opterr = 0; while ((long_opt_val = getopt_long(argc, argv, "wqzsd:gan:o:e:rupcHvh", long_opts, &long_opt_ind)) != -1) { switch (long_opt_val) { case 'w': /* --wii */ g_dev = (g_dev == dev_none) ? dev_wii : g_dev; break; case 'q': /* --neo2 */ g_dev = (g_dev == dev_none) ? dev_neo2 : g_dev; break; case 'z': /* --neo3 */ g_dev = (g_dev == dev_none) ? dev_neo3 : g_dev; break; case 's': /* --sim */ g_dev = (g_dev == dev_none) ? dev_sim : g_dev; strncpy(sim_filename, optarg, sizeof(sim_filename)); sim_filename[sizeof(sim_filename) / sizeof(sim_filename[0]) - 1] = '\0'; break; case 'd': /* --config */ strncpy(dir, optarg, sizeof(dir)); dir[sizeof(dir) / sizeof(dir[0]) - 1] = '\0'; break; case 'n': /* --new */ case 'o': /* --view */ case 'e': /* --train */ case 'r': /* --record */ case 'u': /* --upload */ strncpy(file, optarg, sizeof(file)); file[sizeof(file) / sizeof(file[0]) - 1] = '\0'; case 'g': /* --gui */ case 'a': /* --accel */ cmd = long_opt_val; break; case 'p': /* --verbose */ verbose = 1; break; case 'c': /* --confirm */ confirm = 1; break; case 'H': /* no-header */ no_header = 1; break; case 'v': /* --version */ print_version(); exit(0); break; case 'h': /* --help */ case '?': print_usage(); exit(0); break; } } if (!no_header) { print_header(); } /* minimum requirements */ if ((g_dev == dev_none) || (dir[0] == '\0') || (cmd == '_')) { print_usage(); exit(1); } /* should be ok here */ if (cmd == 'g') /* --gui */ { g_mode = graphical; main_gui(argc, argv); } else if (cmd == 'u') { /* --upload */ chdir(dir); if (upload(file)) { printf("File '%s' uploaded successfully\n", file); fflush(stdout); } else { fprintf(stderr, "Sorry, could not upload file '%s'\n", file); fflush(stderr); exit(1); } } else { handshake(cmd); } dev_close(g_dev); return 0; }
ssize_t qb_rb_write_to_file(struct qb_ringbuffer_s * rb, int32_t fd) { ssize_t result; ssize_t written_size = 0; uint32_t hash = 0; uint32_t version = QB_RB_FILE_HEADER_VERSION; if (rb == NULL) { return -EINVAL; } print_header(rb); /* * 1. word_size */ result = write(fd, &rb->shared_hdr->word_size, sizeof(uint32_t)); if (result != sizeof(uint32_t)) { return -errno; } written_size += result; /* * 2. 3. store the read & write pointers */ result = write(fd, (void *)&rb->shared_hdr->write_pt, sizeof(uint32_t)); if (result != sizeof(uint32_t)) { return -errno; } written_size += result; result = write(fd, (void *)&rb->shared_hdr->read_pt, sizeof(uint32_t)); if (result != sizeof(uint32_t)) { return -errno; } written_size += result; /* * 4. version used */ result = write(fd, &version, sizeof(uint32_t)); if (result != sizeof(uint32_t)) { return -errno; } written_size += result; /* * 5. hash helps us verify header is not corrupted on file read */ hash = rb->shared_hdr->word_size + rb->shared_hdr->write_pt + rb->shared_hdr->read_pt + QB_RB_FILE_HEADER_VERSION; result = write(fd, &hash, sizeof(uint32_t)); if (result != sizeof(uint32_t)) { return -errno; } written_size += result; result = write(fd, rb->shared_data, rb->shared_hdr->word_size * sizeof(uint32_t)); if (result != rb->shared_hdr->word_size * sizeof(uint32_t)) { return -errno; } written_size += result; qb_util_log(LOG_DEBUG, " writing total of: %zd\n", written_size); return written_size; }
static int find_word_unified(const char *word, const regimen_t regimen, const char *dict_name, FILE *dict_fp) { wchar_t word_wc[MAX_WORD_SIZE]; wchar_t str_wc[MAX_WORD_SIZE]; char *str = NULL; size_t str_len = 0; long index_pos = -1; int translate_count = 0; bool break_end_flag = false; if ( strlen(word) < 1 ) return 0; if ( strncpy_lower_wc(word_wc, word, MAX_WORD_SIZE - 1) == NULL ) { fprintf(stderr, "Cannot convert \"%s\" to (wchar_t *): %s\n", word, strerror(errno)); return -1; } if ( regimen == usually_regimen || regimen == first_concurrence_regimen || list_regimen ) { index_pos = linear_index_pos(word_wc[0], dict_fp); if ( index_pos == 0 ) { return 0; } else if ( index_pos > 0 ) { if ( fseek(dict_fp, index_pos, SEEK_SET) != 0 ) fprintf(stderr, "Seek fail on index \"%lc %ld\": %s: ignored\n", word_wc[0], index_pos, strerror(errno)); } else { rewind(dict_fp); } } while ( getline(&str, &str_len, dict_fp) != -1 ) { if ( str[0] == '#' || str[0] == '\n' ) continue; if ( (str_wc[0] = first_lower_wc(str)) == L'\0' ) continue; if ( regimen == usually_regimen || regimen == first_concurrence_regimen || list_regimen ) { if ( word_wc[0] != str_wc[0] && break_end_flag ) break; if ( word_wc[0] != str_wc[0] ) continue; else break_end_flag = true; } if ( strncpy_lower_filter_wc(str_wc, str, MAX_WORD_SIZE - 1) == NULL ) { break_end_flag = false; // ill_defined_regimen not required this continue; } if ( regimen == usually_regimen ) { if ( !strcmp_full_wc(str_wc, word_wc) ) { ++translate_count; if ( translate_count == 1 ) print_header(dict_name, word_wc); print_translate(str, translate_count); if ( translate_count >= settings.max_translate_count ) break; } } else if ( regimen == first_concurrence_regimen ) { if ( !strcmp_noend_wc(str_wc, word_wc) ) { ++translate_count; if ( translate_count == 1 ) print_header(dict_name, word_wc); print_translate(str, translate_count); break; } } else if ( regimen == list_regimen ) { if ( !strcmp_noend_wc(str_wc, word_wc) ) { ++translate_count; if ( translate_count == 1 ) print_header(dict_name, word_wc); print_list_item(str_wc, translate_count); if ( translate_count >= settings.max_translate_count ) break; } } else if ( regimen == ill_defined_regimen ) { if ( !strcmp_jump_wc(str_wc, word_wc, settings.ill_defined_search_percent) ) { ++translate_count; if ( translate_count == 1 ) print_header(dict_name, word_wc); print_list_item(str_wc, translate_count); if ( translate_count >= settings.max_translate_count ) break; } } } free(str); return translate_count; }
qb_ringbuffer_t * qb_rb_create_from_file(int32_t fd, uint32_t flags) { ssize_t n_read; size_t n_required; size_t total_read = 0; uint32_t read_pt; uint32_t write_pt; struct qb_ringbuffer_s *rb; uint32_t word_size = 0; uint32_t version = 0; uint32_t hash = 0; uint32_t calculated_hash = 0; if (fd < 0) { return NULL; } /* * 1. word size */ n_required = sizeof(uint32_t); n_read = read(fd, &word_size, n_required); if (n_read != n_required) { qb_util_perror(LOG_ERR, "Unable to read blackbox file header"); return NULL; } total_read += n_read; /* * 2. 3. read & write pointers */ n_read = read(fd, &write_pt, sizeof(uint32_t)); assert(n_read == sizeof(uint32_t)); total_read += n_read; n_read = read(fd, &read_pt, sizeof(uint32_t)); assert(n_read == sizeof(uint32_t)); total_read += n_read; /* * 4. version */ n_required = sizeof(uint32_t); n_read = read(fd, &version, n_required); if (n_read != n_required) { qb_util_perror(LOG_ERR, "Unable to read blackbox file header"); return NULL; } total_read += n_read; /* * 5. Hash */ n_required = sizeof(uint32_t); n_read = read(fd, &hash, n_required); if (n_read != n_required) { qb_util_perror(LOG_ERR, "Unable to read blackbox file header"); return NULL; } total_read += n_read; calculated_hash = word_size + write_pt + read_pt + version; if (hash != calculated_hash) { qb_util_log(LOG_ERR, "Corrupt blackbox: File header hash (%d) does not match calculated hash (%d)", hash, calculated_hash); return NULL; } else if (version != QB_RB_FILE_HEADER_VERSION) { qb_util_log(LOG_ERR, "Wrong file header version. Expected %d got %d", QB_RB_FILE_HEADER_VERSION, version); return NULL; } /* * 6. data */ n_required = (word_size * sizeof(uint32_t)); /* * qb_rb_open adds QB_RB_CHUNK_MARGIN + 1 to the requested size. */ rb = qb_rb_open("create_from_file", n_required - (QB_RB_CHUNK_MARGIN + 1), QB_RB_FLAG_CREATE | QB_RB_FLAG_NO_SEMAPHORE, 0); if (rb == NULL) { return NULL; } rb->shared_hdr->read_pt = read_pt; rb->shared_hdr->write_pt = write_pt; n_read = read(fd, rb->shared_data, n_required); if (n_read < 0) { qb_util_perror(LOG_ERR, "Unable to read blackbox file data"); goto cleanup_fail; } total_read += n_read; if (n_read != n_required) { qb_util_log(LOG_WARNING, "read %zd bytes, but expected %zu", n_read, n_required); goto cleanup_fail; } qb_util_log(LOG_DEBUG, "read total of: %zd", total_read); print_header(rb); return rb; cleanup_fail: qb_rb_close(rb); return NULL; }
int main(int argc, char *argv[]) { int i, numprocs, rank, size, align_size, disp; int skip; double latency = 0.0, t_start = 0.0, t_stop = 0.0; double timer=0.0; int max_msg_size = 1048576, full = 0; uint64_t requested_mem_limit = 0; double avg_time = 0.0, max_time = 0.0, min_time = 0.0; char *sendbuf, *recvbuf, *s_buf1, *r_buf1; int *rdispls, *recvcounts; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &numprocs); if (process_args(argc, argv, rank, &max_msg_size, &full)) { MPI_Finalize(); return EXIT_SUCCESS; } if(numprocs < 2) { if(rank == 0) { fprintf(stderr, "This test requires at least two processes\n"); } MPI_Finalize(); return EXIT_FAILURE; } requested_mem_limit = (uint64_t) (max_msg_size) * numprocs; if( requested_mem_limit > max_mem_limit) { max_msg_size = max_mem_limit/numprocs; } print_header(rank, full); recvcounts=rdispls=NULL; recvcounts = (int *) malloc (numprocs*sizeof(int)); if(NULL == recvcounts) { fprintf(stderr, "malloc failed.\n"); exit(1); } rdispls = (int *) malloc (numprocs*sizeof(int)); if(NULL == rdispls) { fprintf(stderr, "malloc failed.\n"); exit(1); } s_buf1 = r_buf1 = NULL; s_buf1 = (char *) malloc(sizeof(char)*max_msg_size + MAX_ALIGNMENT); if(NULL == s_buf1) { fprintf(stderr, "malloc failed.\n"); exit(1); } r_buf1 = (char *) malloc(sizeof(char)*max_msg_size * numprocs + MAX_ALIGNMENT); if(NULL == r_buf1) { fprintf(stderr, "malloc failed.\n"); exit(1); } align_size = getpagesize(); sendbuf = (char *)(((unsigned long) s_buf1 + (align_size - 1)) / align_size * align_size); recvbuf = (char *)(((unsigned long) r_buf1 + (align_size - 1)) / align_size * align_size); memset(sendbuf, 1, max_msg_size); memset(recvbuf, 0, max_msg_size * numprocs); for(size=1; size <= max_msg_size; size *= 2) { if(size > LARGE_MESSAGE_SIZE) { skip = SKIP_LARGE; iterations = iterations_large; } else { skip = SKIP; } MPI_Barrier(MPI_COMM_WORLD); disp =0; for ( i = 0; i < numprocs; i++) { recvcounts[i] = size; rdispls[i] = disp; disp += size; } MPI_Barrier(MPI_COMM_WORLD); timer=0.0; for(i=0; i < iterations + skip ; i++) { t_start = MPI_Wtime(); MPI_Gatherv(sendbuf, size, MPI_CHAR, recvbuf, recvcounts, rdispls, MPI_CHAR, 0, MPI_COMM_WORLD); t_stop = MPI_Wtime(); if(i >= skip) { timer+= t_stop-t_start; } MPI_Barrier(MPI_COMM_WORLD); } MPI_Barrier(MPI_COMM_WORLD); latency = (double)(timer * 1e6) / iterations; MPI_Reduce(&latency, &min_time, 1, MPI_DOUBLE, MPI_MIN, 0, MPI_COMM_WORLD); MPI_Reduce(&latency, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD); MPI_Reduce(&latency, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); avg_time = avg_time/numprocs; print_data(rank, full, size, avg_time, min_time, max_time, iterations); MPI_Barrier(MPI_COMM_WORLD); } free(s_buf1); free(r_buf1); free(recvcounts); free(rdispls); MPI_Finalize(); return EXIT_SUCCESS; }
/* * Create a spoiler file for artifacts */ static void spoil_artifact(void) { int i, j; object_type forge; object_type *q_ptr; const bool old_spoil_art = spoil_art; const bool old_spoil_base = spoil_base; const bool old_cheat_item = cheat_item; /* Use full spoilers, but no cheating. */ spoil_art = spoil_base = TRUE; cheat_item = FALSE; /* Dump the header */ print_header(); /* List the artifacts by tval */ for (i = 0; group_artifact[i].idx; i++) { /* Write out the group title */ if (group_artifact[i].str) { spoiler_blanklines(2); spoiler_underline(group_artifact[i].str); spoiler_blanklines(1); } /* Now search through all of the artifacts */ for (j = 1; j < MAX_A_IDX; ++j) { artifact_type *a_ptr = &a_info[j]; /* We only want objects in the current group */ if (k_info[a_ptr->k_idx].tval != group_artifact[i].idx) continue; /* Get local object */ q_ptr = &forge; /* Wipe the object */ object_wipe(q_ptr); /* Attempt to "forge" the artifact */ if (!make_fake_artifact(q_ptr, j)) continue; /* Know most things about the object. */ object_known(q_ptr); my_fprintf(fff, "%v\n", object_desc_f3, q_ptr, OD_ART | OD_SHOP, 1); /* Describe the artifact in a relatively brief way. */ identify_fully_file(q_ptr, fff, TRUE); /* Provide some allocation data. */ fprintf(fff, " Level %d", a_ptr->level); if (a_ptr->level2 && a_ptr->level2 != a_ptr->level) { fprintf(fff, "/%d", a_ptr->level2); } fprintf(fff, ", Rarity %d, %d.%d lbs, %ld Gold\n", a_ptr->rarity, a_ptr->weight/10, a_ptr->weight%10, a_ptr->cost); } } /* Reset spoilers. */ spoil_art = old_spoil_art; spoil_base = old_spoil_base; cheat_item = old_cheat_item; }
int main(int argc, char **argv) { struct insert_data idata; PGresult *ret; FILE *f; unsigned char fbuf[SRVBUFLEN]; char logfile[SRVBUFLEN]; char default_pwd[] = "arealsmartpwd"; int have_pwd = 0, have_logfile = 0, n; int result = 0, position = 0, howmany = 0; int do_nothing = 0; char *cl_sql_host = NULL, *cl_sql_user = NULL, *cl_sql_db = NULL, *cl_sql_table = NULL; char *sql_host; struct template_entry *teptr; int tot_size = 0, cnt = 0; u_char *te; struct template_header th; struct db_cache data; /* getopt() stuff */ extern char *optarg; extern int optind, opterr, optopt; int errflag = 0, cp; memset(&idata, 0, sizeof(idata)); memset(sql_data, 0, sizeof(sql_data)); memset(update_clause, 0, sizeof(update_clause)); memset(insert_clause, 0, sizeof(insert_clause)); memset(lock_clause, 0, sizeof(lock_clause)); memset(where, 0, sizeof(where)); memset(values, 0, sizeof(values)); memset(&data, 0, sizeof(data)); memset(timebuf, 0, sizeof(timebuf)); pp_size = sizeof(struct db_cache); while (!errflag && ((cp = getopt(argc, argv, ARGS)) != -1)) { switch (cp) { case 'd': debug = TRUE; break; case 'f': strlcpy(logfile, optarg, sizeof(logfile)); have_logfile = TRUE; break; case 'o': position = atoi(optarg); if (!position) { printf("ERROR: invalid offset. Exiting.\n"); exit(1); } break; case 'n': howmany = atoi(optarg); if (!howmany) { printf("ERROR: invalid number of elements. Exiting.\n"); exit(1); } break; case 't': do_nothing = TRUE; break; case 'i': sql_dont_try_update = TRUE; break; case 'e': sql_history_since_epoch = TRUE; break; case 'P': strlcpy(sql_pwd, optarg, sizeof(sql_pwd)); have_pwd = TRUE; break; case 'U': cl_sql_user = malloc(SRVBUFLEN); memset(cl_sql_user, 0, SRVBUFLEN); strlcpy(cl_sql_user, optarg, SRVBUFLEN); break; case 'D': cl_sql_db = malloc(SRVBUFLEN); memset(cl_sql_db, 0, SRVBUFLEN); strlcpy(cl_sql_db, optarg, SRVBUFLEN); break; case 'H': cl_sql_host = malloc(SRVBUFLEN); memset(cl_sql_host, 0, SRVBUFLEN); strlcpy(cl_sql_host, optarg, SRVBUFLEN); break; case 'T': cl_sql_table = malloc(SRVBUFLEN); memset(cl_sql_table, 0, SRVBUFLEN); strlcpy(cl_sql_table, optarg, SRVBUFLEN); break; case 'h': usage(argv[0]); exit(0); break; default: usage(argv[0]); exit(1); } } /* searching for user supplied values */ if (!howmany) howmany = -1; if (!have_pwd) memcpy(sql_pwd, default_pwd, sizeof(default_pwd)); if (!have_logfile) { usage(argv[0]); printf("\nERROR: missing logfile (-f)\nExiting...\n"); exit(1); } f = fopen(logfile, "r"); if (!f) { printf("ERROR: %s does not exists\nExiting...\n", logfile); exit(1); } fread(&lh, sizeof(lh), 1, f); lh.sql_table_version = ntohs(lh.sql_table_version); lh.sql_optimize_clauses = ntohs(lh.sql_optimize_clauses); lh.sql_history = ntohs(lh.sql_history); lh.what_to_count = ntohl(lh.what_to_count); lh.magic = ntohl(lh.magic); if (lh.magic == MAGIC) { if (debug) printf("OK: Valid logfile header read.\n"); printf("sql_db: %s\n", lh.sql_db); printf("sql_table: %s\n", lh.sql_table); printf("sql_user: %s\n", lh.sql_user); printf("sql_host: %s\n", lh.sql_host); if (cl_sql_db||cl_sql_table||cl_sql_user||cl_sql_host) printf("OK: Overrided by commandline options:\n"); if (cl_sql_db) printf("sql_db: %s\n", cl_sql_db); if (cl_sql_table) printf("sql_table: %s\n", cl_sql_table); if (cl_sql_user) printf("sql_user: %s\n", cl_sql_user); if (cl_sql_host) printf("sql_host: %s\n", cl_sql_host); } else { printf("ERROR: Invalid magic number. Exiting.\n"); exit(1); } /* binding SQL stuff */ if (cl_sql_db) sql_db = cl_sql_db; else sql_db = lh.sql_db; if (cl_sql_table) sql_table = cl_sql_table; else sql_table = lh.sql_table; if (cl_sql_user) sql_user = cl_sql_user; else sql_user = lh.sql_user; if (cl_sql_host) sql_host = cl_sql_host; else sql_host = lh.sql_host; fread(&th, sizeof(th), 1, f); th.magic = ntohl(th.magic); th.num = ntohs(th.num); th.sz = ntohs(th.sz); if (th.magic == TH_MAGIC) { if (debug) printf("OK: Valid template header read.\n"); if (th.num > N_PRIMITIVES) { printf("ERROR: maximum number of primitives exceeded. Exiting.\n"); exit(1); } te = malloc(th.num*sizeof(struct template_entry)); memset(te, 0, th.num*sizeof(struct template_entry)); fread(te, th.num*sizeof(struct template_entry), 1, f); } else { if (debug) printf("ERROR: no template header found.\n"); exit(1); } /* checking template */ if (th.sz >= sizeof(fbuf)) { printf("ERROR: Objects are too big. Exiting.\n"); exit(1); } teptr = (struct template_entry *) te; for (tot_size = 0, cnt = 0; cnt < th.num; cnt++, teptr++) tot_size += teptr->size; if (tot_size != th.sz) { printf("ERROR: malformed template header. Size mismatch. Exiting.\n"); exit(1); } TPL_check_sizes(&th, &data, te); if (!do_nothing) { PG_compose_conn_string(&p, sql_host); if (!PG_DB_Connect2(&p)) { printf("ALERT: PG_DB_Connect2(): PGSQL daemon failed.\n"); exit(1); } } else { if (debug) print_header(); } /* composing the proper (filled with primitives used during the current execution) SQL strings */ idata.num_primitives = PG_compose_static_queries(); idata.now = time(NULL); /* handling offset */ if (position) n = fseek(f, (th.sz*position), SEEK_CUR); /* handling single or iterative request */ if (!do_nothing) ret = PQexec(p.desc, lock_clause); while(!feof(f)) { if (!howmany) break; else if (howmany > 0) howmany--; memset(fbuf, 0, th.sz); n = fread(fbuf, th.sz, 1, f); if (n) { re++; TPL_pop(fbuf, &data, &th, te); if (!do_nothing) result = PG_cache_dbop(&p, &data, &idata); else { if (debug) print_data(&data, lh.what_to_count, (position+re)); } if (!result) we++; if (re != we) printf("WARN: unable to write element %u.\n", re); } } if (!do_nothing) { ret = PQexec(p.desc, "COMMIT"); if (PQresultStatus(ret) != PGRES_COMMAND_OK) { we = 0; /* if we fail to commit, no elements will be written */ PQclear(ret); } printf("\nOK: written [%u/%u] elements.\n", we, re); } else printf("OK: read [%u] elements.\n", re); PQfinish(p.desc); fclose(f); return 0; }
void wallcycle_print(FILE *fplog, int nnodes, int npme, double realtime, gmx_wallcycle_t wc, wallclock_gpu_t *gpu_t) { double *cyc_sum; double tot, tot_for_pp, tot_for_rest, tot_gpu, tot_cpu_overlap, gpu_cpu_ratio, tot_k; double c2t, c2t_pp, c2t_pme; int i, j, npp, nth_pp, nth_pme, nth_tot; char buf[STRLEN]; const char *hline = "-----------------------------------------------------------------------------"; if (wc == NULL) { return; } nth_pp = wc->nthreads_pp; nth_pme = wc->nthreads_pme; cyc_sum = wc->cycles_sum; npp = nnodes - npme; nth_tot = npp*nth_pp + npme*nth_pme; /* When using PME-only nodes, the next line is valid for both PP-only and PME-only nodes because they started ewcRUN at the same time. */ tot = cyc_sum[ewcRUN]; tot_for_pp = 0; /* Conversion factor from cycles to seconds */ if (tot > 0) { c2t = realtime/tot; c2t_pp = c2t * nth_tot / (double) (npp*nth_pp); c2t_pme = c2t * nth_tot / (double) (npme*nth_pme); } else { c2t = 0; c2t_pp = 0; c2t_pme = 0; } fprintf(fplog, "\n R E A L C Y C L E A N D T I M E A C C O U N T I N G\n\n"); print_header(fplog, npp, nth_pp, npme, nth_pme); fprintf(fplog, "%s\n", hline); for (i = ewcPPDURINGPME+1; i < ewcNR; i++) { if (is_pme_subcounter(i)) { /* Do not count these at all */ } else if (npme > 0 && is_pme_counter(i)) { /* Print timing information for PME-only nodes, but add an * asterisk so the reader of the table can know that the * walltimes are not meant to add up. The asterisk still * fits in the required maximum of 19 characters. */ char buffer[STRLEN]; snprintf(buffer, STRLEN, "%s *", wcn[i]); print_cycles(fplog, c2t_pme, buffer, npme, nth_pme, wc->wcc[i].n, cyc_sum[i], tot); } else { /* Print timing information when it is for a PP or PP+PME node */ print_cycles(fplog, c2t_pp, wcn[i], npp, nth_pp, wc->wcc[i].n, cyc_sum[i], tot); tot_for_pp += cyc_sum[i]; } } if (wc->wcc_all != NULL) { for (i = 0; i < ewcNR; i++) { for (j = 0; j < ewcNR; j++) { snprintf(buf, 20, "%-9.9s %-9.9s", wcn[i], wcn[j]); print_cycles(fplog, c2t_pp, buf, npp, nth_pp, wc->wcc_all[i*ewcNR+j].n, wc->wcc_all[i*ewcNR+j].c, tot); } } } tot_for_rest = tot * (npp * nth_pp) / (double) nth_tot; print_cycles(fplog, c2t_pp, "Rest", npp, nth_pp, -1, tot_for_rest - tot_for_pp, tot); fprintf(fplog, "%s\n", hline); print_cycles(fplog, c2t, "Total", npp, nth_pp, -1, tot, tot); fprintf(fplog, "%s\n", hline); if (npme > 0) { fprintf(fplog, "(*) Note that with separate PME ranks, the walltime column actually sums to\n" " twice the total reported, but the cycle count total and %% are correct.\n" "%s\n", hline); } if (wc->wcc[ewcPMEMESH].n > 0) { fprintf(fplog, " Breakdown of PME mesh computation\n"); fprintf(fplog, "%s\n", hline); for (i = ewcPPDURINGPME+1; i < ewcNR; i++) { if (is_pme_subcounter(i)) { print_cycles(fplog, npme > 0 ? c2t_pme : c2t_pp, wcn[i], npme > 0 ? npme : npp, nth_pme, wc->wcc[i].n, cyc_sum[i], tot); } } fprintf(fplog, "%s\n", hline); } #ifdef GMX_CYCLE_SUBCOUNTERS fprintf(fplog, " Breakdown of PP computation\n"); fprintf(fplog, "%s\n", hline); for (i = 0; i < ewcsNR; i++) { print_cycles(fplog, c2t_pp, wcsn[i], npp, nth_pp, wc->wcsc[i].n, cyc_sum[ewcNR+i], tot); } fprintf(fplog, "%s\n", hline); #endif /* print GPU timing summary */ if (gpu_t) { const char *k_log_str[2][2] = { {"Nonbonded F kernel", "Nonbonded F+ene k."}, {"Nonbonded F+prune k.", "Nonbonded F+ene+prune k."} }; tot_gpu = gpu_t->pl_h2d_t + gpu_t->nb_h2d_t + gpu_t->nb_d2h_t; /* add up the kernel timings */ tot_k = 0.0; for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { tot_k += gpu_t->ktime[i][j].t; } } tot_gpu += tot_k; tot_cpu_overlap = wc->wcc[ewcFORCE].c; if (wc->wcc[ewcPMEMESH].n > 0) { tot_cpu_overlap += wc->wcc[ewcPMEMESH].c; } tot_cpu_overlap *= realtime*1000/tot; /* convert s to ms */ fprintf(fplog, "\n GPU timings\n%s\n", hline); fprintf(fplog, " Computing: Count Wall t (s) ms/step %c\n", '%'); fprintf(fplog, "%s\n", hline); print_gputimes(fplog, "Pair list H2D", gpu_t->pl_h2d_c, gpu_t->pl_h2d_t, tot_gpu); print_gputimes(fplog, "X / q H2D", gpu_t->nb_c, gpu_t->nb_h2d_t, tot_gpu); for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { if (gpu_t->ktime[i][j].c) { print_gputimes(fplog, k_log_str[i][j], gpu_t->ktime[i][j].c, gpu_t->ktime[i][j].t, tot_gpu); } } } print_gputimes(fplog, "F D2H", gpu_t->nb_c, gpu_t->nb_d2h_t, tot_gpu); fprintf(fplog, "%s\n", hline); print_gputimes(fplog, "Total ", gpu_t->nb_c, tot_gpu, tot_gpu); fprintf(fplog, "%s\n", hline); gpu_cpu_ratio = tot_gpu/tot_cpu_overlap; fprintf(fplog, "\nForce evaluation time GPU/CPU: %.3f ms/%.3f ms = %.3f\n", tot_gpu/gpu_t->nb_c, tot_cpu_overlap/wc->wcc[ewcFORCE].n, gpu_cpu_ratio); /* only print notes related to CPU-GPU load balance with PME */ if (wc->wcc[ewcPMEMESH].n > 0) { fprintf(fplog, "For optimal performance this ratio should be close to 1!\n"); /* print note if the imbalance is high with PME case in which * CPU-GPU load balancing is possible */ if (gpu_cpu_ratio < 0.75 || gpu_cpu_ratio > 1.2) { /* Only the sim master calls this function, so always print to stderr */ if (gpu_cpu_ratio < 0.75) { if (npp > 1) { /* The user could have used -notunepme, * but we currently can't check that here. */ md_print_warn(NULL, fplog, "\nNOTE: The GPU has >25%% less load than the CPU. This imbalance causes\n" " performance loss. Maybe the domain decomposition limits the PME tuning.\n" " In that case, try setting the DD grid manually (-dd) or lowering -dds."); } else { /* We should not end up here, unless the box is * too small for increasing the cut-off for PME tuning. */ md_print_warn(NULL, fplog, "\nNOTE: The GPU has >25%% less load than the CPU. This imbalance causes\n" " performance loss."); } } if (gpu_cpu_ratio > 1.2) { md_print_warn(NULL, fplog, "\nNOTE: The GPU has >20%% more load than the CPU. This imbalance causes\n" " performance loss, consider using a shorter cut-off and a finer PME grid."); } } } } if (wc->wcc[ewcNB_XF_BUF_OPS].n > 0 && (cyc_sum[ewcDOMDEC] > tot*0.1 || cyc_sum[ewcNS] > tot*0.1)) { /* Only the sim master calls this function, so always print to stderr */ if (wc->wcc[ewcDOMDEC].n == 0) { md_print_warn(NULL, fplog, "NOTE: %d %% of the run time was spent in pair search,\n" " you might want to increase nstlist (this has no effect on accuracy)\n", (int)(100*cyc_sum[ewcNS]/tot+0.5)); } else { md_print_warn(NULL, fplog, "NOTE: %d %% of the run time was spent in domain decomposition,\n" " %d %% of the run time was spent in pair search,\n" " you might want to increase nstlist (this has no effect on accuracy)\n", (int)(100*cyc_sum[ewcDOMDEC]/tot+0.5), (int)(100*cyc_sum[ewcNS]/tot+0.5)); } } if (cyc_sum[ewcMoveE] > tot*0.05) { /* Only the sim master calls this function, so always print to stderr */ md_print_warn(NULL, fplog, "NOTE: %d %% of the run time was spent communicating energies,\n" " you might want to use the -gcom option of mdrun\n", (int)(100*cyc_sum[ewcMoveE]/tot+0.5)); } }
static void cross_check_gts(args_t *args) { int nsamples = bcf_hdr_nsamples(args->sm_hdr), ndp_arr = 0; unsigned int *dp = (unsigned int*) calloc(nsamples,sizeof(unsigned int)), *ndp = (unsigned int*) calloc(nsamples,sizeof(unsigned int)); // this will overflow one day... int fake_pls = args->no_PLs, ignore_dp = 0; int i,j,k,idx, pl_warned = 0, dp_warned = 0; int32_t *dp_arr = NULL; int *is_hom = args->hom_only ? (int*) malloc(sizeof(int)*nsamples) : NULL; if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "PL")<0 ) { if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "GT")<0 ) error("[E::%s] Neither PL nor GT present in the header of %s\n", __func__, args->files->readers[0].fname); if ( !args->no_PLs ) fprintf(pysamerr,"Warning: PL not present in the header of %s, using GT instead\n", args->files->readers[0].fname); fake_pls = 1; } if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "DP")<0 ) ignore_dp = 1; FILE *fp = args->plot ? open_file(NULL, "w", "%s.tab", args->plot) : stdout; print_header(args, fp); if ( args->all_sites ) fprintf(fp,"# [1]SD, Average Site Discordance\t[2]Chromosome\t[3]Position\t[4]Number of available pairs\t[5]Average discordance\n"); while ( bcf_sr_next_line(args->files) ) { bcf1_t *line = args->files->readers[0].buffer[0]; bcf_unpack(line, BCF_UN_FMT); int npl; if ( !fake_pls ) { npl = bcf_get_format_int32(args->sm_hdr, line, "PL", &args->pl_arr, &args->npl_arr); if ( npl<=0 ) { pl_warned++; continue; } npl /= nsamples; } else npl = fake_PLs(args, args->sm_hdr, line); int mdp = 0; if ( !ignore_dp && (mdp=bcf_get_format_int32(args->sm_hdr, line, "DP", &dp_arr, &ndp_arr)) <= 0 ) dp_warned++; if ( args->hom_only ) { for (i=0; i<nsamples; i++) is_hom[i] = is_hom_most_likely(line->n_allele, args->pl_arr+i*npl); } double sum = 0; int nsum = 0; idx = 0; for (i=0; i<nsamples; i++) { int *ipl = &args->pl_arr[i*npl]; if ( *ipl==-1 ) { idx += i; continue; } // missing genotype if ( mdp>0 && (dp_arr[i]==bcf_int32_missing || !dp_arr[i]) ) { idx += i; continue; } if ( args->hom_only && !is_hom[i] ) { idx += i; continue; } for (j=0; j<i; j++) { int *jpl = &args->pl_arr[j*npl]; if ( *jpl==-1 ) { idx++; continue; } // missing genotype if ( mdp>0 && (dp_arr[j]==bcf_int32_missing || !dp_arr[j]) ) { idx++; continue; } if ( args->hom_only && !is_hom[j] ) { idx++; continue; } int min_pl = INT_MAX; for (k=0; k<npl; k++) { if ( ipl[k]==bcf_int32_missing || jpl[k]==bcf_int32_missing ) break; if ( ipl[k]==bcf_int32_vector_end || jpl[k]==bcf_int32_vector_end ) { k = npl; break; } if ( min_pl > ipl[k]+jpl[k] ) min_pl = ipl[k]+jpl[k]; } if ( k!=npl ) { idx++; continue; } if ( args->all_sites ) { sum += min_pl; nsum++; } args->lks[idx] += min_pl; args->cnts[idx]++; if ( mdp>0 ) { args->dps[idx] += dp_arr[i] < dp_arr[j] ? dp_arr[i] : dp_arr[j]; dp[i] += dp_arr[i]; ndp[i]++; dp[j] += dp_arr[j]; ndp[j]++; } else { args->dps[idx]++; dp[i]++; ndp[i]++; dp[j]++; ndp[j]++; } idx++; } } if ( args->all_sites ) fprintf(fp,"SD\t%s\t%d\t%d\t%.0f\n", args->sm_hdr->id[BCF_DT_CTG][line->rid].key, line->pos+1, nsum, nsum?sum/nsum:0); } if ( dp_arr ) free(dp_arr); if ( args->pl_arr ) free(args->pl_arr); if ( args->tmp_arr ) free(args->tmp_arr); if ( is_hom ) free(is_hom); if ( pl_warned ) fprintf(pysamerr, "[W::%s] PL was not found at %d site(s)\n", __func__, pl_warned); if ( dp_warned ) fprintf(pysamerr, "[W::%s] DP was not found at %d site(s)\n", __func__, dp_warned); // Output samples sorted by average discordance double *score = (double*) calloc(nsamples,sizeof(double)); args->sites = (double*) calloc(nsamples,sizeof(double)); idx = 0; for (i=0; i<nsamples; i++) { for (j=0; j<i; j++) { score[i] += args->lks[idx]; score[j] += args->lks[idx]; args->sites[i] += args->cnts[idx]; args->sites[j] += args->cnts[idx]; idx++; } } for (i=0; i<nsamples; i++) if ( args->sites[i] ) score[i] /= args->sites[i]; double **p = (double**) malloc(sizeof(double*)*nsamples), avg_score = 0; for (i=0; i<nsamples; i++) p[i] = &score[i]; qsort(p, nsamples, sizeof(int*), cmp_doubleptr); // The average discordance gives the number of differing sites in % with -G1 fprintf(fp, "# [1]SM\t[2]Average Discordance\t[3]Average depth\t[4]Average number of sites\t[5]Sample\t[6]Sample ID\n"); for (i=0; i<nsamples; i++) { idx = p[i] - score; double adp = ndp[idx] ? (double)dp[idx]/ndp[idx] : 0; double nsites = args->sites[idx]/(nsamples-1); avg_score += score[idx]; fprintf(fp, "SM\t%f\t%.2lf\t%.0lf\t%s\t%d\n", score[idx]*100., adp, nsites, args->sm_hdr->samples[idx],i); } // // Overall score: maximum absolute deviation from the average score // fprintf(fp, "# [1] MD\t[2]Maximum deviation\t[3]The culprit\n"); // fprintf(fp, "MD\t%f\t%s\n", (score[idx] - avg_score/nsamples)*100., args->sm_hdr->samples[idx]); // idx still set free(p); free(score); free(dp); free(ndp); // Pairwise discordances fprintf(fp, "# [1]CN\t[2]Discordance\t[3]Number of sites\t[4]Average minimum depth\t[5]Sample i\t[6]Sample j\n"); idx = 0; for (i=0; i<nsamples; i++) { for (j=0; j<i; j++) { fprintf(fp, "CN\t%.0f\t%d\t%.2f\t%s\t%s\n", args->lks[idx], args->cnts[idx], args->cnts[idx]?(double)args->dps[idx]/args->cnts[idx]:0.0, args->sm_hdr->samples[i],args->sm_hdr->samples[j]); idx++; } } fclose(fp); if ( args->plot ) plot_cross_check(args); }
/* exe_commande Descr: Execute les différentes opérations demandés par l'utilisateur Param: - c: Commande (voir #define ci dessus) - nomfichier: Nom du fichier à lire - nm_index: Argument de l'option -x, NULL si l'option n'a pas été choisis Return: Etat de sortie de la fonction: - -1: Impossible d'ouvrir le fichier donné - 0: Ouverture du fichier réussi */ int exe_commande(unsigned char c, char *nomfichier,char* nm_index) { if (nomfichier==NULL) return NOMFICHIERNULL; FILE *f; Elf32_Ehdr header; Elf32_Shdr *section_header_table; Elf32_Sym *symbol_tab; sectioncontent section; int nbSym = 0; int valid = 0; f = fopen(nomfichier,"r"); // Ouverture du fichier nomfichier if(f == NULL) { // Echec d'ouverture return FICHIERINEXISTANT; } else { /* Lecture Header */ header = read_header(f,&valid); if(valid==1) { // Header valide /* Lecture Table de section header */ section_header_table = read_section_header_table(f,header); /* Lecture Table des symboles */ symbol_tab = read_symbol_table(f ,section_header_table, header, &nbSym); if(c&COMMANDE_HEAD) //COMMANDE_HEAD { printf("ELF Header:\n"); print_header(header); printf("\n"); } if(c&COMMANDE_SECTIONTAB)//COMMANDE_SECTIONTAB { printf("Section Headers:\n"); print_section_header_table(f,section_header_table,header); printf("\n"); } if(c&COMMANDE_CONTENT)//COMMANDE_CONTENT { printf("Section %s content:\n", nm_index); section = read_section_content(f,nm_index, section_header_table, header); if(section.content==NULL) { printf("Warning, section : %s,was not dumped because it does not exist \n",nm_index); } else { print_section_content(section); } } if(c&COMMANDE_RELOC)//COMMANDE_RELOC { print_all_reloc_table(f, header, section_header_table, symbol_tab); printf("\n"); } if(c&COMMANDE_SYM)//COMMANDE_SYM { printf("Symbol table\n"); print_symbol_table(symbol_tab, nbSym, f, section_header_table, header); freeSymbolTable(symbol_tab); } } else // Header non valide { if(valid ==-1) { // Fichier non valid (vide ou autre) return FILEEMPTY;fprintf(stderr, "%s : Error while reading the file (possibly empty)\n",nomfichier); } else if(valid==0) { //Fichier pas au format elf32 return NOTELF32; } else { // Cas normalement impossible fprintf(stderr, "Impossible error append\n"); } } fclose(f); // Fermeture du fichier } return 0; }
int request_custom_command(buffer* recv_buf, server_stat* status) { unsigned char http_message[1000]; // used to hold http message from robot buffer* http_data = create_buffer(BUFFER_LEN); int n, retries; cst_header request_header; // header from the client buffer* response; // buffer to send to client struct timeval timeout; timeout.tv_sec = 0; timeout.tv_usec = 500000; fprintf(stdout, "\tProcessing request\n"); // acknowledgement of command to client udp_send(recv_buf, status); // create the http request memset(http_message, '\0', 1000); request_header = extract_custom_header(recv_buf); switch (request_header.data[CST_COMMAND]) { case IMAGE: fprintf(stdout, "\t\tContacting image port\n"); snprintf((char*)http_message, 100, "GET /snapshot?topic=/robot_%d/image?width=600?height=500 HTTP/1.1\r\n\r\n", status->r_stat.id); status->r_stat.http_sock = tcp_connect(status->r_stat.hostname, IMAGE_PORT); break; case GPS: fprintf(stdout, "\t\tContacting gps port\n"); snprintf((char*)http_message, 100, "GET /state?id=%s HTTP/1.1\r\n\r\n", status->r_stat.name); status->r_stat.http_sock = tcp_connect(status->r_stat.hostname, GPS_PORT); break; case LASERS: fprintf(stdout, "\t\tContacting lasers port\n"); snprintf((char*)http_message, 100, "GET /state?id=%s HTTP/1.1\r\n\r\n", status->r_stat.name); status->r_stat.http_sock = tcp_connect(status->r_stat.hostname, LASERS_PORT); break; case dGPS: fprintf(stdout, "\t\tContacting dgps port\n"); snprintf((char*)http_message, 100, "GET /state?id=%s HTTP/1.1\r\n\r\n", status->r_stat.name); status->r_stat.http_sock = tcp_connect(status->r_stat.hostname, dGPS_PORT); break; case MOVE: fprintf(stdout, "\t\tContacting move port\n"); snprintf((char*)http_message, 100, "GET /twist?id=%s&lx=1 HTTP/1.1\r\n\r\n", status->r_stat.name); status->r_stat.http_sock = tcp_connect(status->r_stat.hostname, GPS_PORT); break; case TURN: fprintf(stdout, "\t\tContacting turn port\n"); snprintf((char*)http_message, 100, "GET /twist?id=%s&az=1 HTTP/1.1\r\n\r\n", status->r_stat.name); status->r_stat.http_sock = tcp_connect(status->r_stat.hostname, GPS_PORT); break; case STOP: fprintf(stdout, "\t\tContacting stop port\n"); snprintf((char*)http_message, 100, "GET /twist?id=%s&lx=0 HTTP/1.1\r\n\r\n", status->r_stat.name); status->r_stat.http_sock = tcp_connect(status->r_stat.hostname, GPS_PORT); break; default: fprintf(stderr, "ERROR: Invalid client request\n"); return -2; break; } // send the http request fprintf(stdout, "\t\tWriting request to server\n"); timeout_setup(status->r_stat.http_sock, timeout); write(status->r_stat.http_sock, (char*)http_message, strlen((char*)http_message)); // read http message into a buffer fprintf(stdout, "\t\tReceiving reply from server\n"); memset(http_message, '\0', 1000); retries = 0; while (1) { n = read(status->r_stat.http_sock, (char*)http_message, 1000); if (n == -1) { if (retries > 2) { break; } retries++; write(status->r_stat.http_sock, (char*)http_message, strlen((char*)http_message)); continue; } else if (n == 0) { break; } fprintf(stdout, "\t\t\tReceived %d bytes\n", n); append_buffer(http_data, (unsigned char*)http_message, n); memset(http_message, '\0', 1000); } fprintf(stdout, "\t\tTotal bytes received: %d\n", http_data->len); // see what we go fprintf(stdout, "\t\tAssembled Message:\n%s\n", http_data->data); // check for '200 OK' char ret_code[4]; memcpy(ret_code, http_data->data + 9, 3); // HTTP/1.1 <ret_code> ~~~~ ret_code[3] = '\0'; if (atoi(ret_code) != 200) { fprintf(stderr, "ERROR: bad http request\n"); response = create_custom_message(GROUP_NUMBER, status->password, HTTP_ERROR, 0, 0, 0); udp_send(response, status); return 0; } // send it to client int http_header_len = http_get_data(http_data->data) - http_data->data; int a = 0; while ((a + http_header_len) < http_data->len) { response = create_custom_message(request_header.data[CST_VERSION], request_header.data[CST_PASSWORD], request_header.data[DATA], request_header.data[CST_SEQUENCE], (http_data->len - http_header_len), ((http_data->len - (a + http_header_len)) > CST_MAX_PAYLOAD ? CST_MAX_PAYLOAD:(http_data->len - (a + http_header_len)))); append_buffer(response, http_data->data + a + http_header_len, CST_MAX_PAYLOAD); fprintf(stdout, "\n\t\tAssembled packet:\n"); print_header(response); fprintf(stdout, "%s\n", response->data + UP_HEADER_LEN); fprintf(stdout, "\t\tSending packet\n"); udp_send(response, status); fprintf(stdout, "\t\tPacket sent\n"); delete_buffer(response); a += 370; } fprintf(stdout, "\t\tRequest complete!\n"); return 1; }
/* * Print the symbol table according to the flags that were * set, if any. Input is an opened ELF file, the section name, * the section header, the section descriptor, and the filename. * First get the symbol table with a call to elf_getdata. * Then translate the symbol table data in memory by calling * readsyms(). This avoids duplication of function calls * and improves sorting efficiency. qsort is used when sorting * is requested. */ static void print_symtab(Elf *elf_file, unsigned int shstrndx, Elf_Scn *p_sd, GElf_Shdr *shdr, char *filename) { Elf_Data * sd; SYM *sym_data; SYM *s; GElf_Sxword count = 0; const int ndigits_arr[] = { 10, /* FMT_T_DEC */ 8, /* FMT_T_HEX */ 11, /* FMT_T_OCT */ }; int ndigits; /* * Determine # of digits to use for each numeric value. */ ndigits = ndigits_arr[fmt_flag]; if (gelf_getclass(elf_file) == ELFCLASS64) ndigits *= 2; /* * print header */ print_header(ndigits); /* * get symbol table data */ if (((sd = elf_getdata(p_sd, NULL)) == NULL) || (sd->d_size == 0)) { (void) fprintf(stderr, gettext("%s: %s: no symbol table data\n"), prog_name, filename); return; } count = shdr->sh_size / shdr->sh_entsize; /* * translate symbol table data */ sym_data = readsyms(sd, count, elf_file, shdr->sh_link, (unsigned int)elf_ndxscn(p_sd)); if (sym_data == NULL) { (void) fprintf(stderr, gettext( "%s: %s: problem reading symbol data\n"), prog_name, filename); return; } qsort((char *)sym_data, count-1, sizeof (SYM), (int (*)(const void *, const void *))compare); s = sym_data; while (count > 1) { #ifndef XPG4 if (u_flag) { /* * U_flag specified */ print_with_uflag(sym_data, filename); } else if (p_flag) #else if (p_flag) #endif print_with_pflag(ndigits, elf_file, shstrndx, sym_data, filename); else if (P_flag) print_with_Pflag(ndigits, elf_file, shstrndx, sym_data); else print_with_otherflags(ndigits, elf_file, shstrndx, sym_data, filename); sym_data++; count--; } free(s); /* allocated in readsym() */ }