freesasa-sys 0.1.12

Rust raw FFI bindings for the freesasa C library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

#if HAVE_CONFIG_H
#include <config.h>
#endif
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#include "freesasa_internal.h"

#ifdef PACKAGE_NAME
const char *freesasa_name = PACKAGE_NAME;
#else
const char *freesasa_name = "freesasa";
#endif

static FILE *errlog = NULL;

struct file_range
freesasa_whole_file(FILE *file)
{
    struct file_range range;

    assert(file);
    rewind(file);
    range.begin = ftell(file);
    fseek(file, 0, SEEK_END);
    range.end = ftell(file);
    rewind(file);
    assert(range.begin <= range.end);

    return range;
}

static void
freesasa_err_impl(int err,
                  const char *format,
                  va_list arg)
{
    FILE *fp = stderr;

    if (errlog != NULL) fp = errlog;

    fprintf(fp, "%s: ", freesasa_name);
    switch (err) {
    case FREESASA_FAIL:
        fputs("error: ", fp);
        break;
    case FREESASA_WARN:
        fputs("warning: ", fp);
        break;
    default:
        break;
    }
    vfprintf(fp, format, arg);
    va_end(arg);
    fputc('\n', fp);
    fflush(fp);
}

int freesasa_fail(const char *format, ...)
{
    va_list arg;

    if (freesasa_get_verbosity() == FREESASA_V_SILENT) return FREESASA_FAIL;

    va_start(arg, format);
    freesasa_err_impl(FREESASA_FAIL, format, arg);
    va_end(arg);

    return FREESASA_FAIL;
}

int freesasa_warn(const char *format, ...)
{
    va_list arg;
    int v = freesasa_get_verbosity();

    if (v == FREESASA_V_NOWARNINGS || v == FREESASA_V_SILENT) return FREESASA_WARN;

    va_start(arg, format);
    freesasa_err_impl(FREESASA_WARN, format, arg);
    va_end(arg);

    return FREESASA_WARN;
}

int freesasa_fail_wloc(const char *file,
                       int line,
                       const char *format,
                       ...)
{
    FILE *fp = stderr;
    va_list arg;

    if (freesasa_get_verbosity() == FREESASA_V_SILENT) return FREESASA_FAIL;
    if (errlog != NULL) fp = errlog;

    fprintf(fp, "%s:%s:%d: error: ", freesasa_name, file, line);
    va_start(arg, format);
    vfprintf(fp, format, arg);
    va_end(arg);
    fputc('\n', fp);
    fflush(fp);

    return FREESASA_FAIL;
}

int freesasa_mem_fail(const char *file, int line)
{
    return freesasa_fail_wloc(file, line, "Out of memory");
}

const char *
freesasa_thread_error(int error_code)
{
    switch (error_code) {
    case EDEADLK:
        return "deadlock (EDEADLK)";
    case EINVAL:
        return "(EINVAL)";
    case ESRCH:
        return "no matching thread (ESRCH)";
    case EAGAIN:
        return "no resources to create thread (EAGAIN)";
    }
    return "Unknown thread error";
}

void freesasa_set_err_out(FILE *fp)
{
    assert(fp);
    errlog = fp;
}

FILE *
freesasa_get_err_out()
{
    return errlog;
}