Beispiel #1
0
char *
uproc_io_gets(char *s, int size, uproc_io_stream *stream)
{
    char *res;
    switch (stream->type) {
        case UPROC_IO_GZIP:
#if HAVE_ZLIB_H
            res = gzgets(stream->s.gz, s, size);
            if (!res) {
                int num;
                const char *msg = gzerror(stream->s.gz, &num);
                if (num != Z_OK && num != Z_STREAM_END) {
                    uproc_error_msg(UPROC_EIO,
                                    "failed to read from gz stream: %d %s", num, msg);
                }
            }
            break;
#endif
        case UPROC_IO_STDIO:
            res = fgets(s, size, stream->s.fp);
            if (!res && ferror(stream->s.fp)) {
                uproc_error_msg(UPROC_EIO, "failed to read from stream");
            }
            break;
        default:
            uproc_error_msg(UPROC_EINVAL, "invalid stream");
            return NULL;
    }
    return res;
}
Beispiel #2
0
int
uproc_io_seek(uproc_io_stream *stream, long offset,
              enum uproc_io_seek_whence whence)
{
    int w;
    switch (whence) {
        case UPROC_IO_SEEK_SET:
            w = SEEK_SET;
            break;
        case UPROC_IO_SEEK_CUR:
            w = SEEK_CUR;
            break;
    }

    switch (stream->type) {
        case UPROC_IO_GZIP:
#if HAVE_ZLIB_H
            return gzseek(stream->s.gz, offset, w) >= 0 ? 0 : -1;
#endif
        case UPROC_IO_STDIO:
            return fseek(stream->s.fp, offset, w);
    }
    uproc_error_msg(UPROC_EINVAL, "invalid stream");
    return -1;
}
Beispiel #3
0
uproc_io_stream *
uproc_io_stdstream_gz(FILE *stream) {
    if (stream == stdin) {
        return uproc_io_stdstream(stdin);
    }
    uproc_error_msg(UPROC_ENOTSUP, "gzip compression not available");
    return NULL;
}
Beispiel #4
0
int uproc_list_add(uproc_list *list, const uproc_list *src)
{
    if (list->value_size != src->value_size) {
        return uproc_error_msg(UPROC_EINVAL,
                               "can't add lists with different value sizes");
    }
    return uproc_list_extend(list, src->data, src->size);
}
Beispiel #5
0
int uproc_list_extend(uproc_list *list, const void *values, long n)
{
    int res;
    if (n < 0) {
        return uproc_error_msg(UPROC_EINVAL, "negative number of items");
    }
    if (n > (LONG_MAX - list->size)) {
        return uproc_error_msg(UPROC_EINVAL, "list too big");
    }

    res = list_grow(list, n);
    if (res) {
        return res;
    }
    memcpy(list->data + list->size * list->value_size, values,
           n * list->value_size);
    list->size += n;
    return 0;
}
Beispiel #6
0
int uproc_list_check_value_size(const uproc_list *list, size_t value_size)
{
    if (value_size && value_size != list->value_size) {
        return uproc_error_msg(UPROC_EINVAL,
                               "list value size %lu (possibly) doesn't match "
                               "size of passed object %lu",
                               (unsigned long)list->value_size,
                               (unsigned long)value_size);
    }
    return 0;
}
Beispiel #7
0
int uproc_list_pop(uproc_list *list, void *value)
{
    if (list->size < 1) {
        return uproc_error_msg(UPROC_EINVAL, "pop from empty list");
    }
    uproc_list_get(list, list->size - 1, value);
    list->size--;
    if (list->size > list->capacity / 4) {
        return 0;
    }
    return list_realloc(list, list->capacity / 2);
}
Beispiel #8
0
int
uproc_io_close(uproc_io_stream *stream)
{
    int res = 1;
    if (!stream) {
        return 0;
    }
    switch (stream->type) {
        case UPROC_IO_GZIP:
#if HAVE_ZLIB_H
            if (stream->s.gz) {
                res = gzclose(stream->s.gz);
                stream->s.gz = NULL;
                if (res == Z_OK) {
                    res = 0;
                }
                else {
                    res = uproc_error_msg(UPROC_ERRNO,
                                         "error closing gz stream");
                }
            }
            break;
#endif
        case UPROC_IO_STDIO:
            if (stream->s.fp) {
                res = fclose(stream->s.fp);
                if (res) {
                    res = -1;
                }
                stream->s.fp = NULL;
            }
            break;
        default:
            return uproc_error_msg(UPROC_EINVAL, "invalid stream");
    }
    if (!stream->stdstream) {
        free(stream);
    }
    return res;
}
Beispiel #9
0
int uproc_list_set(uproc_list *list, long index, const void *value)
{
    long idx = index;
    if (idx < 0) {
        idx += list->size;
    }
    if (idx < 0 || idx >= list->size) {
        return uproc_error_msg(UPROC_EINVAL, "list index %ld out of range",
                               index);
    }
    memcpy(list->data + idx * list->value_size, value, list->value_size);
    return 0;
}
Beispiel #10
0
int
uproc_io_eof(uproc_io_stream *stream)
{
    switch (stream->type) {
        case UPROC_IO_GZIP:
#if HAVE_ZLIB_H
            return gzeof(stream->s.gz);
#endif
        case UPROC_IO_STDIO:
            return feof(stream->s.fp);
    }
    uproc_error_msg(UPROC_EINVAL, "invalid stream");
    return 0;
}
Beispiel #11
0
int
database_load(struct database *db, const char *path, int prot_thresh_level,
              enum uproc_ecurve_format format)
{
    db->fwd = db->rev = NULL;
    db->idmap = NULL;
    db->prot_thresh = NULL;

    switch (prot_thresh_level) {
        case 2:
        case 3:
            db->prot_thresh = uproc_matrix_load(
                UPROC_IO_GZIP, "%s/prot_thresh_e%d", path, prot_thresh_level);
            if (!db->prot_thresh) {
                goto error;
            }
            break;

        case 0:
            break;

        default:
            uproc_error_msg(
                UPROC_EINVAL, "protein threshold level must be 0, 2, or 3");
            goto error;
    }

    db->idmap = uproc_idmap_load(UPROC_IO_GZIP, "%s/idmap", path);
    if (!db->idmap) {
        goto error;
    }
    db->fwd = uproc_ecurve_load(format, UPROC_IO_GZIP, "%s/fwd.ecurve", path);
    if (!db->fwd) {
        goto error;
    }
    db->rev = uproc_ecurve_load(format, UPROC_IO_GZIP, "%s/rev.ecurve", path);
    if (!db->rev) {
        goto error;
    }

    return 0;
error:
    database_free(db);
    return -1;
}
Beispiel #12
0
int
model_load(struct model *m, const char *path, int orf_thresh_level)
{
    m->substmat = NULL;
    m->codon_scores = m->orf_thresh = NULL;

    m->substmat = uproc_substmat_load(UPROC_IO_GZIP, "%s/substmat", path);
    if (!m->substmat) {
        goto error;
    }

    m->codon_scores = uproc_matrix_load(UPROC_IO_GZIP, "%s/codon_scores",
                                      path);
    if (!m->codon_scores) {
        goto error;
    }

    switch (orf_thresh_level) {
        case 1:
        case 2:
            m->orf_thresh = uproc_matrix_load(UPROC_IO_GZIP, "%s/orf_thresh_e%d",
                                            path, orf_thresh_level);
            if (!m->orf_thresh) {
                goto error;
            }
            break;

        case 0:
            break;

        default:
            uproc_error_msg(
                UPROC_EINVAL, "ORF threshold level must be 0, 1, or 2");
            goto error;
    }

    return 0;
error:
    model_free(m);
    return -1;
}
Beispiel #13
0
int
uproc_io_printf(uproc_io_stream *stream, const char *fmt, ...)
{
    int res = -1;
    va_list ap;
    va_start(ap, fmt);
    switch (stream->type) {
        case UPROC_IO_GZIP:
#if HAVE_ZLIB_H
            res = gzvprintf(stream->s.gz, fmt, ap);
            break;
#endif
        case UPROC_IO_STDIO:
            res = vfprintf(stream->s.fp, fmt, ap);
            break;
        default:
            res = uproc_error_msg(UPROC_EINVAL, "invalid stream");
    }
    va_end(ap);
    return res;
}
Beispiel #14
0
static uproc_io_stream *
io_open(const char *path, const char *mode, enum uproc_io_type type)
{
    uproc_io_stream *stream = malloc(sizeof *stream);
    if (!stream) {
        uproc_error(UPROC_ENOMEM);
        return NULL;
    }
    stream->type = type;
    stream->stdstream = false;
    switch (stream->type) {
        case UPROC_IO_GZIP:
#if HAVE_ZLIB_H
            if (!(stream->s.gz = gzopen(path, mode))) {
                /* gzopen sets errno to 0 if memory allocation failed */
                if (!errno) {
                    uproc_error(UPROC_ENOMEM);
                    goto error;
                }
                goto error_errno;
            }
            (void) gzbuffer(stream->s.gz, GZIP_BUFSZ);
            break;
#endif
        case UPROC_IO_STDIO:
            if (!(stream->s.fp = fopen(path, mode))) {
                goto error_errno;
            }
            break;
        default:
            goto error;
    }
    return stream;
error_errno:
    uproc_error_msg(UPROC_ERRNO, "can't open \"%s\" with mode \"%s\"",
                    path, mode);
error:
    free(stream);
    return NULL;
}
Beispiel #15
0
uproc_list *uproc_list_create(size_t value_size)
{
    struct uproc_list_s *list;
    if (!value_size) {
        uproc_error_msg(UPROC_EINVAL, "value size must be non-zero");
        return NULL;
    }

    list = malloc(sizeof *list);
    if (!list) {
        uproc_error(UPROC_ENOMEM);
        return NULL;
    }
    list->size = list->capacity = 0;
    list->value_size = value_size;
    list->data = NULL;

    if (list_realloc(list, 0)) {
        free(list);
        return NULL;
    }
    return list;
}
Beispiel #16
0
size_t
uproc_io_read(void *ptr, size_t size, size_t nmemb, uproc_io_stream *stream)
{
    switch (stream->type) {
        case UPROC_IO_GZIP:
#if HAVE_ZLIB_H
            {
                size_t i, n;
                for (i = 0; i < nmemb; i++) {
                    n = gzread(stream->s.gz, (char*)ptr + i * size, size);
                    if (n != size) {
                        break;
                    }
                }
                return i;
            }
#endif
        case UPROC_IO_STDIO:
            return fread(ptr, size, nmemb, stream->s.fp);
    }
    uproc_error_msg(UPROC_EINVAL, "invalid stream");
    return 0;
}
Beispiel #17
0
/* Doubles the capacity of a list. If (value_size * capacity) would exceed
 * MAX_SIZE, use (MAX_SIZE / value_size) instead of doubling.
 * Fails if the size is already (MAX_SIZE / value_size).  */
static int list_grow(struct uproc_list_s *list, long n)
{
    long cap_req, cap_new, cap_max;

    cap_req = list->size + n;
    if (cap_req < list->capacity) {
        return 0;
    }

    cap_max = MAX_SIZE / list->value_size;
    if (list->capacity == cap_max || cap_req > cap_max) {
        return uproc_error_msg(UPROC_EINVAL, "list too big");
    }

    if (cap_max / 2 > list->capacity) {
        cap_new = list->capacity * 2;
    } else {
        cap_new = cap_max;
    }
    if (cap_new < cap_req) {
        cap_new = cap_req;
    }
    return list_realloc(list, cap_new);
}