diff srf2fastq/io_lib-1.12.2/io_lib/Read.c @ 0:d901c9f41a6a default tip

Migrated tool version 1.0.1 from old tool shed archive to new tool shed repository

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/srf2fastq/io_lib-1.12.2/io_lib/Read.c	Tue Jun 07 17:48:05 2011 -0400
@@ -0,0 +1,555 @@
+/*
+ * Copyright (c) Medical Research Council 1994. All rights reserved.
+ *
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * this copyright and notice appears in all copies.
+ *
+ * This file was written by James Bonfield, Simon Dear, Rodger Staden,
+ * as part of the Staden Package at the MRC Laboratory of Molecular
+ * Biology, Hills Road, Cambridge, CB2 2QH, United Kingdom.
+ *
+ * MRC disclaims all warranties with regard to this software.
+ */
+
+/* 
+ * File: 	Read.c
+ * Purpose:	Performs read/write IO on the Read data stucture.
+ * Last update: 01/09/94
+ */
+
+
+/*
+    The Read data type is designed so that it can hold a varying degree
+    of information about sequences, yet have a single set of calls
+    to access the data.
+
+    There are plenty of assumptions around that both the number of
+    bases and the number of points will fit into an int_2, a short.
+
+*/
+
+/* ---- Includes ---- */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h> /* Only need on windows for _O_BINARY */
+#include <unistd.h>
+
+#include "io_lib/Read.h"
+#include "io_lib/mFILE.h"
+
+#ifdef IOLIB_ABI
+# include "io_lib/abi.h"
+#endif
+#ifdef IOLIB_SCF
+# include "io_lib/scf.h"
+#endif
+#ifdef IOLIB_ALF
+# include "io_lib/alf.h"
+#endif
+#ifdef IOLIB_PLN
+# include "io_lib/plain.h"
+#endif
+#ifdef IOLIB_ZTR
+# include "io_lib/ztr.h"
+#endif
+#ifdef IOLIB_CTF
+# include "io_lib/seqIOCTF.h"
+#endif
+#ifdef IOLIB_SFF
+# include "io_lib/sff.h"
+#endif
+#ifdef IOLIB_EXP
+# include "io_lib/expFileIO.h"
+#endif
+#ifdef USE_BIOLIMS
+# include "spBiolims.h"
+#endif
+
+#include "io_lib/xalloc.h"
+#include "io_lib/translate.h"
+#include "io_lib/traceType.h"
+#include "io_lib/misc.h"
+#include "io_lib/open_trace_file.h"
+
+/*
+ * Read a sequence from a file "fnin" of format "format". If "format" is 0
+ * (ANY_FORMAT), we automatically determine the correct format.
+ * Returns:
+ *   Read *   for success
+ *   NULLRead for failure
+ */
+Read *read_reading(char *fn, int format) {
+    Read *read;
+    mFILE *fp;
+
+#ifdef USE_BIOLIMS
+    if( !strncmp(fn,BIOLIMS_TAG,strlen(BIOLIMS_TAG))){
+	return spReadBiolimsReading(fn);
+   }
+#endif
+
+    /*
+     * If we're asking for an Experiment file, read it.
+     * If the format is ANY then attempt EXP first following by trace.
+     * Otherwise use the trace search mechanism.
+     *
+     * Note this is purely for locating files and not for forcing the file
+     * format. It's here so that experiment files and trace files may be
+     * given identical names but accessed through different search paths
+     * (as is the case with the trace server).
+     */
+    if (format == TT_EXP) {
+	if (NULL == (fp = open_exp_mfile(fn, NULL))) {
+	    errout("'%s': couldn't open\n", fn);
+	    return NULL;
+	}
+    } else {
+	fp = NULL;
+	if (format == TT_ANY)
+	    fp = open_exp_mfile(fn, NULL);
+
+	if (!fp && NULL == (fp = open_trace_mfile(fn, NULL))) {
+	    errout("'%s': couldn't open\n", fn);
+	    return NULL;
+	}
+    }
+
+    read = mfread_reading(fp, fn, format);
+    mfclose(fp);
+
+    return read;
+}
+
+/*
+ * Read a sequence from a FILE *fp of format "format". If "format" is 0
+ * (ANY_FORMAT), we automatically determine the correct format.
+ * We still pass a filename 'fn' although this isn't used other than for
+ * filling in the read->trace_name field.
+ *
+ * NB this function should NOT be used when Biolims support is required
+ * (as biolims readings are not stored in a file)
+ *
+ * Returns:
+ *   Read *   for success
+ *   NULLRead for failure
+ */
+Read *mfread_reading(mFILE *fp, char *fn, int format) {
+    Read *read;
+    mFILE *newfp;
+
+    if (!fn)
+	fn = "(unknown)";
+
+    newfp = freopen_compressed(fp, NULL);
+    if (newfp != fp) {
+	fp = newfp;
+    } else {
+	newfp = NULL;
+    }
+
+#ifdef _WIN32
+    /*
+     * jkb 16/05/00 comment below
+     *
+     * On windows "prog < file.abi" will work wrongly (compared to
+     * "prog file.abi") because windows is rather stupid. It treats ascii
+     * and binary streams differently, it considers stdin to be ascii unless
+     * told otherwise, and it can only be told otherwise by using non-ansi
+     * windows-specific function calls.
+     */
+    if (format != TT_EXP && format != TT_PLN && fp->fp)
+	_setmode(_fileno(fp->fp), _O_BINARY);
+#endif
+
+    if (format == TT_ANY || format == TT_ANYTR) {
+	format = fdetermine_trace_type(fp);
+	mrewind(fp);
+    }
+
+    switch (format) {
+    case TT_UNK:
+    case TT_ERR:
+	errout("File '%s' has unknown trace type\n", fn);
+	read = NULLRead;
+	break;
+
+#ifdef IOLIB_SCF
+    case TT_SCF: {
+        Scf *scf;
+	scf = mfread_scf(fp);
+
+	if (scf) {
+	    read = scf2read(scf);
+	    scf_deallocate(scf);
+	} else
+	    read = NULLRead;
+
+	break;
+    }
+#endif
+
+#ifdef IOLIB_CTF
+    case TT_CTF:
+	read = mfread_ctf(fp);
+	break;
+#endif
+
+#ifdef IOLIB_SFF
+    case TT_SFF:
+	read = mfread_sff(fp);
+	break;
+#endif
+
+#ifdef IOLIB_ZTR
+    case TT_ZTR:
+    case TT_ZTR1:
+    case TT_ZTR2:
+    case TT_ZTR3: {
+        ztr_t *ztr;
+
+	if ((ztr = mfread_ztr(fp))) {
+	    uncompress_ztr(ztr);
+	    read = ztr2read(ztr);
+	    delete_ztr(ztr);
+	} else {
+	    read = NULLRead;
+	}
+	break;
+    }
+#endif
+
+#ifdef IOLIB_ABI
+    case TT_ABI:
+	read = mfread_abi(fp);
+	break;
+#endif
+
+#ifdef IOLIB_ALF
+    case TT_ALF:
+	read = mfread_alf(fp);
+	break;
+#endif
+
+#ifdef IOLIB_EXP
+    case TT_EXP: {
+	/* FIXME: we shouldn't redirect like this */
+	Exp_info *e = exp_mfread_info(fp);
+	
+	read = e ? exp2read(e,fn) : NULLRead;
+	break;
+    }
+#endif
+
+#ifdef IOLIB_PLN
+    case TT_PLN:
+	read = mfread_pln(fp);
+	break;
+#endif
+
+    default:
+	errout("Unknown format %d specified to read_reading()\n", format);
+	read = NULLRead;
+    }
+
+    if (read != NULLRead && (read->trace_name = (char *)xmalloc(strlen(fn)+1)))
+	strcpy(read->trace_name, fn);
+
+    if (newfp) mfclose(newfp);
+
+    return read;
+}
+
+Read *fread_reading(FILE *fp, char *fn, int format) {
+    return mfread_reading(mfreopen(fn, "rb", fp), fn, format);
+}
+
+/*
+ * Write a sequence to a FILE *fp of format "format". If "format" is 0,
+ * we choose our favourite - SCF.
+ *
+ * Returns:
+ *   0 for success
+ *  -1 for failure
+ */
+int mfwrite_reading(mFILE *fp, Read *read, int format) {
+    int r = -1;
+    int no_compress = 0;
+
+#ifdef _WIN32
+    /*
+     * jkb 09/06/00 comment below
+     *
+     * On windows "prog > file.scf" will work wrongly (compared to
+     * "prog file.scf") because windows is rather stupid. It treats ascii
+     * and binary streams differently, it considers stdout to be ascii unless
+     * told otherwise, and it can only be told otherwise by using non-ansi
+     * windows-specific function calls.
+     */
+    if (format != TT_EXP && format != TT_PLN && fp->fp)
+	_setmode(_fileno(fp->fp), _O_BINARY);
+#endif
+
+    switch (format) {
+    default:
+	/* Defaults to ZTR type */
+
+#ifdef IOLIB_ZTR
+    case TT_ZTR:
+    case TT_ZTR2: {
+        ztr_t *ztr;
+	ztr = read2ztr(read);
+	compress_ztr(ztr, 2);
+	r = mfwrite_ztr(fp, ztr); 
+	delete_ztr(ztr);
+	no_compress = 1;
+	break;
+    }
+    case TT_ZTR1: {
+        ztr_t *ztr;
+	ztr = read2ztr(read);
+	compress_ztr(ztr, 1);
+	r = mfwrite_ztr(fp, ztr); 
+	delete_ztr(ztr);
+	break;
+    }
+    case TT_ZTR3: {
+        ztr_t *ztr;
+	ztr = read2ztr(read);
+	compress_ztr(ztr, 3);
+	r = mfwrite_ztr(fp, ztr); 
+	delete_ztr(ztr);
+	no_compress = 1;
+	break;
+    }
+#endif
+
+#ifdef IOLIB_SCF
+    case TT_SCF: {
+        Scf *scf;
+	scf = read2scf(read);
+	r = mfwrite_scf(scf, fp);
+	scf_deallocate(scf);
+	break;
+    }
+#endif
+
+#ifdef IOLIB_CTF
+    case TT_CTF:
+	r = mfwrite_ctf(fp, read); 
+	break;
+#endif
+
+#ifdef IOLIB_ABI
+    case TT_ABI:
+	/*return mfwrite_abi(fp, read); */
+	break;
+#endif
+
+#ifdef IOLIB_SFF
+    case TT_SFF:
+	/*return mfwrite_sff(fp, read); */
+	break;
+#endif
+
+#ifdef IOLIB_ALF
+    case TT_ALF:
+	/* return mfwrite_alf(fp, read); */
+	break;
+#endif
+
+#ifdef IOLIB_EXP
+    case TT_EXP: {
+	Exp_info *e = read2exp(read, read->ident ? read->ident : "unknown");
+	
+	if (NULL == e) {
+	    fprintf(stderr, "Failed to create experiment file.\n");
+	    r = -1;
+	} else {
+	    exp_print_mfile(fp, e);
+	    exp_destroy_info(e);
+	    r = 0;
+	}
+	break;
+    }
+#endif
+
+#ifdef IOLIB_PLN
+    case TT_PLN:
+	r = mfwrite_pln(fp, read);
+	break;
+#endif
+    }
+
+    mftruncate(fp, -1);
+    if (r == 0 && !no_compress) {
+	fcompress_file(fp);
+    }
+    mfflush(fp);
+
+    return r;
+}
+
+int fwrite_reading(FILE *fp, Read *read, int format) {
+    int ret;
+    mFILE *mf = mfreopen(NULL, "wbx", fp);
+    if (mf) {
+	ret = mfwrite_reading(mf, read, format);
+	mfflush(mf);
+	mf->fp = NULL; /* Don't want this closed here */
+	mfclose(mf);
+    } else {
+	return -1;
+    }
+
+    return ret;
+}
+
+/*
+ * 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;
+}
+
+/*
+ * Old style stub interfaces implemented simply as redirection through
+ * fread_reading and frwrite_reading.
+ */
+#ifdef IOLIB_ABI
+Read *fread_abi(FILE *fp) {
+    return fread_reading(fp, NULL, TT_ABI);
+}
+
+int fwrite_abi(FILE *fp, Read *read) {
+    return fwrite_reading(fp, read, TT_ABI);
+}
+#endif
+
+#ifdef IOLIB_ALF
+Read *fread_alf(FILE *fp) {
+    return fread_reading(fp, NULL, TT_ALF);
+}
+
+int fwrite_alf(FILE *fp, Read *read) {
+    return fwrite_reading(fp, read, TT_ALF);
+}
+#endif
+
+#ifdef IOLIB_CTF
+Read *fread_ctf(FILE *fp) {
+    return fread_reading(fp, NULL, TT_CTF);
+}
+
+int fwrite_ctf(FILE *fp, Read *read) {
+    return fwrite_reading(fp, read, TT_CTF);
+}
+#endif
+
+#ifdef IOLIB_PLN
+Read *fread_pln(FILE *fp) {
+    return fread_reading(fp, NULL, TT_PLN);
+}
+
+int fwrite_pln(FILE *fp, Read *read) {
+    return fwrite_reading(fp, read, TT_PLN);
+}
+#endif
+
+#ifdef IOLIB_ZTR
+ztr_t *fread_ztr(FILE *fp) {
+    ztr_t *z;
+    mFILE *mf;
+
+    if (NULL == (mf = mfreopen(NULL, "rb", fp)))
+	return NULL;
+
+    z = mfread_ztr(mf);
+    mfclose(mf);
+    return z;
+}
+
+int fwrite_ztr(FILE *fp, ztr_t *z) {
+    mFILE *mf;
+    int r;
+
+    if (NULL == (mf = mfreopen(NULL, "wbx", fp)))
+	return -1;
+
+    r = mfwrite_ztr(mf, z);
+    mfflush(mf);
+    mf->fp = NULL; /* Don't want this closed here */
+    mfclose(mf);
+    return r;
+}
+#endif
+
+#ifdef IOLIB_SCF
+Scf *fread_scf(FILE *fp) {
+    Scf *s;
+    mFILE *mf;
+
+    if (NULL == (mf = mfreopen(NULL, "rb", fp)))
+	return NULL;
+
+    s = mfread_scf(mf);
+    mf->fp = NULL; /* Don't want this closed here */
+    mfclose(mf);
+    return s;
+}
+
+int fwrite_scf(Scf *s, FILE *fp) {
+    mFILE *mf;
+    int r;
+
+    if (NULL == (mf = mfreopen(NULL, "wbx", fp)))
+	return -1;
+
+    r = mfwrite_scf(s, mf);
+    mfflush(mf);
+    mf->fp = NULL; /* Don't want this closed here */
+    mfclose(mf);
+    return r;
+}
+#endif
+
+#ifdef IOLIB_EXP
+Exp_info *exp_fread_info(FILE *fp) {
+    Exp_info *e;
+    mFILE *mf;
+
+    if (NULL == (mf = mfreopen(NULL, "rb", fp)))
+	return NULL;
+
+    e = exp_mfread_info(mf);
+    mf->fp = NULL; /* Don't want this closed here */
+    mfclose(mf);
+    return e;
+}
+
+void exp_print_file(FILE *fp, Exp_info *e) {
+    mFILE *mf;
+
+    if (NULL == (mf = mfreopen(NULL, "wbx", fp)))
+	return;
+
+    exp_print_mfile(mf, e);
+    mfflush(mf);
+    mf->fp = NULL; /* Don't want this closed here */
+    mfclose(mf);
+}
+#endif