MFILE *fileRead(char *fname) { MFILE *mfin=mfopen(), *mfout=mfopen(), *mfbuf=mfopen(); FILE *f=fopen(fname, "r"); const char *flastok, *fhit, *fend; if(f==NULL) pexit("Cannot read input file ", fname); mfFileToMFile(f, mfin); fclose(f); flastok=fhit=fend=mfGetData(mfin); while((fhit=strstr(flastok, "<!--#"))!=NULL){ searchInput(flastok, fhit); fend=strstr(fhit, "-->"); if(fend==NULL) pexit("Parse error - '-->' expected - exiting\n", fhit); if(commdepth==0) escapeWrite((void*)flastok, fhit-flastok, mfout); flastok=(const char*)(fend+3); mfSetLength(mfbuf, 0); mfwrite((void*)(fhit+5), 1, fend-(fhit+5), mfbuf); parseMeta(mfout, mfGetData(mfbuf)); } searchInput(flastok, (char*)0x8FFFFFFF); escapeWrite((void*)flastok, strlen(flastok), mfout); mfprintf(mfout, "\";\n"); mfclose(mfin); return(mfout); }
/* * Write a sequence to a file "fn" of format "format". If "format" is 0, * we choose our favourite - SCF. * * Returns: * 0 for success * -1 for failure */ int write_reading(char *fn, Read *read, int format) { mFILE *fp = mfopen(fn, "wb"); if (!fp) return -1; return mfwrite_reading(fp, read, format); }
void searchInput(const char *flastok, const char *fhit) { MFILE *mfbuf=mfopen(); const char *input, *ta, *hit, *select, *end, *test; hit=flastok; do{ input=strstr(hit, "<input"); ta=strstr(hit, "<textarea"); select=strstr(hit, "<select"); hit=(char*)0x8FFFFFFF; if(input!=NULL && input<hit) hit=input; if(ta!=NULL && ta<hit) hit=ta; if(select!=NULL && select < hit) hit=select; if(hit!=(char*)0x8FFFFFFF && hit<fhit){ end=strchr(hit, '>'); test=strchr(hit+1, '<'); if(test!=NULL && test<end) end=strchr(end+1, '>'); mfSetLength(mfbuf, 0); mfwrite((void*)hit+1, 1, end-hit-1, mfbuf); printf("Input: %s\n", mfGetData(mfbuf)); parseInput(mfGetData(mfbuf)); hit++; } }while(hit!=(char*)0x8FFFFFFF && hit<fhit); mfclose(mfbuf); }
/* ---------------- ac_read ---------------------------------- * Given a pointer to a filename, read in the data. * This is an interface function, visible to the outside world. */ struct aa_clssfcn * ac_read (const char *fname) { FILE *fp; size_t n_class, n_att; struct aa_clssfcn *aa_clssfcn = NULL; size_t i; const char *this_sub = "ac_read"; # ifndef BUFSIZ enum {BUFSIZ = 1024}; # endif char buf [BUFSIZ]; if ((fp = mfopen (fname, "r", this_sub)) == NULL) return (NULL); if ((n_class = get_n_class (fp, buf, BUFSIZ)) == 0) goto end; if ((n_att = get_n_att (fp, buf, BUFSIZ)) == 0) goto end; aa_clssfcn = new_aa_clssfcn ( n_class, n_att); for (i = 0; i < n_class; i++) { if (read_class (fp, buf, BUFSIZ, aa_clssfcn, i, MIN_AA)==EXIT_FAILURE){ aa_clssfcn_destroy (aa_clssfcn); goto end; } } end: fclose (fp); return (aa_clssfcn); }
int main(int argc, char **argv) { int a = 1; int format = TT_ANY; mFILE *ofp = mstdout(); char *name = NULL, *oname = NULL; int output_conf = 0; read_sections(READ_BASES); while (a < argc) { if (strcasecmp(argv[a], "-abi") == 0) format = TT_ABI; else if (strcasecmp(argv[a], "-alf") == 0) format = TT_ALF; else if (strcasecmp(argv[a], "-scf") == 0) format = TT_SCF; else if (strcasecmp(argv[a], "-pln") == 0) format = TT_PLN; else if (strcasecmp(argv[a], "-name") == 0) { if (a == argc) usage(); name = argv[++a]; } else if (strcasecmp(argv[a], "-output") == 0) { if (a == argc) usage(); ofp = mfopen(oname = argv[++a], "wb"); if (NULL == ofp) { perror(argv[a]); return 1; } } else if (strcasecmp(argv[a], "-conf") == 0) { output_conf = 1; } else if (argv[a][0] == '-') usage(); else break; a++; } if (a+1 != argc) usage(); if (!name) name = oname; if (!name) name = argv[a]; return convert(argv[a], format, ofp, name, output_conf); }
/* ---------------- prob_vec_write ---------------------------- * Write a probability vector a specified file name. * We have to write some sizes first, so we know how many bytes * we may need, but we */ int prob_vec_write (struct prob_vec *p_v, const char *fname) { FILE *fp; unsigned short *nc, *nc_last; unsigned total = 0; const char *this_sub = "prob_vec_write"; if (! (fp = mfopen(fname, "w", this_sub))) return EXIT_FAILURE; if (p_v -> cmpct_prob == NULL) prob_vec_compact (p_v); nc = p_v->cmpct_n; nc_last = nc + p_v->n_pvec; for ( ; nc < nc_last; nc++) total += *nc; write_magic_num (fp); if (xfwrt ( &PVEC_VERSION, sizeof(PVEC_VERSION), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (write_4 (p_v->frag_len, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (write_4 (p_v->prot_len, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (write_4 (p_v->n_pvec, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (write_4 (p_v->n_class, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (xfwrt( p_v->cmpct_n, sizeof (p_v->cmpct_n[0]), p_v->n_pvec, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (xfwrt( p_v->cmpct_prob, sizeof(p_v->cmpct_prob[0]), total, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (xfwrt( p_v->cmpct_ndx, sizeof(p_v->cmpct_ndx[0]), total, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (xfwrt ( &p_v->norm_type, sizeof(p_v->norm_type), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; /*store compound information*/ if (write_4 (p_v->compnd_len, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (xfwrt ( p_v->compnd, sizeof(char), p_v->compnd_len, fp, this_sub, fname) == EXIT_FAILURE) goto error; fclose (fp); return EXIT_SUCCESS; error: fclose (fp); return EXIT_FAILURE; }
int parseMultiPart(char *boundary) { int bound_len=strlen(boundary), type, startat, finish=false; char *name=NULL, *ctyp=NULL, *fname=NULL; MFILE *mf=mfopen(); while((startat=miscFReadLn(stdin, mf))!=-1) { if(strncmp(boundary, mfGetDataAt(mf, startat), bound_len)) continue; /* new part found - insert old part and init new one... * no insert at FIRST header ... * at end of multipart ??? "--boundary--" line ? */ if(!strncmp("--", mfGetDataAt(mf, mfGetLength(mf)-4), 2)) finish=true; mfSetLength(mf, startat); if(name!=NULL) { /* strip memfile, since one more <cr><lf> or only <lf> at end */ mf->used--; if(*(char*)((int)mf->data+mf->used-1) == '\r') mf->used--; if(type==CgiKindFile) { listAddData(type, name, fname, ctyp, mf); mf=mfopen(); } else listAddData(type, name, mfGetData(mf), ctyp, NULL); } if(finish==true) return(true); type=parseMultiHead(&name, &fname, &ctyp); mfSetLength(mf, 0); } mfclose(mf); free(name); free(fname); free(ctyp); return true; }
/* * Searches for file in the directory 'dirname'. If it finds it, it opens * it. This also searches for compressed versions of the file in dirname * too. * * Returns mFILE pointer if found * NULL if not */ static mFILE *find_file_dir(char *file, char *dirname) { char path[PATH_MAX+1]; size_t len = strlen(dirname); char *cp; if (dirname[len-1] == '/') len--; /* Special case for "./" or absolute filenames */ if (*file == '/' || (len==1 && *dirname == '.')) { sprintf(path, "%s", file); } else { /* Handle %[0-9]*s expansions, if required */ char *path_end = path; *path = 0; while ((cp = strchr(dirname, '%'))) { char *endp; long l = strtol(cp+1, &endp, 10); if (*endp != 's') { strncpy(path_end, dirname, (endp+1)-dirname); path_end += (endp+1)-dirname; dirname = endp+1; continue; } strncpy(path_end, dirname, cp-dirname); path_end += cp-dirname; if (l) { strncpy(path_end, file, l); path_end += MIN(strlen(file), l); file += MIN(strlen(file), l); } else { strcpy(path_end, file); path_end += strlen(file); file += strlen(file); } len -= (endp+1) - dirname; dirname = endp+1; } strncpy(path_end, dirname, len); path_end += MIN(strlen(dirname), len); *path_end = 0; if (*file) { *path_end++ = '/'; strcpy(path_end, file); } //fprintf(stderr, "*PATH=\"%s\"\n", path); } if (is_file(path)) { return mfopen(path, "rb"); } return NULL; }
/*! * Write a sequence to a file "fn" of format "format". If "format" is 0, * we choose our favourite - SCF. * * Returns: * 0 for success * -1 for failure */ int write_reading(char *fn, Read *read, int format) { int ret; mFILE *fp = mfopen(fn, "wb"); if (!fp) return -1; ret = mfwrite_reading(fp, read, format); mfclose(fp); return ret; }
/* * Searches for file in the directory 'dirname'. If it finds it, it opens * it. This also searches for compressed versions of the file in dirname * too. * * Returns mFILE pointer if found * NULL if not */ static mFILE *find_file_dir(char *file, char *dirname) { char *path; mFILE *mf = NULL; path = expand_path(file, dirname); if (is_file(path)) mf = mfopen(path, "rbm"); free(path); return mf; }
/* ---------------- score_mat_read -------------------------- * Read a score matrix from a file. Return a newly allocated * score_mat pointer. */ struct score_mat * score_mat_read ( const char *fname) { float **mat; struct score_mat *ret_mat = NULL; FILE *fp; unsigned to_read; unsigned int n_rows, n_cols, ret; int err = 0; static int first = 1; const char *this_sub = "score_mat_read"; const char *read_fail = "Read fail on %s in %s\n"; extern const char *prog_bug; if (sizeof(n_rows) != 4) { err_printf (this_sub, prog_bug, __FILE__, __LINE__); return NULL; } if ((fp = mfopen (fname, "r", this_sub)) == NULL) return NULL; if ((err = file_no_cache(fp)) != 0) { if (first) { const char *no_cache = "cannot disable read cache: %s: %s"; first = 0; err_printf (this_sub, no_cache, fname, strerror (err)); } } if (fread (&n_rows, sizeof (n_rows), 1, fp) != 1) { err_printf (this_sub, read_fail, "n_rows", fname); goto end; } if (fread (&n_cols, sizeof (n_cols), 1, fp) != 1) { err_printf (this_sub, read_fail, "n_cols", fname); goto end; } ret_mat = score_mat_new (n_rows - 2, n_cols - 2); mat = ret_mat->mat; to_read = (n_rows ) * (n_cols); if ((ret = fread (mat[0], sizeof (mat[0][0]), to_read, fp)) != to_read) { err_printf (this_sub, "Failed reading %s. Wanted %lu items. Got %lu\n", fname, (long unsigned) to_read, (long unsigned) ret); score_mat_destroy (ret_mat); goto end; } end: fclose (fp); return ret_mat; }
int main(int argc, char **argv) { ztr_t *ztr; mFILE *fp; int i; if (argc >= 2) { if (NULL == (fp = mfopen(argv[1], "rb"))) { perror(argv[1]); return 1; } } else { fp = mstdin(); } if (NULL == (ztr = mfread_ztr(fp))) { perror("fread_ztr"); return 1; } printf("Nchunks = %d\n", ztr->nchunks); for (i = 0; i < ztr->nchunks; i++) { char str[5]; int complen; int rawlen; char *val; (void)ZTR_BE2STR(ztr->chunk[i].type, str); complen = ztr->chunk[i].dlength; val = ztr_lookup_mdata_value(ztr, &ztr->chunk[i], "TYPE"); if (val) printf("-- %s (%s) --\n", str, val); else printf("-- %s --\n", str); explode_chunk(ztr, &ztr->chunk[i]); rawlen = ztr->chunk[i].dlength; printf("SUMMARY %s mlen %3d, dlen %6d, rawlen %6d, ratio %f\n", str, ztr->chunk[i].mdlength, complen, rawlen, (double)complen/rawlen); #if 0 fflush(stdout); puts("\n========================================"); write(1, ztr->chunk[i].data, ztr->chunk[i].dlength); puts("\n========================================"); #endif } delete_ztr(ztr); return 0; }
/* ---------------- score_mat_write -------------------------- * Dump a score matrix to a file. */ int score_mat_write (const struct score_mat *smat, const char *fname) { FILE *fp; float **mat; unsigned int n_rows, n_cols; size_t to_write; const char *this_sub = "score_mat_write"; extern const char *null_point, *prog_bug; if (sizeof(n_rows) != 4) { err_printf (this_sub, prog_bug, __FILE__, __LINE__); return EXIT_FAILURE; } if ( ! smat ) { err_printf (this_sub, null_point); return EXIT_FAILURE; } if ( smat->n_rows == 0 || smat->n_cols == 0) { err_printf (this_sub, "n_rows or columns is zero for %s\n", fname); return EXIT_FAILURE; } if ((fp = mfopen ( fname, "w", this_sub)) == NULL) return EXIT_FAILURE; n_rows = (unsigned int) smat->n_rows; n_cols = (unsigned int) smat->n_cols; if (fwrite (&n_rows, sizeof (n_rows), 1, fp) != 1) goto error; if (fwrite (&n_cols, sizeof (n_cols), 1, fp) != 1) goto error; mat = smat->mat; to_write = n_rows * n_cols; if (fwrite (mat[0], sizeof (mat[0][0]), to_write, fp) != to_write) goto error; fclose (fp); return EXIT_SUCCESS; error: mperror (this_sub); err_printf (this_sub, "Failed writing to %s", fname); fclose (fp); return EXIT_FAILURE; }
void LoadScriptFile(pzllst *lst,FManNode *filename, bool control, MList *controlst) { #ifdef TRACE printf("Loading script file %s\n",filename->File); #endif if (control) { Rend_SetRenderer(RENDER_FLAT); } mfile *fl=mfopen(filename); if (fl == NULL) { printf("Error opening file %s\n",filename->File); exit(1); return; } char buf[FILE_LN_BUF]; while(!mfeof(fl)) { mfgets(buf,FILE_LN_BUF,fl); char *str=PrepareString(buf); if (strCMP(str,"puzzle")==0) { Parse_Puzzle(lst,fl,str); } else if (strCMP(str,"control")==0 && control ) { Parse_Control(controlst,fl,str); } } mfclose(fl); }
/* ------------------------ score_mat_write_gnuplot ---------------------- * For Plotting an alignment traceback, e.g. with gnuplot, you need the * smat->mat scores. This function writes them into an ASCII file with * filename as param with output in each line: * i j value */ int score_mat_write_gnuplot( const struct score_mat *smat, const char *fname, const char *protA, const char *protB ){ const char *this_sub = "score_mat_write_gnuplot"; float **mat = smat->mat; size_t i,j; FILE *fp; if ((fp = mfopen ( fname, "w", this_sub)) == NULL) return EXIT_FAILURE; if ( mfprintf ( fp , "%s%s%s%s%s\n","# Data from ", protA, ".pdb and ", protB ,".pdb") < 0) goto error; if ( mfprintf ( fp, "# %u entries per side \n", (unsigned int) smat->n_cols ) < 0) goto error; if ( mfprintf ( fp, "# Total entries %u\n", (unsigned int)(smat->n_rows * smat->n_cols) ) < 0) goto error; for (i = 0; i < smat->n_rows; i++ ){ for (j = 0; j < smat->n_cols; j++ ){ if ( mfprintf ( fp, "%d %d %f \n", i, j , mat[i][j] ) < 0) goto error; } if ( mfprintf ( fp, "\n") < 0) goto error; } if ( mfprintf ( fp, "\n" ) < 0) goto error; fclose (fp); return EXIT_SUCCESS; error: mperror (this_sub); err_printf (this_sub, "Failed writing to %s", fname); fclose (fp); return EXIT_FAILURE; }
static int ResolveEntity(void *UserData, LPXMLENTITY entity, LPBUFFEREDISTREAM reader) { FILE *f; XMLCH r[FILENAME_MAX]; XMLCH *filename; if (entity->publicID && !strcmp(entity->publicID, "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN")) return XML_OK; filename = ResolveBaseUri(parser, entity->systemID, AppBase); if (filename != entity->systemID) { strcpy(r, filename); filename = strcat(r, entity->systemID); } if (!(f = mfopen(filename, "rb"))) { fprintf(stderr, "error opening file '%s'\n", filename); return XML_ABORT; } reader->inputData = f; return XML_OK; }
int cgiLoadDebugData(char *fname) { FILE *f=fopen(fname, "r"); int count, subcount, type, mflen, envcount; MFILE *mf; char *name, *ctyp; CgiElement *where; if(init_complete==true || f==NULL) return(false); listInit(); fread(&count, 1, 4, f); while(count-->0) { fread(&type, 1, 4, f); name=miscReadData(f); ctyp=miscReadData(f); fread(&mflen, 1, 4, f); if(mflen>0) { mf=mfopen(); mfFileToMFileN(f, mf, mflen); } else mf=NULL; where=listAppendElement(type, name, ctyp, mf); fread(&subcount, 1, 4, f); while(subcount-->0) listAppendValue(where, miscReadData(f)); } fread(&envcount, 1, 4, f); while(envcount-->0) miscReadSetEnviron(f); init_called = true; init_complete = true; fclose(f); return(true); }
int doglobal( /* execute a global command */ PRIMITIVE *g ) { FILE *fp = NULL; switch (g->com) { case PEOF: return(0); case PPAUS: break; case PINCL: if (g->args == NULL) error(USER, "missing include file name in include"); if (g->arg0 == 2 || (fp = fopen(g->args, "r")) == NULL) { if (g->arg0 != 0) fp = mfopen(g->args, "r"); else { sprintf(errmsg, "cannot open user include file \"%s\"", g->args); error(USER, errmsg); } } plot(fp); fclose(fp); break; case PDRAW: fflush(stdout); break; case PEOP: endpage(); newpage = TRUE; break; case PSET: set(g->arg0, g->args); break; case PUNSET: unset(g->arg0); break; case PRESET: reset(g->arg0); break; case POPEN: segopen(g->args); break; case PCLOSE: segclose(); break; default: sprintf(errmsg, "unknown command '%c' in doglobal", g->com); error(WARNING, errmsg); break; } return(1); }
int Catalogs_Init(void) { LPXMLDTDVALIDATOR dtd; FILE *f; int ret=1, i=0; char t[FILENAME_MAX]; char *env = getenv("XML_CATALOG_FILES"); if (!env) doc = "/etc/xml/catalog"; if (!XMLParser_Create(&parser)) { fputs("Out of memory\n", stderr); return 0; } if (!(dtd = XMLParser_CreateDTDValidator())) { XMLParser_Free(parser); fputs("Out of memory\n", stderr); return 0; } XMLParser_SetExternalSubset(parser, NULL, "catalog_flat.dtd"); parser->startElementHandler = StartElement; parser->errorHandler = ErrorHandler; parser->resolveEntityHandler = ResolveEntity; parser->externalEntityParsedHandler = FreeInputData; while (ret) { if (env) doc = mstrtok(&env, t, sizeof(t)/sizeof(t[0]), ';'); if (!doc) { if (env && *env) { ret = 0; fprintf(stderr, "Erroneous token in XML_CATALOG FILES: %s\n", env); } break; } while (doc) { if (!(f = mfopen(doc, "rb"))) { fprintf(stderr, "Error opening file %s\n", doc); ret = 0; break; } ret = XMLParser_ParseValidateDTD(dtd, parser, filestream, f, 0); fclose(f); if (!ret || !nextCatalog || i == nextCatalog->length) doc = NULL; else { char **uri = XMLVector_Get(nextCatalog, i++); doc = *uri; } } } if (ret) { if (publicIDS && publicIDS->length > 1) qsort(publicIDS->array, publicIDS->length, sizeof(struct IDs), (int(*)(const void*, const void*))idsort); if (systemIDS && systemIDS->length > 1) qsort(systemIDS->array, publicIDS->length, sizeof(struct IDs), (int(*)(const void*, const void*))idsort); } XMLParser_FreeDTDValidator(dtd); XMLParser_Free(parser); return ret; }
/* this is REALLY a f**k ... why didnt they put the fname in a own line :( */ int parseMultiHead(char **name, char **fname, char **ctyp) { char *endchars; const char *contt="Content-Type: ", *line; const char *contd="Content-Disposition: form-data; name="; int i, ret=0; MFILE *mf=mfopen(), *mfname=mfopen(); free(*ctyp); (*ctyp)=strdup(""); /* read till empty line appears - end of header ... */ while((miscFReadLn(stdin, mf)>=0) && (line=mfGetData(mf)) && !(line[0]=='\n' || (line[0]!=0 && line[0]=='\r' && line[1]=='\n'))) { /* make sure, next lines starts at beginn of file again... */ mfSetLength(mf, 0); /* "Content-Type: what/ever" line */ if(!strncasecmp(line, contt, strlen(contt))) { free(*ctyp); (*ctyp)=miscStringDelCrLf((char*)strdup((char*)(line+strlen(contt)))); } /* "Content-Disposition: form-data; name="whatever"; filename="C:\f**k.txt"" - line */ if(!strncasecmp(line, contd, strlen(contd))) { i=strlen(contd); if(line[i]=='"') { endchars="\"\r\n\0"; i++; } else endchars=";\r\n\0"; /* parse name */ while(strchr(endchars, line[i])==NULL) mfputc(line[i++], mfname); *name=realloc(*name, mfGetLength(mfname)+1); strcpy(*name, mfGetData(mfname)); mfSetLength(mfname, 0); if(line[i]=='\"') i++; if(line[i]!=';') { ret=CgiKindValue; continue; } else ret=CgiKindFile; /* we have a filename= part here - parse filename */ while(line[i]!=0 && line[i]!='=') i++; i++; if(line[i]=='\"') { endchars="\"\r\n\0"; i++; } else endchars=";\r\n\0"; while(strchr(endchars, line[i])==NULL) mfputc(line[i++], mfname); if(mfGetLength(mfname)>0) { *fname=realloc(*fname, mfGetLength(mfname)+1); strcpy(*fname, mfGetData(mfname)); mfSetLength(mfname, 0); } else { *fname=realloc(*fname, 16); (*fname)[0]=0; } } } mfclose(mf); mfclose(mfname); return(ret); }
/* ---------------- prob_vec_read ---------------------------- * Here is a thought... When we read from one of these files, * we are always going to read the whole thing. It might be a * good idea to read into a relatively large ( 24 K ) ? buffer * using setvbuf(). */ struct prob_vec * prob_vec_read (const char *fname) { enum { FBUFSIZ = 32768 }; char fbuf [FBUFSIZ]; FILE *fp; struct prob_vec *p_v = NULL; int version, err; unsigned total = 0; unsigned int n_pvec, n_class, prot_len, frag_len; static unsigned char first = (char) 1; const char *this_sub = "prob_vec_read"; const char *no_swap = "Byte swapping not written yet. Reading from %s\n"; const char *broken = "File error reading magic number from %s\n"; const char *s = "Turning off caching for %s:\n\"%s\"\n"; if (sizeof (n_pvec) != 4) { err_printf (this_sub, mismatch, sizeof (n_pvec)); return NULL; } if (! (fp = mfopen(fname, "r", this_sub))) return NULL; if (setvbuf(fp, fbuf, _IOFBF, FBUFSIZ)) err_printf (this_sub, "warning setvbuf() call failed\n"); if ((err = file_no_cache(fp)) != 0) { if (first) { first = 0; err_printf (this_sub, s, fname, strerror (err)); } } switch (read_magic_num (fp)) { case BYTE_REVERSE: err_printf (this_sub, no_swap, fname); fclose (fp); return NULL; case BYTE_BROKEN: err_printf (this_sub, broken, fname); fclose (fp); return NULL; case BYTE_STRAIGHT: break; /* fall through, no problem occurred */ } if( xfrd ( &version, sizeof (version), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; if (version != 1) { err_printf (this_sub, "error reading version num, got %d\n", version); goto error; } if( xfrd ( &frag_len, sizeof (frag_len), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; if( xfrd ( &prot_len, sizeof (prot_len), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; if( xfrd ( &n_pvec, sizeof (n_pvec), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; if( xfrd ( &n_class, sizeof (n_class), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; err_printf(this_sub,"blabla\n"); p_v = new_pvec (frag_len, prot_len, n_pvec, 0); p_v->n_class = n_class; p_v->cmpct_n = E_MALLOC (n_pvec * sizeof (p_v->cmpct_n[0])); if (xfrd (p_v->cmpct_n, sizeof (p_v->cmpct_n[0]), n_pvec, fp, this_sub, fname) == EXIT_FAILURE) goto error; { unsigned short *nc = p_v->cmpct_n; const unsigned short *nc_last = nc + n_pvec; for ( ; nc < nc_last; nc++) total += *nc; } p_v->cmpct_prob = E_MALLOC (total * sizeof (p_v->cmpct_prob[0])); if (xfrd (p_v->cmpct_prob, sizeof (p_v->cmpct_prob[0]), total, fp, this_sub, fname) == EXIT_FAILURE) goto error; p_v->cmpct_ndx = E_MALLOC (total * sizeof (p_v->cmpct_ndx[0])); if (xfrd (p_v->cmpct_ndx, sizeof (p_v->cmpct_ndx[0]), total, fp, this_sub, fname) == EXIT_FAILURE) goto error; if( xfrd (&p_v->norm_type, sizeof (p_v->norm_type), 1, fp, this_sub, fname) == EXIT_FAILURE) goto error; /*read compound information*/ if (xfrd (&p_v->compnd_len, sizeof(p_v->compnd_len),1, fp, this_sub, fname) == EXIT_FAILURE) goto error; p_v->compnd = E_MALLOC (p_v->compnd_len * sizeof (char)); if (xfrd ( p_v->compnd, sizeof(char), p_v->compnd_len, fp, this_sub, fname) == EXIT_FAILURE) goto error; fclose (fp); return p_v; error: if (new_pvec) prob_vec_destroy (p_v); fclose (fp); return NULL; }
int main(int argc, char **argv) { int format = TT_ANY, r, prec = 0, version = 3, silent = 0; int compress_mode = -1; char *inf = NULL; char *outf = NULL; mFILE *ofp = mstdout(); int normalise = 0; for (argc--, argv++; argc > 0; argc--, argv++) { if (strcmp(*argv, "-8") == 0) { prec = 1; } else if (strcmp(*argv, "-2") == 0) { version = 2; } else if (strcmp(*argv, "-3") == 0) { version = 3; } else if (strcmp(*argv, "-normalise") == 0) { normalise = 1; } else if (strcmp(*argv, "-s") == 0) { silent = 1; } else if (strcasecmp(*argv, "-abi") == 0) { format = TT_ABI; inf = *++argv; argc--; } else if (strcasecmp(*argv, "-alf") == 0) { format = TT_ALF; inf = *++argv; argc--; } else if (strcasecmp(*argv, "-scf") == 0) { format = TT_SCF; inf = *++argv; argc--; } else if (strcasecmp(*argv, "-ztr") == 0) { format = TT_ZTR; inf = *++argv; argc--; } else if (strcasecmp(*argv, "-any") == 0) { format = TT_ANY; inf = *++argv; argc--; } else if (strcasecmp(*argv, "-output") == 0) { outf = *++argv; argc--; } else if (strcasecmp(*argv, "-compress") == 0) { compress_mode = compress_str2int(*++argv); argc--; } else { break; } } /* if no args left than input file must have been specified */ if (!argc && !inf) usage(); /* if outfile set, then using original syntax, so don't expect any extra args */ if (argc && outf) usage(); if (!silent) { printf("makeSCF v3.06\n"); printf("Copyright (c) MRC Laboratory of Molecular Biology, 2001. All rights reserved.\n"); } set_scf_version(version); if(!argc) { /* original calling syntax */ if (outf) { ofp = mfopen(outf, "wb+"); if (NULL == ofp) { perror(outf); return 1; } } r = convert(inf, ofp, outf, format, prec, compress_mode, normalise); mfclose(ofp); return r; } /* else */ { /* new calling syntax, handling multiple files */ int result=0; for (; argc > 0; argc--, argv++) { if (inf) { /* got infile, so get outfile and process */ outf= *argv; ofp = mfopen(outf, "wb+"); if (NULL == ofp) { perror(outf); if(!result) result=1; continue; } r = convert(inf, ofp, outf, format, prec, compress_mode, normalise); mfclose(ofp); if(!result) /* keep track of the first error */ result=r; /* now need to get another infile */ inf=NULL; } else { /* need infile */ inf= *argv; } } return result; } }
int main(int argc, char *argv[]){ MFILE* fp = mfopen(argv[1], "a"); mfputs(argv[2], fp); mfclose(fp); return 0; }
/* ---------------- sub_mat_read ------------------------------ */ struct sub_mat * sub_mat_read (const char *fname) { # ifndef BUFSIZ # error please define BUFSIZ to around 1024 # endif fpos_t pos; struct sub_mat *smat = NULL; FILE *fp; char buf [BUFSIZ]; char aanames [ MAX_AA + 3]; const char *this_sub = "read_mat"; const char comment = '#'; if ((fp = mfopen (fname, "r", this_sub)) == NULL) return NULL; /* Portably initialise the fpos_t structure * because =0 is insufficient */ if (fgetpos(fp, &pos)) { mperror (this_sub); goto broken; } smat = E_MALLOC ( sizeof (*smat)); smat -> fname = NULL; smat -> comment = NULL; smat->fname = save_str (fname); while (fgets (buf, BUFSIZ, fp) != NULL) { if ( buf[0] != comment) { if (fsetpos (fp, &pos)) { mperror (this_sub); goto broken; } break; } smat->comment = save_str_append (smat->comment, buf); if (fgetpos(fp, &pos)) { mperror (this_sub); goto broken; } } if (fgets (buf, BUFSIZ, fp) == NULL) goto broken; memset (aanames, BAD_AA, MAX_AA); if (get_aa_names (aanames, buf, BAD_AA) == EXIT_FAILURE) goto broken; { int n, m; for (n = 0; n < MAX_AA; n++) for ( m = 0; m < MAX_AA; m++) smat->data[n][m] = (mat_t) INVALID; } { int n = 0; for ( ;fgets(buf, BUFSIZ, fp) != NULL; n++) { if (aanames [n] == BAD_AA) continue; if (add_to_mat (smat, aanames, buf, n) == EXIT_FAILURE) err_printf (this_sub, "Ignoring matrix line\n"); } } fclose (fp); return smat; broken: fclose (fp); free_if_not_null (smat->comment); free_if_not_null (smat->fname); free_if_not_null (smat); return NULL; }
int main(void) { MEMFILE *file, *file2, *file3; char test[] = "This is a very long string that just goes on and on, but it can surely tell us a few things about how this code is working."; char test2[] = "This is the second string, and should get cat'd right up behind the first string."; char buffer[512]; printf("\n--------- open should fail (file doesn't exist)\n"); file = mfopen( "dummy", "r+b" ); printf("fopen(\"dummy\",\"r+b\") -> 0x%x\n", file ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("\n--------- open should succeed (truncated on open)\n"); file = mfopen( "dummy", "w+b" ); printf("fopen(\"dummy\",\"w+b\") -> 0x%x\n", file ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("growth increment was %d\n", _mfsetgrowincrement( file, 64 ) ); printf("growth increment is now %d\n", _mfsetgrowincrement( file, 0 ) ); printf("\n--------- should be zero offset, and eof == false\n"); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- should write %d bytes\n", strlen(test)); printf( "fwrite( [], %d, %d, file ) -> %d\n", strlen(test), sizeof(char), mfwrite( test, strlen(test), sizeof(char), file ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- should read the string back in\n"); printf( "rewind(file) \n" ); mrewind(file); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); memset( buffer, 0, sizeof( buffer )); printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char), mfread( buffer, sizeof(buffer), sizeof(char), file ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- should cat the second string to the first\n"); printf( "fwrite( [], %d, %d, file ) -> %d\n", sizeof(char), strlen(test2), mfwrite( test2, strlen(test2), sizeof(char), file ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- should read zero (fp is at eof)\n"); memset( buffer, 0, sizeof( buffer )); printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char), mfread( buffer, sizeof(buffer), sizeof(char), file ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- seek test\n"); printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) ); printf( "seek(file,64,0)-> %d\n", mfseek( file, 64, SEEK_SET ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- read after seek test, should read filelen-64 bytes\n"); memset( buffer, 0, sizeof( buffer )); printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char), mfread( buffer, sizeof(buffer), sizeof(char), file ) ); printf( "-> \"%s\"\n", buffer ); printf("\n--------- change size test\n"); printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf( "ftruncate(fileno(file),10) -> %d\n", mftruncate( mfileno( file ), 10 ) ); printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- negative seek test\n"); printf( "fseek(file,-5,2)->%d\n", mfseek( file, -5, SEEK_END ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("\n--------- read after seek test, should read 5 bytes\n"); memset( buffer, 0, sizeof( buffer )); printf( "fread( [], %d, %d, file ) -> %d\n", sizeof(buffer), sizeof(char), mfread( buffer, sizeof(buffer), sizeof(char), file ) ); printf( "-> \"%s\"\n", buffer ); printf("\n--------- open and write a second file\n"); file2 = mfopen( "dummy2", "w+b" ); printf("fopen(\"dummy2\",\"w+b\") -> 0x%x\n", file2 ); printf( "fwrite( [], %d, %d, file2 ) -> %d\n", strlen("TEST"), sizeof(char), mfwrite( "TEST", strlen("TEST"), sizeof(char), file2 ) ); printf( "filelength( fileno( file2 ) )-> %ld\n", mfilelength( mfileno( file2 ) ) ); printf( "ftell(file2) -> %ld feof(file2)-> %d\n", mftell( file2 ), mfeof( file2 ) ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("\n--------- open and write a third file\n"); file3 = mfopen( "dummy3", "w+b" ); printf("fopen(\"dummy3\",\"w+b\") -> 0x%x\n", file3 ); printf( "fwrite( [], %d, %d, file3 ) -> %d\n", strlen("BLAHBLAH"), sizeof(char), mfwrite( "BLAHBLAH", strlen("BLAHBLAH"), sizeof(char), file3 ) ); printf( "filelength( fileno( file3 ) )-> %ld\n", mfilelength( mfileno( file3 ) ) ); printf( "ftell(file3) -> %ld feof(file3)-> %d\n", mftell( file3 ), mfeof( file3 ) ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("\n--------- close second\n"); printf( "fclose(file2) -> %d\n", mfclose( file2 ) ); printf( "filelength( fileno( file2 ) )-> %ld\n", mfilelength( mfileno( file2 ) ) ); printf( "ftell(file2) -> %ld feof(file2)-> %d\n", mftell( file2 ), mfeof( file2 ) ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("\n--------- check first\n"); printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("\n--------- truncate to zero test\n"); printf( "ftruncate(fileno(file),0) -> %d\n", mftruncate( mfileno( file ), 0 ) ); printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("\n--------- close first\n"); printf( "fclose(file) -> %d\n", mfclose( file ) ); printf( "filelength( fileno( file ) )-> %ld\n", mfilelength( mfileno( file ) ) ); printf( "ftell(file) -> %ld feof(file)-> %d\n", mftell( file ), mfeof( file ) ); printf("#of open memstreams: %d\n", count_open_streams() ); printf("\n--------- close third\n"); printf( "fclose(file3) -> %d\n", mfclose( file3 ) ); printf( "filelength( fileno( file3 ) )-> %ld\n", mfilelength( mfileno( file3 ) ) ); printf( "ftell(file3) -> %ld feof(file3)-> %d\n", mftell( file3 ), mfeof( file3 ) ); printf("#of open memstreams: %d\n", count_open_streams() ); return 0; }