/* * nextFile * * open the next source file, if any. * * return 1 if could not open the next file. * return 0 otherwise. */ static int nextFile(fstream_t*fs) { int response_code; const char *response_string; struct gpfxdist_t* transform = fs->options.transform; fs->compressed_position += gfile_get_compressed_size(&fs->fd); gfile_close(&fs->fd); fs->foff = 0; fs->line_number = 1; fs->fidx++; if (fs->fidx < fs->glob.gl_pathc) { fs->skip_header_line = fs->options.header; if (gfile_open(&fs->fd, fs->glob.gl_pathv[fs->fidx], GFILE_OPEN_FOR_READ, &response_code, &response_string, transform)) { gfile_printf_then_putc_newline("fstream unable to open file %s", fs->glob.gl_pathv[fs->fidx]); fs->ferror = "unable to open file"; return 1; } } return 0; }
/* * fstream_rewind * * close the currently open file. open the first file in the file stream * chain, reset state and start from scratch. */ int fstream_rewind(fstream_t *fs) { int response_code; const char* response_string; struct gpfxdist_t* transform = fs->options.transform; fs->fidx = 0; fs->foff = 0; fs->line_number = 1; fs->ferror = 0; fs->skip_header_line = fs->options.header; fs->buffer_cur_size = 0; fs->compressed_position = 0; gfile_close(&fs->fd); if (gfile_open(&fs->fd, fs->glob.gl_pathv[0], GFILE_OPEN_FOR_READ, &response_code, &response_string, transform)) { gfile_printf_then_putc_newline("fstream unable to open file %s", fs->glob.gl_pathv[0]); fs->ferror = "unable to open file"; return -1; } return 0; }
/* close the file stream */ void fstream_close(fstream_t* fs) { #ifdef GPFXDIST /* * remove temporary file we created to hold the file paths */ if (fs->options.transform && fs->options.transform->tempfilename) { apr_file_remove(fs->options.transform->tempfilename, fs->options.transform->mp); fs->options.transform->tempfilename = NULL; } #endif if(fs->buffer) gfile_free(fs->buffer); glob_and_copyfree(&fs->glob); gfile_close(&fs->fd); gfile_free(fs); }
int brot_main(const char *cmdline) { struct brot_args_info brot_args; SeqMatrix* sm = NULL; int retval = 0; Scmf_Rna_Opt_data* sim_data = NULL; GFile* entropy_file = NULL; /* command line parsing */ brot_cmdline_parser_init (&brot_args); retval = brot_cmdline_parser_string (cmdline, &brot_args, get_progname()); if (retval == 0) { retval = brot_cmdline_parser_required (&brot_args, get_progname()); } /* postprocess arguments */ if (retval == 0) { retval = brot_cmdline_parser_postprocess (&brot_args); } /* init simulation data */ if (retval == 0) { sim_data = SCMF_RNA_OPT_DATA_NEW_INIT(brot_args.inputs[1], strlen (brot_args.inputs[1]), RNA_ALPHABET, strlen(RNA_ALPHABET)/2, ((-1) * ((logf (1 / 0.000001f)) / (strlen (brot_args.inputs[1]))))); if (sim_data == NULL) { retval = 1; } } /* init matrix */ if (retval == 0) { sm = SEQMATRIX_NEW; if (sm != NULL) { retval = SEQMATRIX_INIT ( alphabet_size (scmf_rna_opt_data_get_alphabet (sim_data)), strlen (brot_args.inputs[1]), sm); /*seqmatrix_print_2_stdout (6, sm);*/ } else { retval = 1; } } /* fix certain sites in the matrix */ if (retval == 0) { retval = adopt_site_presettings (&brot_args, scmf_rna_opt_data_get_alphabet (sim_data), sm); } /* open entropy file if name given */ if (brot_args.entropy_output_given) { entropy_file = GFILE_OPEN (brot_args.entropy_output_arg, strlen (brot_args.entropy_output_arg), GFILE_VOID, "a"); if (entropy_file == NULL) { retval = 1; } else { if (gfile_printf (entropy_file, "# bROT settings:\n") < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# steps: %lu\n", brot_args.steps_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# temp: %f\n", brot_args.temp_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# beta-short: %f\n", brot_args.beta_short_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# beta-long: %f\n", brot_args.beta_long_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# speedup-threshold: %f\n", brot_args.speedup_threshold_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# min-cool: %f\n", brot_args.min_cool_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# scale-cool: %f\n", brot_args.scale_cool_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# lambda: %f\n", brot_args.lambda_arg) < 0) { retval = 1; } else if (gfile_printf (entropy_file, "# sm-entropy: %f\n", brot_args.sm_entropy_arg) < 0) { retval = 1; } } } if (retval == 0) { if (brot_args.scoring_arg == scoring_arg_simpleNN) { /* special to NN usage: structure has to be of size >= 2 */ if (strlen (brot_args.inputs[1]) > 1) { retval = simulate_using_simplenn_scoring (&brot_args, sm, sim_data, entropy_file); } else { THROW_ERROR_MSG (NN_2_SMALL_WARNING, brot_args.inputs[1], (unsigned long) strlen (brot_args.inputs[1])); retval = 1; } } else if (brot_args.scoring_arg == scoring_arg_nussinov) { retval = simulate_using_nussinov_scoring (&brot_args, sm, sim_data, entropy_file); } else if (brot_args.scoring_arg == scoring_arg_NN) { /* special to NN usage: structure has to be of size >= 2 */ if (strlen (brot_args.inputs[1]) > 1) { retval = simulate_using_nn_scoring (&brot_args, sm, sim_data, entropy_file); } else { THROW_ERROR_MSG (NN_2_SMALL_WARNING, brot_args.inputs[1], (unsigned long) strlen (brot_args.inputs[1])); retval = 1; } } } /* close entropy file */ if (retval == 0) { retval = gfile_close (entropy_file); } else { gfile_close (entropy_file); } if (retval == 0) { /* seqmatrix_print_2_stdout (2, sm); */ mprintf ("%s\n", scmf_rna_opt_data_get_seq(sim_data)); } /* finalise */ brot_cmdline_parser_free (&brot_args); seqmatrix_delete (sm); scmf_rna_opt_data_delete (sim_data); if (retval == 0) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } }
void game_close(struct gfile *f) { gfile_close(gfs, f); }
int brot_main(const char *cmdline) { struct brot_args_info brot_args; SeqMatrix* sm = NULL; int retval = 0; Scmf_Rna_Opt_data* sim_data = NULL; GFile* entropy_file = NULL; GFile* simulation_file = NULL; /* command line parsing */ brot_cmdline_parser_init (&brot_args); retval = brot_cmdline_parser_string (cmdline, &brot_args, get_progname()); if (retval == 0) { retval = brot_cmdline_parser_required (&brot_args, get_progname()); } /* postprocess arguments */ if (retval == 0) { retval = brot_cmdline_parser_postprocess (&brot_args, cmdline); } /* init simulation data */ if (retval == 0) { sim_data = SCMF_RNA_OPT_DATA_NEW_INIT(brot_args.inputs[1], strlen (brot_args.inputs[1]), RNA_ALPHABET, strlen(RNA_ALPHABET)/2, ((-1) * ((logf (1 / 0.000001f)) / (strlen (brot_args.inputs[1])))), brot_args.file_given); if (sim_data == NULL) { retval = 1; } } /* init matrix */ if (retval == 0) { sm = SEQMATRIX_NEW; if (sm != NULL) { retval = SEQMATRIX_INIT ( alphabet_size (scmf_rna_opt_data_get_alphabet (sim_data)), scmf_rna_opt_data_get_rna_size(sim_data), /* strlen (brot_args.inputs[1]), */ sm); /*seqmatrix_print_2_stdout (6, sm);*/ } else { retval = 1; } } /* fix certain sites in the matrix */ if (retval == 0) { retval = adopt_site_presettings (&brot_args, scmf_rna_opt_data_get_alphabet (sim_data), sim_data, sm); } /* open entropy file if name given */ if (retval == 0) { print_verbose ("# Entropy file (-p): "); if (brot_args.entropy_output_given) { print_verbose ("%s", brot_args.entropy_output_arg); entropy_file = GFILE_OPEN (brot_args.entropy_output_arg, strlen (brot_args.entropy_output_arg), GFILE_VOID, "a"); if (entropy_file == NULL) { retval = 1; } else { retval = brot_settings_2_file (entropy_file, cmdline); } } /* open simulation/ matrix file if name given */ print_verbose ("\n# Simulation/ Matrix file (-m): "); if (brot_args.simulation_output_given) { print_verbose ("%s", brot_args.simulation_output_arg); simulation_file = GFILE_OPEN (brot_args.simulation_output_arg, strlen (brot_args.simulation_output_arg), GFILE_VOID, "a"); if (simulation_file == NULL) { retval = 1; } else { retval = brot_settings_2_file (simulation_file, cmdline); if (retval == 0) { if (gfile_printf (simulation_file, "START\n") < 0) { retval = 1; } } } } } if (retval == 0) { print_verbose ("\n# Scoring scheme (-c): "); if (brot_args.scoring_arg == scoring_arg_simpleNN) { print_verbose ("simpleNN\n"); /* special to NN usage: structure has to be of size >= 2 */ if (strlen (brot_args.inputs[1]) > 1) { retval = simulate_using_simplenn_scoring (&brot_args, sm, sim_data, entropy_file, simulation_file); } else { THROW_ERROR_MSG (NN_2_SMALL_WARNING, brot_args.inputs[1], (unsigned long) strlen (brot_args.inputs[1])); retval = 1; } } else if (brot_args.scoring_arg == scoring_arg_nussinov) { print_verbose ("nussinov\n"); retval = simulate_using_nussinov_scoring (&brot_args, sm, sim_data, entropy_file, simulation_file); } else if (brot_args.scoring_arg == scoring_arg_NN) { print_verbose ("NN\n"); /* special to NN usage: structure has to be of size >= 2 */ if (strlen (brot_args.inputs[1]) > 1) { retval = simulate_using_nn_scoring (&brot_args, sm, sim_data, entropy_file, simulation_file); } else { THROW_ERROR_MSG (NN_2_SMALL_WARNING, brot_args.inputs[1], (unsigned long) strlen (brot_args.inputs[1])); retval = 1; } } } /* close files */ if (retval == 0) { retval = gfile_close (entropy_file); } else { gfile_close (entropy_file); } if (simulation_file != NULL) { if (gfile_printf (simulation_file, "END\n") < 0) { retval = 1; } } if (retval == 0) { retval = gfile_close (simulation_file); } else { gfile_close (simulation_file); } if (retval == 0) { /*seqmatrix_print_2_stdout (2, sm);*/ mprintf ("%s\n", scmf_rna_opt_data_get_seq(sim_data)); } /* finalise */ brot_cmdline_parser_free (&brot_args); seqmatrix_delete (sm); scmf_rna_opt_data_delete (sim_data); if (retval == 0) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } }
/* * fstream_open * * Allocate a new file stream given a path (a url). in case of wildcards, * expand them here. we end up with a final list of files and include them * in our filestream that we return. * * In case of errors we set the proper http response code to send to the client. */ fstream_t* fstream_open(const char *path, const struct fstream_options *options, int *response_code, const char **response_string) { int i; fstream_t* fs; *response_code = 500; *response_string = "Internal Server Error"; if (0 == (fs = gfile_malloc(sizeof *fs))) { gfile_printf_then_putc_newline("fstream out of memory"); return 0; } memset(fs, 0, sizeof *fs); fs->options = *options; fs->buffer = gfile_malloc(options->bufsize); /* * get a list of all files that were requested to be read and include them * in our fstream. This includes any wildcard pattern matching. */ if (glob_path(fs, path)) { fstream_close(fs); return 0; } /* * If the list of files in our filestrem includes a directory name, expand * the directory and add all the files inside of it. */ if (fpath_all_directories(&fs->glob)) { if (expand_directories(fs)) { fstream_close(fs); return 0; } } /* * check if we don't have any matching files */ if (fs->glob.gl_pathc == 0) { gfile_printf_then_putc_newline("fstream bad path: %s", path); fstream_close(fs); *response_code = 404; *response_string = "No matching file(s) found"; return 0; } if (fs->glob.gl_pathc != 1 && options->forwrite) { gfile_printf_then_putc_newline("fstream open for write found more than one file (%d)", fs->glob.gl_pathc); *response_code = 404; *response_string = "More than 1 file found for writing. Unsupported operation."; fstream_close(fs); return 0; } #ifdef GPFXDIST /* * when the subprocess transformation wants to handle iteration over the files * we write the paths to a temporary file and replace the fs->glob items with * just a single entry referencing the path to the temporary file. */ if (options->transform && options->transform->pass_paths) { apr_pool_t* mp = options->transform->mp; apr_file_t* f = NULL; const char* tempdir = NULL; char* tempfilename = NULL; apr_status_t rv; if ((rv = apr_temp_dir_get(&tempdir, mp)) != APR_SUCCESS) { *response_code = 500; *response_string = "failed to get temporary directory for paths file"; gfile_printf_then_putc_newline(*response_string); fstream_close(fs); return 0; } tempfilename = apr_pstrcat(mp, tempdir, "/pathsXXXXXX", NULL); if ((rv = apr_file_mktemp(&f, tempfilename, APR_CREATE|APR_WRITE|APR_EXCL, mp)) != APR_SUCCESS) { *response_code = 500; *response_string = "failed to open temporary paths file"; gfile_printf_then_putc_newline(*response_string); fstream_close(fs); return 0; } options->transform->tempfilename = tempfilename; for (i = 0; i<fs->glob.gl_pathc; i++) { char* filename = fs->glob.gl_pathv[i]; apr_size_t expected = strlen(filename) + 1; if (apr_file_printf(f, "%s\n", filename) < expected) { apr_file_close(f); *response_code = 500; *response_string = "failed to fully write path to temporary paths file"; gfile_printf_then_putc_newline(*response_string); fstream_close(fs); return 0; } } apr_file_close(f); if (glob_adjust(fs, tempfilename, response_code, response_string)) { fstream_close(fs); return 0; } } #endif /* * if writing - check write access rights for the one file. * if reading - check read access right for all files, and * then close them, leaving the first file open. * */ for (i = fs->glob.gl_pathc; --i >= 0;) { /* * CR-2173 - the fstream code allows the upper level logic to treat a * collection of input sources as a single stream. One problem it has * to handle is the possibility that some of the underlying sources may * not be readable. Here we're trying to detect potential problems in * advance by checking that we can open and close each source in our * list in reverse order. * * However in the case of subprocess transformations, we don't want to * start and stop each transformation in this manner. The check that * each transformation's underlying input source can be read is still * useful so we do those until we get to the first source, at which * point we proceed to just setup the tranformation for it. */ struct gpfxdist_t* transform = (i == 0) ? options->transform : NULL; gfile_close(&fs->fd); if (gfile_open(&fs->fd, fs->glob.gl_pathv[i], gfile_open_flags(options->forwrite, options->usesync), response_code, response_string, transform)) { gfile_printf_then_putc_newline("fstream unable to open file %s", fs->glob.gl_pathv[i]); fstream_close(fs); return 0; } fs->compressed_size += gfile_get_compressed_size(&fs->fd); } fs->line_number = 1; fs->skip_header_line = options->header; return fs; }
// Background part as separate thread // Don't do any GUI things on this thread. void print_gdi_thread(void *pdummy) { PGDI_THREAD *pth= (PGDI_THREAD *)pdummy; CPrintDIB printdib; char buf[MAXSTR]; int length; LPBYTE pLine; LPBYTE p; DWORD dwRead; int i; GFile *pFile = gfile_open_handle((int)pth->hPipeRd); int page = 0; BOOL print_it; printdib.debug = (debug & DEBUG_GDI); while (printdib.ReadHeader(pFile)) { page++; print_it = TRUE; if ((pth->oddeven == EVEN_PAGES) && ((page & 1) == 1)) print_it = FALSE; else if ((pth->oddeven == ODD_PAGES) && ((page & 1) == 0)) print_it = FALSE; if ((pth->from > 0) && (page < pth->from)) print_it = FALSE; if ((pth->to > 0) && (page > pth->to)) print_it = FALSE; sprintf(buf, "Page %d, %s\n", page, print_it ? "PRINT" : "ignore"); gs_addmess(buf); if (print_it) StartPage(pth->hdc); length = printdib.m_bytewidth; pLine = new BYTE[length]; for (i=0; i < printdib.m_PageBmp.bmp2.biHeight; i++) { // read a scan line length = printdib.m_bytewidth; p = pLine; while (length && (dwRead = gfile_read(pFile, p, length)) != 0) { length -= dwRead; p += dwRead; } if (print_it) printdib.AddPrintLine(pth->hdc, i, pLine); } if (print_it) { printdib.FlushPrintBitmap(pth->hdc); EndPage(pth->hdc); } delete pLine; } EndDoc(pth->hdc); DeleteDC(pth->hdc); pth->hdc = NULL; gfile_close(pFile); free(pth); print_count--; /* if printing from command line, close GSview */ if (print_exit && (print_count==0) && !(debug & DEBUG_GDI)) gsview_command(IDM_EXIT); gs_addmess("\nPrint GDI finished\n"); }