Reset repository and upload final project (part 2)

.gitattributes

@@ -61,3 +61,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/bin/python filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/bin/python3 filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/bin/python3.12 filter=lfs diff=lfs merge=lfs -text
+.venv_haddock/lib/python3.12/site-packages/Bio/Align/_pairwisealigner.cpython-312-darwin.so filter=lfs diff=lfs merge=lfs -text

.venv_haddock/include/site/python3.12/freesasa/parser.h

@@ -0,0 +1,97 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_FREESASA_YY_PARSER_H_INCLUDED
+# define YY_FREESASA_YY_PARSER_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int freesasa_yydebug;
+#endif
+/* "%code requires" blocks.  */
+#line 13 "parser.y" /* yacc.c:1909  */
+
+
+#ifndef FREESASA_TYPEDEF_YY_SCANNER_T
+#define FREESASA_TYPEDEF_YY_SCANNER_T
+    typedef void* freesasa_yyscan_t;
+#endif
+
+
+#line 53 "parser.h" /* yacc.c:1909  */
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    T_NUMBER = 258,
+    T_ID = 259,
+    T_SELID = 260,
+    T_AND = 261,
+    T_OR = 262,
+    T_NOT = 263,
+    T_RESN = 264,
+    T_RESI = 265,
+    T_SYMBOL = 266,
+    T_NAME = 267,
+    T_CHAIN = 268,
+    T_MINUS = 269,
+    ATOM = 270
+  };
+#endif
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+#line 30 "parser.y" /* yacc.c:1909  */
+
+    const char *value;
+    expression *expression;
+
+#line 86 "parser.h" /* yacc.c:1909  */
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+int freesasa_yyparse (expression **expression, freesasa_yyscan_t scanner);
+
+#endif /* !YY_FREESASA_YY_PARSER_H_INCLUDED  */

.venv_haddock/include/site/python3.12/freesasa/pdb.c

@@ -0,0 +1,432 @@
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "freesasa_internal.h"
+#include "pdb.h"
+
+/* len >= 6 */
+static inline int
+pdb_line_check(const char *line, size_t len)
+{
+    assert(line);
+    if (len < 6) return FREESASA_FAIL;
+    if (strlen(line) < len) return FREESASA_FAIL;
+    if (strncmp("ATOM", line, 4) != 0 &&
+        strncmp("HETATM", line, 6) != 0) {
+        return FREESASA_FAIL;
+    }
+    return FREESASA_SUCCESS;
+}
+
+/**
+    Extracts a double from the line of maximum width characters, to
+    allow checking for empty fields (instead of just reading the first
+    float that comes along.
+ */
+static inline int
+pdb_get_double(const char *line, size_t width, double *val)
+{
+    /* allow truncated lines */
+    char buf[PDB_LINE_STRL];
+    float tmp;
+
+    if (strlen(line) < width) width = strlen(line);
+
+    memcpy(buf, line, width);
+    buf[width] = '\0';
+
+    if (sscanf(buf, "%f", &tmp) == 1) {
+        *val = tmp;
+        return FREESASA_SUCCESS;
+    }
+
+    return FREESASA_FAIL;
+}
+
+int freesasa_pdb_get_models(FILE *pdb,
+                            struct file_range **ranges)
+{
+    char line[PDB_MAX_LINE_STRL];
+    int n = 0, n_end = 0, error = 0;
+    long last_pos = ftell(pdb);
+    struct file_range *it = NULL, *itb;
+
+    assert(pdb != NULL);
+
+    while (fgets(line, PDB_MAX_LINE_STRL, pdb) != NULL) {
+        if (strncmp("MODEL", line, 5) == 0) {
+            ++n;
+            itb = it;
+            it = realloc(it, sizeof(struct file_range) * n);
+            if (!it) {
+                free(itb);
+                error = mem_fail();
+                break;
+            }
+            it[n - 1].begin = last_pos;
+        }
+        if (strncmp("ENDMDL", line, 6) == 0) {
+            ++n_end;
+            if (n != n_end) {
+                error = fail_msg("mismatch between MODEL and ENDMDL in input");
+                break;
+            }
+            it[n - 1].end = ftell(pdb);
+        }
+        last_pos = ftell(pdb);
+    }
+    if (n == 0) { /* when there are no models, the whole file is the model */
+        free(it);
+        it = NULL;
+    }
+    if (error == FREESASA_FAIL) {
+        free(it);
+        *ranges = NULL;
+        return FREESASA_FAIL;
+    }
+    *ranges = it;
+    return n;
+}
+
+int freesasa_pdb_get_chains(FILE *pdb,
+                            struct file_range model,
+                            struct file_range **ranges,
+                            int options)
+{
+    /* it is assumed that 'model' is valid for 'pdb' */
+
+    int n_chains = 0;
+    char line[PDB_MAX_LINE_STRL];
+    struct file_range *chains = NULL, *chb;
+    char last_chain = '\0';
+    long last_pos = model.begin;
+
+    assert(pdb);
+    assert(ranges);
+
+    *ranges = NULL;
+
+    /* for each model, find file ranges for each chain, store them
+       in the dynamically growing array chains */
+    fseek(pdb, model.begin, SEEK_SET);
+    while (fgets(line, PDB_MAX_LINE_STRL, pdb) != NULL &&
+           ftell(pdb) < model.end) {
+        if (strncmp("ATOM", line, 4) == 0 || ((options & FREESASA_INCLUDE_HETATM) &&
+                                              (strncmp("HETATM", line, 6) == 0))) {
+            char chain = freesasa_pdb_get_chain_label(line);
+            if (chain != last_chain) {
+                if (n_chains > 0) chains[n_chains - 1].end = last_pos;
+                ++n_chains;
+                chb = chains;
+                chains = realloc(chains, sizeof(struct file_range) * n_chains);
+                if (!chains) {
+                    free(chb);
+                    return mem_fail();
+                }
+                chains[n_chains - 1].begin = last_pos;
+                last_chain = chain;
+            }
+        }
+        last_pos = ftell(pdb);
+    }
+
+    if (n_chains > 0) {
+        chains[n_chains - 1].end = last_pos;
+        chains[0].begin = model.begin; /* preserve model info */
+        *ranges = chains;
+    } else {
+        *ranges = NULL;
+    }
+    return n_chains;
+}
+
+int freesasa_pdb_get_atom_name(char *name,
+                               const char *line)
+{
+    assert(name);
+    assert(line);
+    if (pdb_line_check(line, PDB_ATOM_NAME_STRL + 12) == FREESASA_FAIL) {
+        name[0] = '\0';
+        return FREESASA_FAIL;
+    }
+    strncpy(name, line + 12, PDB_ATOM_NAME_STRL);
+    name[PDB_ATOM_NAME_STRL] = '\0';
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_pdb_get_res_name(char *name,
+                              const char *line)
+{
+    assert(name);
+    assert(line);
+    if (pdb_line_check(line, PDB_ATOM_RES_NAME_STRL + 17) == FREESASA_FAIL) {
+        name[0] = '\0';
+        return FREESASA_FAIL;
+    }
+    strncpy(name, line + 17, PDB_ATOM_RES_NAME_STRL);
+    name[PDB_ATOM_RES_NAME_STRL] = '\0';
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_pdb_get_coord(double *xyz,
+                           const char *line)
+{
+    int n_coord = 24; /* 54-30+1 */
+    char coord_section[25];
+
+    assert(xyz);
+    assert(line);
+
+    if (pdb_line_check(line, 54) == FREESASA_FAIL) {
+        return FREESASA_FAIL;
+    }
+
+    strncpy(coord_section, line + 30, n_coord);
+    coord_section[n_coord] = '\0';
+
+    if (sscanf(coord_section, "%lf%lf%lf", &xyz[0], &xyz[1], &xyz[2]) != 3) {
+        return fail_msg("could not read coordinates from line '%s'", line);
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_pdb_get_res_number(char *number,
+                                const char *line)
+{
+    assert(number);
+    assert(line);
+    if (pdb_line_check(line, PDB_ATOM_RES_NUMBER_STRL + 22) == FREESASA_FAIL) {
+        number[0] = '\0';
+        return FREESASA_FAIL;
+    }
+    strncpy(number, line + 22, PDB_ATOM_RES_NUMBER_STRL);
+    number[PDB_ATOM_RES_NUMBER_STRL] = '\0';
+    return FREESASA_SUCCESS;
+}
+char freesasa_pdb_get_chain_label(const char *line)
+{
+    assert(line);
+    if (pdb_line_check(line, 21) == FREESASA_FAIL) return '\0';
+    return line[21];
+}
+
+char freesasa_pdb_get_alt_coord_label(const char *line)
+{
+    assert(line);
+    if (pdb_line_check(line, 16) == FREESASA_FAIL) return '\0';
+    return line[16];
+}
+
+int freesasa_pdb_get_symbol(char *symbol,
+                            const char *line)
+{
+    assert(line);
+    if (pdb_line_check(line, 76 + PDB_ATOM_SYMBOL_STRL) == FREESASA_FAIL) {
+        symbol[0] = '\0';
+        return FREESASA_FAIL;
+    }
+    strncpy(symbol, line + 76, 2);
+    symbol[2] = '\0';
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_pdb_get_occupancy(double *occ,
+                               const char *line)
+{
+    assert(line);
+    /* allow truncated lines */
+    if (pdb_line_check(line, 55) == FREESASA_SUCCESS)
+        return pdb_get_double(line + 54, 6, occ);
+    return FREESASA_FAIL;
+}
+
+int freesasa_pdb_get_bfactor(double *bfac,
+                             const char *line)
+{
+    assert(line);
+    /* allow truncated lines */
+    if (pdb_line_check(line, 61) == FREESASA_SUCCESS)
+        return pdb_get_double(line + 60, 6, bfac);
+    return FREESASA_FAIL;
+}
+
+int freesasa_pdb_ishydrogen(const char *line)
+{
+    assert(line);
+    char symbol[PDB_ATOM_SYMBOL_STRL + 1];
+    freesasa_pdb_get_symbol(symbol, line);
+
+    if (pdb_line_check(line, 13) == FREESASA_FAIL) return FREESASA_FAIL;
+
+    /* Check symbol first */
+    if (strncmp(symbol, " H", 2) == 0) return 1;
+    if (strncmp(symbol, " D", 2) == 0) return 1;
+    /* If the symbol is not blank and not H or D */
+    if (!(strncmp(symbol, "  ", 2) == 0)) return 0;
+
+    /* When symbol is missing */
+    /* Cover elements such as Cd, Nd, Th, etc. ("CD  ", "ND  ") */
+    if (!(line[12] == ' ' || (line[12] >= '1' && line[12] <= '9'))) return 0;
+    /* Hydrogen, atom name "H**" or " H**" */
+    if (line[12] == 'H' || line[13] == 'H') return 1;
+    /* Deuterium */
+    if (line[12] == 'D' || line[13] == 'D') return 1;
+    return 0;
+}
+
+static int
+write_pdb_impl(FILE *output,
+               freesasa_node *structure)
+{
+    char buf[PDB_LINE_STRL + 1], buf2[6];
+    int model;
+    double radius;
+    const char *line = NULL;
+    freesasa_node *chain = NULL, *residue = NULL, *atom = NULL;
+    const freesasa_nodearea *area = NULL;
+    const char *last_res_name = NULL, *last_res_number = NULL, *last_chain = NULL;
+
+    assert(freesasa_node_type(structure) == FREESASA_NODE_STRUCTURE);
+
+    model = freesasa_node_structure_model(structure);
+    if (model > 0)
+        fprintf(output, "MODEL     %4d\n", model);
+    else
+        fprintf(output, "MODEL        1\n");
+
+    chain = freesasa_node_children(structure);
+
+    /* Write ATOM entries */
+    while (chain) {
+        residue = freesasa_node_children(chain);
+        while (residue) {
+            atom = freesasa_node_children(residue);
+            while (atom) {
+                line = freesasa_node_atom_pdb_line(atom);
+                area = freesasa_node_area(atom);
+                radius = freesasa_node_atom_radius(atom);
+
+                if (line == NULL) {
+                    return fail_msg("PDB input not valid or not present");
+                }
+
+                strncpy(buf, line, PDB_LINE_STRL);
+                sprintf(&buf[54], "%6.2f%6.2f", radius, area->total);
+                fprintf(output, "%s\n", buf);
+
+                atom = freesasa_node_next(atom);
+            }
+            last_res_name = freesasa_node_name(residue);
+            last_res_number = freesasa_node_residue_number(residue);
+            residue = freesasa_node_next(residue);
+        }
+        last_chain = freesasa_node_name(chain);
+        chain = freesasa_node_next(chain);
+    }
+
+    /* Write TER and ENDMDL lines */
+    strncpy(buf2, &buf[6], 5);
+    buf2[5] = '\0';
+    fprintf(output, "TER   %5d     %4s %c%5s\nENDMDL\n",
+            atoi(buf2) + 1, last_res_name, last_chain[0], last_res_number);
+
+    fflush(output);
+    if (ferror(output)) {
+        return fail_msg(strerror(errno));
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_write_pdb(FILE *output,
+                       freesasa_node *root)
+{
+    freesasa_node *result = freesasa_node_children(root), *structure;
+
+    assert(output);
+    assert(root);
+    assert(freesasa_node_type(root) == FREESASA_NODE_ROOT);
+
+    fprintf(output, "REMARK 999 This PDB file was generated by %s.\n", freesasa_string);
+    fprintf(output, "REMARK 999 In the ATOM records temperature factors have been\n"
+                    "REMARK 999 replaced by the SASA of the atom, and the occupancy\n"
+                    "REMARK 999 by the radius used in the calculation.\n");
+
+    while (result) {
+        structure = freesasa_node_children(result);
+        while (structure) {
+            if (write_pdb_impl(output, structure) == FREESASA_FAIL) {
+                return fail_msg("");
+            }
+            structure = freesasa_node_next(structure);
+        }
+        result = freesasa_node_next(result);
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+#if USE_CHECK
+#include <check.h>
+#include <math.h>
+
+START_TEST(test_pdb)
+{
+    double v;
+    ck_assert(pdb_line_check("", 6) == FREESASA_FAIL);
+    ck_assert(pdb_line_check("ATOM", 4) == FREESASA_FAIL);
+    ck_assert(pdb_line_check("ATOM", 6) == FREESASA_FAIL);
+    ck_assert(pdb_line_check("HETAT", 6) == FREESASA_FAIL);
+    ck_assert(pdb_line_check("HETAT ", 6) == FREESASA_FAIL);
+    ck_assert(pdb_line_check("BLA BLA BLA", 10) == FREESASA_FAIL);
+    ck_assert(pdb_line_check("BLA BLA BLA", 11) == FREESASA_FAIL);
+    ck_assert(pdb_line_check("BLA BLA BLA", 12) == FREESASA_FAIL);
+
+    /* these will pass, although they would be useless */
+    ck_assert(pdb_line_check("ATOM  ", 6) == FREESASA_SUCCESS);
+    ck_assert(pdb_line_check("HETATM", 6) == FREESASA_SUCCESS);
+
+    /* a more likely type of error */
+    ck_assert(pdb_line_check("HETATM", 7) == FREESASA_FAIL);
+
+    /* The normal case */
+    ck_assert(pdb_line_check("ATOM      1  N   MET A   1      27.340  "
+                             "24.430   2.614  1.00  9.67           N  ",
+                             80) == FREESASA_SUCCESS);
+
+    v = 0;
+    ck_assert(pdb_get_double("1.23", 4, &v) == FREESASA_SUCCESS);
+    ck_assert(fabs(1.23 - v) < 1e-5);
+    v = 0;
+    ck_assert(pdb_get_double(" 1.23", 5, &v) == FREESASA_SUCCESS);
+    ck_assert(fabs(1.23 - v) < 1e-5);
+    v = 0;
+    ck_assert(pdb_get_double("1.23", 10, &v) == FREESASA_SUCCESS);
+    ck_assert(fabs(1.23 - v) < 1e-5);
+    v = 0;
+    ck_assert(pdb_get_double("1.23 4.56", 10, &v) == FREESASA_SUCCESS);
+    ck_assert(fabs(1.23 - v) < 1e-5);
+
+    ck_assert(pdb_get_double("  ", 10, &v) == FREESASA_FAIL);
+    ck_assert(pdb_get_double("    1.23", 4, &v) == FREESASA_FAIL);
+    ck_assert(pdb_get_double("abc", 10, &v) == FREESASA_FAIL);
+    ck_assert(pdb_get_double("a 1.23", 6, &v) == FREESASA_FAIL);
+}
+END_TEST
+
+TCase *
+test_pdb_static()
+{
+    TCase *tc = tcase_create("pdb.c static");
+    tcase_add_test(tc, test_pdb);
+
+    return tc;
+}
+
+#endif /* USE_CHECK */

.venv_haddock/include/site/python3.12/freesasa/pdb.h

@@ -0,0 +1,187 @@
+#ifndef FREESASA_PDB_H
+#define FREESASA_PDB_H
+
+#include "freesasa.h"
+#include "freesasa_internal.h"
+
+/**
+    @file
+    @author Simon Mitternacht
+
+    The following functions all extract info from the PDB lines `ATOM`
+    and `HETATM`. Valid lines have to begin with either `ATOM` or
+    `HETATM` and be sufficiently long to contain the value in
+    question.
+*/
+
+#define PDB_ATOM_NAME_STRL 4       /**< Length of strings with atom names, such as `" CA "`. */
+#define PDB_ATOM_RES_NAME_STRL 3   /**< Length of string with residue names, such as `"ALA"`. */
+#define PDB_ATOM_RES_NUMBER_STRL 5 /**< Length of string with residue number, such as `" 123"`. */
+#define PDB_ATOM_SYMBOL_STRL 2     /**< Length for string with element symbol, such "FE". */
+#define PDB_LINE_STRL 80           /**< Length of a line in PDB file. */
+#define PDB_MAX_LINE_STRL 120      /**< for reading, allows nonstandard input with extra fields. */
+
+/**
+    Finds the location of all MODEL entries in the file pdb, returns
+    the number of models found.
+
+    The array *ranges will be dynamically allocated to contain a
+    file ranges for each model.
+
+    @return Returns 0 if no MODEL lines were found (for example an
+      X-ray structure with only one model) and sets *ranges to
+      NULL. A return value of 0 doesn't have to mean the file is
+      empty. ::FREESASA_FAIL if malloc-failure.
+ */
+int freesasa_pdb_get_models(FILE *pdb,
+                            struct file_range **ranges);
+
+/**
+    Finds the location of all chains within the file range 'model'.
+
+    @param pdb The pdb-file
+    @param model The ::file_range to search for chains within.
+    @param ranges The address to a dynamically allocated array
+      containing the ::file_range of each chain will be stored here.
+    @param options Bitfield, can be used to set
+      ::FREESASA_INCLUDE_HETATM.
+    @return Number of chains found. Returns ::FREESASA_FAIL if memory
+      allocation fails.
+ */
+int freesasa_pdb_get_chains(FILE *pdb,
+                            struct file_range model,
+                            struct file_range **ranges,
+                            int options);
+/**
+    Get atom name from a PDB line.
+
+    Extracts the whole atom name field from an `ATOM` or `HETATM` PDB
+    line, including padding, i.e. a string of ::PDB_ATOM_NAME_STRL
+    characters. For example `" CA "` for a regular C-alpha.  If the
+    line is invalid, the name will be an empty string and the function
+    returns ::FREESASA_FAIL.
+
+    @param name The name is written to this string.
+    @param line Line from a PDB file.
+    @return ::FREESASA_SUCCESS if input is readable, else ::FREESASA_FAIL.
+ */
+int freesasa_pdb_get_atom_name(char *name,
+                               const char *line);
+
+/**
+    Get residue name from a PDB line.
+
+    Extracts the whole residue name from an `ATOM` or `HETATM` PDB
+    line, i.e. a string of ::PDB_ATOM_RES_NAME_STRL characters. For
+    example `"ALA"` for an Alanine. If theline is invalid, the name
+    will be an empty string and the function returns ::FREESASA_FAIL.
+
+    @param name The name is written to this string.
+    @param line Line from a PDB file.
+    @return ::FREESASA_SUCCESS if input is readable, else ::FREESASA_FAIL.
+ */
+int freesasa_pdb_get_res_name(char *name,
+                              const char *line);
+
+/**
+    Get atom coordinates from a PDB line.
+
+    Extracts x-, y- and z-coordinates from an `ATOM` or `HETATM` PDB
+    line. If the line is invalid, the function returns ::FREESASA_FAIL
+    and coord will remain unchanged.
+
+    @param coord The coordiantes are written to this array as x,y,z.
+    @param line Line from a PDB file.
+    @return ::FREESASA_SUCCESS if input is readable, else ::FREESASA_FAIL.
+ */
+int freesasa_pdb_get_coord(double *coord,
+                           const char *line);
+
+/**
+    Get residue number from a PDB line.
+
+    Extracts residue number (ResSeq) as a string from an `ATOM` or
+    `HETATM` PDB line as a string. String format is used because not
+    all residue-numbers are numbers. The string should have length
+    ::PDB_ATOM_RES_NUMBER_STRL. If the line is invalid, the number will be an
+    empty string and the function returns ::FREESASA_FAIL.
+
+    @param number The residue number will be saved to this string.
+    @param line Line from a PDB file.
+    @return ::FREESASA_SUCCESS if input is readable, else ::FREESASA_FAIL.
+ */
+int freesasa_pdb_get_res_number(char *number,
+                                const char *line);
+
+/**
+    Get chain label from PDB line.
+
+    Extracts the one character chain label (Chain identifier) from an
+    `ATOM` or `HETATM` PDB line (i.e. `'A'`, `'B'`, `'C'`, ...)
+
+    @param line Line from a PDB file.
+    @return The chain label. If the line is invalid, the function
+    returns '\0'.
+ */
+char freesasa_pdb_get_chain_label(const char *line);
+
+/**
+    Get alternate coordinate label from PDB line.
+
+    If there is more than one set of coordinates for an atom there
+    will be a label 'A', 'B', etc (Alternate location indicator). Else
+    the label is ' '.
+
+    @param line Line from a PDB file.
+    @return The label. If line is invalid, the function returns
+      '\0'.
+ */
+char freesasa_pdb_get_alt_coord_label(const char *line);
+
+/**
+    Get element symbol from PDB line.
+
+    Writes padded string to argument symbol, i.e. " C", "SE", etc.
+
+    @param symbol The symbol will be written to this string.
+    @param line Line from a PDB file.
+    @return ::FREESASA_SUCCESS line has 78 or more characters. ::FREESASA_FAIL if
+      line too short. Does not check if symbol is valid.
+ */
+int freesasa_pdb_get_symbol(char *symbol,
+                            const char *line);
+
+/**
+    Get occupancy from PDB line
+
+    @param occ The occupancy will be written to this location.
+    @param line Line from a PDB file
+
+    @return ::FREESASA_SUCCESS if line is long enough, starts with
+      ATOM or HETATM, and characters 55-60 contain a number.
+ */
+int freesasa_pdb_get_occupancy(double *occ,
+                               const char *line);
+/**
+    Get temperature factor (B-factor) from PDB line
+
+    @param bfac The B-factor will be written to this location.
+    @param line Line from a PDB file
+    @return ::FREESASA_SUCCESS if line is long enough, starts with
+      ATOM or HETATM, and characters 61-66 contain a number.
+ */
+int freesasa_pdb_get_bfactor(double *bfac,
+                             const char *line);
+
+/**
+    Is atom Hydrogen?
+
+    Checks if an atom from an `ATOM` or `HETATM` PDB line is Hydrogen.
+
+    @param line Line from a PDB file.
+    @return 1 if Hydrogen (or deuterium). 0 otherwise. If line is
+      invalid, the function returns ::FREESASA_FAIL.
+ */
+int freesasa_pdb_ishydrogen(const char *line);
+
+#endif /* FREESASA_PDB_H */

.venv_haddock/include/site/python3.12/freesasa/rsa.c

@@ -0,0 +1,174 @@
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <math.h>
+#include <stdlib.h>
+
+#include "classifier.h"
+#include "freesasa_internal.h"
+#include "pdb.h"
+
+void freesasa_residue_rel_nodearea(freesasa_nodearea *rel,
+                                   const freesasa_nodearea *abs,
+                                   const freesasa_nodearea *ref)
+{
+    rel->total = 100. * abs->total / ref->total;
+    rel->side_chain = 100. * abs->side_chain / ref->side_chain;
+    rel->main_chain = 100. * abs->main_chain / ref->main_chain;
+    rel->polar = 100. * abs->polar / ref->polar;
+    rel->apolar = 100. * abs->apolar / ref->apolar;
+    rel->name = abs->name;
+}
+
+static void
+rsa_print_header(FILE *output,
+                 const char *config_name,
+                 const char *protein_name,
+                 const char *chains,
+                 const freesasa_parameters *parameters,
+                 int options)
+{
+    freesasa_algorithm alg = parameters->alg;
+#ifdef PACKAGE_VERSION
+    fprintf(output, "REM  FreeSASA " PACKAGE_VERSION "\n");
+#else
+    fprintf(output, "REM  FreeSASA\n");
+#endif
+    fprintf(output, "REM  Absolute and relative SASAs for %s\n", protein_name);
+    if (!(options & FREESASA_OUTPUT_SKIP_REL))
+        fprintf(output, "REM  Atomic radii and reference values for relative SASA: %s\n", config_name);
+    else
+        fprintf(output, "REM  No reference values available to calculate relative SASA\n");
+    fprintf(output, "REM  Chains: %s\n", chains);
+    fprintf(output, "REM  Algorithm: %s\n", freesasa_alg_name(alg));
+    fprintf(output, "REM  Probe-radius: %.2f\n", parameters->probe_radius);
+    if (alg == FREESASA_LEE_RICHARDS) {
+        fprintf(output, "REM  Slices: %d\n", parameters->lee_richards_n_slices);
+    } else if (alg == FREESASA_SHRAKE_RUPLEY) {
+        fprintf(output, "REM  Test-points: %d\n", parameters->shrake_rupley_n_points);
+    }
+    fprintf(output, "REM RES _ NUM      All-atoms   Total-Side   Main-Chain    Non-polar    All polar\n");
+    fprintf(output, "REM                ABS   REL    ABS   REL    ABS   REL    ABS   REL    ABS   REL\n");
+}
+
+static inline void
+rsa_print_abs_rel(FILE *output,
+                  double abs,
+                  double rel)
+{
+    fprintf(output, "%7.2f", abs);
+    if (isfinite(rel))
+        fprintf(output, "%6.1f", rel);
+    else
+        fprintf(output, "   N/A");
+}
+
+static inline void
+rsa_print_abs_only(FILE *output,
+                   double abs)
+{
+    fprintf(output, "%7.2f", abs);
+    fprintf(output, "   N/A");
+}
+
+static int
+rsa_print_residue(FILE *output,
+                  int iaa,
+                  const freesasa_nodearea *abs,
+                  const freesasa_nodearea *rel,
+                  freesasa_node *residue)
+{
+    const char *resi_str;
+    char chain;
+
+    resi_str = freesasa_node_residue_number(residue);
+    chain = freesasa_node_name(freesasa_node_parent(residue))[0];
+
+    fprintf(output, "RES %s %c%s ", abs->name, chain, resi_str);
+    if (rel->name != NULL) {
+        rsa_print_abs_rel(output, abs->total, rel->total);
+        rsa_print_abs_rel(output, abs->side_chain, rel->side_chain);
+        rsa_print_abs_rel(output, abs->main_chain, rel->main_chain);
+        rsa_print_abs_rel(output, abs->apolar, rel->apolar);
+        rsa_print_abs_rel(output, abs->polar, rel->polar);
+    } else {
+        rsa_print_abs_only(output, abs->total);
+        rsa_print_abs_only(output, abs->side_chain);
+        rsa_print_abs_only(output, abs->main_chain);
+        rsa_print_abs_only(output, abs->apolar);
+        rsa_print_abs_only(output, abs->polar);
+    }
+    fprintf(output, "\n");
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_write_rsa(FILE *output,
+                       freesasa_node *tree,
+                       int options)
+{
+    freesasa_node *residue, *chain, *structure_node, *result_node;
+    const freesasa_nodearea *abs, *reference;
+    freesasa_nodearea rel;
+    int res_index, chain_index;
+    const freesasa_parameters *parameters;
+
+    assert(output);
+    assert(tree);
+
+    result_node = freesasa_node_children(tree);
+    parameters = freesasa_node_result_parameters(result_node);
+    structure_node = freesasa_node_children(result_node);
+    chain = freesasa_node_children(structure_node);
+
+    rsa_print_header(output, freesasa_node_classified_by(result_node),
+                     freesasa_node_name(result_node), freesasa_node_name(structure_node), parameters, options);
+
+    res_index = chain_index = 0;
+    while (chain) {
+        residue = freesasa_node_children(chain);
+        while (residue) {
+            abs = freesasa_node_area(residue);
+            reference = freesasa_node_residue_reference(residue);
+            if (reference && !(options & FREESASA_OUTPUT_SKIP_REL)) {
+                freesasa_residue_rel_nodearea(&rel, abs, reference);
+            } else {
+                rel = freesasa_nodearea_null;
+            }
+            rsa_print_residue(output, res_index, abs, &rel, residue);
+            ++res_index;
+            residue = freesasa_node_next(residue);
+        }
+        chain = freesasa_node_next(chain);
+    }
+
+    fprintf(output, "END  Absolute sums over single chains surface\n");
+
+    chain = freesasa_node_children(structure_node);
+    chain_index = 0;
+    while (chain) {
+        const char *name = freesasa_node_name(chain);
+        abs = freesasa_node_area(chain);
+
+        fprintf(output, "CHAIN%3d %c %10.1f   %10.1f   %10.1f   %10.1f   %10.1f\n",
+                chain_index + 1, name[0], abs->total, abs->side_chain,
+                abs->main_chain, abs->apolar, abs->polar);
+
+        ++chain_index;
+        chain = freesasa_node_next(chain);
+    }
+
+    abs = freesasa_node_area(structure_node);
+    fprintf(output, "END  Absolute sums over all chains\n");
+    fprintf(output, "TOTAL      %10.1f   %10.1f   %10.1f   %10.1f   %10.1f\n",
+            abs->total, abs->side_chain, abs->main_chain, abs->apolar, abs->polar);
+
+    fflush(output);
+    if (ferror(output)) {
+        return fail_msg(strerror(errno));
+    }
+
+    return FREESASA_SUCCESS;
+}

.venv_haddock/include/site/python3.12/freesasa/sasa_lr.c

@@ -0,0 +1,487 @@
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+#define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+
+#if USE_THREADS
+#include <pthread.h>
+#define MAX_LR_THREADS 16
+#else
+#define MAX_LR_THREADS 1
+#endif
+
+#include "freesasa_internal.h"
+#include "nb.h"
+
+const double TWOPI = 2 * M_PI;
+
+/* calculation parameters and data (results stored in *sasa) */
+typedef struct {
+    int n_atoms;
+    double *radii; /* including probe */
+    const coord_t *xyz;
+    nb_list *adj;
+    int n_slices_per_atom;
+    double *sasa; /* results */
+    double *arc[MAX_LR_THREADS], *z_nb[MAX_LR_THREADS], *R_nb[MAX_LR_THREADS];
+    int n_threads;
+} lr_data;
+
+typedef struct {
+    int first_atom;
+    int last_atom;
+    int thread_id;
+    lr_data *lr;
+} lr_thread_interval;
+
+#if USE_THREADS
+static int lr_do_threads(int n_threads, lr_data *);
+static void *lr_thread(void *arg);
+#endif
+
+/** Returns the are of atom i */
+static double
+atom_area(lr_data *lr, int i, int thread_id);
+
+/** Sum of exposed arcs based on buried arc intervals arc, assumes no
+    intervals cross zero */
+static double
+exposed_arc_length(double *restrict arc, int n);
+
+/** Release contenst of lr_data pointer*/
+static void
+release_lr(lr_data *lr)
+{
+    int i;
+
+    free(lr->radii);
+    freesasa_nb_free(lr->adj);
+    lr->radii = NULL;
+    lr->adj = NULL;
+
+    for (i = 0; i < lr->n_threads; ++i) {
+        free(lr->arc[i]);
+        free(lr->z_nb[i]);
+        free(lr->R_nb[i]);
+    }
+}
+
+/* Allocate some helper arrays in area calculation that need to be pre-allocated */
+static int
+alloc_lr_calc_arrays(lr_data *lr, int n_threads)
+{
+    int max_nni = 0, i, nni;
+    const int n_atoms = lr->n_atoms;
+
+    for (i = 0; i < n_atoms; ++i) {
+        nni = lr->adj->nn[i];
+        max_nni = max_nni < nni ? nni : max_nni;
+    }
+
+    for (i = 0; i < n_threads; ++i) {
+        lr->arc[i] = malloc(sizeof(double) * 4 * max_nni);
+        lr->z_nb[i] = malloc(sizeof(double) * max_nni);
+        lr->R_nb[i] = malloc(sizeof(double) * max_nni);
+
+        if (!lr->arc[i] || !lr->z_nb[i] || !lr->R_nb[i]) {
+            return mem_fail();
+        }
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+/** Initialize object to be used for L&R calculation */
+static int
+init_lr(lr_data *lr,
+        double *sasa,
+        const coord_t *xyz,
+        const double *atom_radii,
+        double probe_radius,
+        int n_slices_per_atom,
+        int n_threads)
+{
+    const int n_atoms = freesasa_coord_n(xyz);
+    int i;
+
+    lr->n_atoms = n_atoms;
+    lr->xyz = xyz;
+    lr->adj = NULL;
+    lr->n_slices_per_atom = n_slices_per_atom;
+    lr->sasa = sasa;
+    lr->n_threads = n_threads;
+
+    for (i = 0; i < n_threads; ++i) {
+        lr->arc[i] = NULL;
+        lr->z_nb[i] = NULL;
+        lr->R_nb[i] = NULL;
+    }
+
+    lr->radii = malloc(sizeof(double) * n_atoms);
+    if (lr->radii == NULL) {
+        return mem_fail();
+    }
+
+    /* init some arrays */
+    for (i = 0; i < n_atoms; ++i) {
+        lr->radii[i] = atom_radii[i] + probe_radius;
+        sasa[i] = 0.;
+    }
+
+    /* determine which atoms are neighbours */
+    lr->adj = freesasa_nb_new(xyz, lr->radii);
+
+    if (lr->adj == NULL) {
+        release_lr(lr);
+        return fail_msg("");
+    }
+
+    if (alloc_lr_calc_arrays(lr, n_threads)) {
+        release_lr(lr);
+        return fail_msg("");
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_lee_richards(double *sasa,
+                          const coord_t *xyz,
+                          const double *atom_radii,
+                          const freesasa_parameters *param)
+{
+    int return_value, n_atoms, n_threads, resolution, i;
+    double probe_radius;
+    lr_data lr;
+
+    assert(sasa);
+    assert(xyz);
+    assert(atom_radii);
+
+    if (param == NULL) param = &freesasa_default_parameters;
+
+    return_value = FREESASA_SUCCESS;
+    n_atoms = freesasa_coord_n(xyz);
+    n_threads = param->n_threads;
+    resolution = param->lee_richards_n_slices;
+    probe_radius = param->probe_radius;
+
+    if (n_threads > MAX_LR_THREADS) {
+        return fail_msg("L&R does not support more than %d threads", MAX_LR_THREADS);
+    }
+
+    if (resolution <= 0) {
+        return fail_msg("%f slices per atom invalid resolution in L&R, must be > 0\n", resolution);
+    }
+
+    if (n_atoms == 0) {
+        return freesasa_warn("in %s(): empty coordinates", __func__);
+    }
+
+    if (n_threads > n_atoms) {
+        n_threads = n_atoms;
+        freesasa_warn("no sense in having more threads than atoms, only using %d threads",
+                      n_threads);
+    }
+
+    if (init_lr(&lr, sasa, xyz, atom_radii, probe_radius, resolution, n_threads))
+        return FREESASA_FAIL;
+
+    if (n_threads > 1) {
+#if USE_THREADS
+        return_value = lr_do_threads(n_threads, &lr);
+#else
+        return_value = freesasa_warn("in %s(): program compiled for single-threaded use, "
+                                     "but multiple threads were requested, will "
+                                     "proceed in single-threaded mode\n",
+                                     __func__);
+        n_threads = 1;
+#endif /* pthread */
+    }
+    if (n_threads == 1) {
+        for (i = 0; i < lr.n_atoms; ++i) {
+            lr.sasa[i] = atom_area(&lr, i, 0);
+        }
+    }
+    release_lr(&lr);
+    return return_value;
+}
+
+#if USE_THREADS
+static int
+lr_do_threads(int n_threads,
+              lr_data *lr)
+{
+    pthread_t thread[MAX_LR_THREADS];
+    lr_thread_interval t_data[MAX_LR_THREADS];
+    int n_perthread = lr->n_atoms / n_threads, res;
+    int threads_created = 0, return_value = FREESASA_SUCCESS;
+    int t;
+
+    for (t = 0; t < n_threads; ++t) {
+        t_data[t].first_atom = t * n_perthread;
+        if (t == n_threads - 1) {
+            t_data[t].last_atom = lr->n_atoms - 1;
+        } else {
+            t_data[t].last_atom = (t + 1) * n_perthread - 1;
+        }
+        t_data[t].lr = lr;
+        t_data[t].thread_id = t;
+        res = pthread_create(&thread[t], NULL, lr_thread,
+                             (void *)&t_data[t]);
+        if (res) {
+            return_value = fail_msg(freesasa_thread_error(res));
+            break;
+        }
+        ++threads_created;
+    }
+    for (int t = 0; t < threads_created; ++t) {
+        res = pthread_join(thread[t], NULL);
+        if (res) {
+            return_value = fail_msg(freesasa_thread_error(res));
+        }
+    }
+    return return_value;
+}
+
+static void *
+lr_thread(void *arg)
+{
+    int i;
+    lr_thread_interval *ti = ((lr_thread_interval *)arg);
+
+    for (i = ti->first_atom; i <= ti->last_atom; ++i) {
+        /* the different threads write to different parts of the
+           array, so locking shouldn't be necessary */
+        ti->lr->sasa[i] = atom_area(ti->lr, i, ti->thread_id);
+    }
+    pthread_exit(NULL);
+}
+#endif /* USE_THREADS */
+
+static double
+atom_area(lr_data *lr,
+          int i,
+          int thread_id)
+{
+    /* This function is large because a large number of pre-calculated
+       arrays need to be accessed efficiently. Partially dereferenced
+       here to make access more efficient.
+
+       Variables are named according to the documentation (see page
+       "Geometry of Lee & Richards' algorithm") */
+
+    const int nni = lr->adj->nn[i];
+    const double *restrict const v = freesasa_coord_all(lr->xyz);
+    const double *restrict const R = lr->radii;
+    const int *restrict const nbi = lr->adj->nb[i];
+    const double *restrict const xydi = lr->adj->xyd[i];
+    const double *restrict const xdi = lr->adj->xd[i];
+    const double *restrict const ydi = lr->adj->yd[i];
+    const double zi = v[3 * i + 2], Ri = R[i];
+    const int ns = lr->n_slices_per_atom;
+
+    int j, islice, n_arcs, is_buried, narc2;
+    double *arc = lr->arc[thread_id],
+           *z_nb = lr->z_nb[thread_id],
+           *R_nb = lr->R_nb[thread_id];
+    double z, delta, sasa = 0, alpha, beta, inf, sup;
+    double zj, di, dj, dij, Rj, Ri_prime2, Ri_prime, Rj_prime2, Rj_prime;
+
+    for (j = 0; j < nni; ++j) {
+        z_nb[j] = v[3 * nbi[j] + 2];
+        R_nb[j] = R[nbi[j]];
+    }
+
+    delta = 2 * Ri / ns;
+    z = zi - Ri - 0.5 * delta;
+    for (islice = 0; islice < ns; ++islice) {
+        z += delta;
+        di = fabs(zi - z);
+        Ri_prime2 = Ri * Ri - di * di;
+        if (Ri_prime2 < 0) continue; /* handle round-off errors */
+        Ri_prime = sqrt(Ri_prime2);
+        if (Ri_prime <= 0) continue; /* more round-off errors */
+        n_arcs = 0;
+        is_buried = 0;
+        for (j = 0; j < nni; ++j) {
+            zj = z_nb[j];
+            dj = fabs(zj - z);
+            Rj = R_nb[j];
+
+            if (dj < Rj) {
+                Rj_prime2 = Rj * Rj - dj * dj;
+                Rj_prime = sqrt(Rj_prime2);
+                dij = xydi[j];
+                if (dij >= Ri_prime + Rj_prime) { /* atoms aren't in contact */
+                    continue;
+                }
+                if (dij + Ri_prime < Rj_prime) { /* circle i is completely inside j */
+                    is_buried = 1;
+                    break;
+                }
+                if (dij + Rj_prime < Ri_prime) { /* circle j is completely inside i */
+                    continue;
+                }
+                /* arc of circle i intersected by circle j */
+                alpha = acos((Ri_prime2 + dij * dij - Rj_prime2) / (2.0 * Ri_prime * dij));
+                /* position of mid-point of intersection along circle i */
+                beta = atan2(ydi[j], xdi[j]) + M_PI;
+                inf = beta - alpha;
+                sup = beta + alpha;
+                if (inf < 0) inf += TWOPI;
+                if (sup > 2 * M_PI) sup -= TWOPI;
+                narc2 = 2 * n_arcs;
+                /* store the arc, if arc passes 2*PI split into two */
+                if (sup < inf) {
+                    /* store arcs as contiguous pairs of angles */
+                    arc[narc2] = 0;
+                    arc[narc2 + 1] = sup;
+                    /* second arc */
+                    arc[narc2 + 2] = inf;
+                    arc[narc2 + 3] = TWOPI;
+                    n_arcs += 2;
+                } else {
+                    arc[narc2] = inf;
+                    arc[narc2 + 1] = sup;
+                    ++n_arcs;
+                }
+            }
+        }
+        if (is_buried == 0) {
+            sasa += delta * Ri * exposed_arc_length(arc, n_arcs);
+        }
+    }
+    return sasa;
+}
+
+/* insertion sort (faster than qsort for these short lists) */
+inline static void
+sort_arcs(double *restrict arc,
+          int n)
+{
+    double tmp[2];
+    double *end = arc + 2 * n, *arcj, *arci;
+    for (arci = arc + 2; arci < end; arci += 2) {
+        *tmp = *arci;
+        *(tmp + 1) = *(arci + 1);
+        arcj = arci;
+        while (arcj > arc && *(arcj - 2) > tmp[0]) {
+            *arcj = *(arcj - 2);
+            *(arcj + 1) = *(arcj - 1);
+            arcj -= 2;
+        }
+        *arcj = *tmp;
+        *(arcj + 1) = *(tmp + 1);
+    }
+}
+
+/* sort arcs by start-point, loop through them to sum parts of circle
+   not covered by any of the arcs */
+inline static double
+exposed_arc_length(double *restrict arc,
+                   int n)
+{
+    int i2;
+    double sum, sup, tmp;
+
+    if (n == 0) return TWOPI;
+
+    sort_arcs(arc, n);
+    sum = arc[0];
+    sup = arc[1];
+    /* in the following it is assumed that the arc[i2] <= arc[i2+1] */
+    for (i2 = 2; i2 < 2 * n; i2 += 2) {
+        if (sup < arc[i2]) sum += arc[i2] - sup;
+        tmp = arc[i2 + 1];
+        if (tmp > sup) sup = tmp;
+    }
+    return sum + TWOPI - sup;
+}
+
+#if USE_CHECK
+#include <check.h>
+
+static int
+is_identical(const double *l1, const double *l2, int n)
+{
+    int i;
+
+    for (i = 0; i < n; ++i) {
+        if (l1[i] != l2[i]) return 0;
+    }
+
+    return 1;
+}
+
+static int
+is_sorted(const double *list, int n)
+{
+    int i;
+
+    for (i = 0; i < n - 1; ++i)
+        if (list[2 * i] > list[2 * i + 1]) return 0;
+
+    return 1;
+}
+
+START_TEST(test_sort_arcs)
+{
+    double a_ref[] = {0, 1, 2, 3}, b_ref[] = {-2, 0, -1, 0, -1, 1};
+    double a1[4] = {0, 1, 2, 3}, a2[4] = {2, 3, 0, 1};
+    double b1[6] = {-2, 0, -1, 0, -1, 1}, b2[6] = {-1, 1, -2, 0, -1, 1};
+    sort_arcs(a1, 2);
+    sort_arcs(a2, 2);
+    sort_arcs(b1, 3);
+    sort_arcs(b2, 3);
+    ck_assert(is_sorted(a1, 2));
+    ck_assert(is_sorted(a2, 2));
+    ck_assert(is_sorted(b1, 3));
+    ck_assert(is_sorted(b2, 3));
+    ck_assert(is_identical(a_ref, a1, 4));
+    ck_assert(is_identical(a_ref, a2, 4));
+    ck_assert(is_identical(b_ref, b1, 6));
+}
+END_TEST
+
+START_TEST(test_exposed_arc_length)
+{
+    double a1[4] = {0, 0.1 * TWOPI, 0.9 * TWOPI, TWOPI}, a2[4] = {0.9 * TWOPI, TWOPI, 0, 0.1 * TWOPI};
+    double a3[4] = {0, TWOPI, 1, 2}, a4[4] = {1, 2, 0, TWOPI};
+    double a5[4] = {0.1 * TWOPI, 0.2 * TWOPI, 0.5 * TWOPI, 0.6 * TWOPI};
+    double a6[4] = {0.1 * TWOPI, 0.2 * TWOPI, 0.5 * TWOPI, 0.6 * TWOPI};
+    double a7[4] = {0.1 * TWOPI, 0.3 * TWOPI, 0.15 * TWOPI, 0.2 * TWOPI};
+    double a8[4] = {0.15 * TWOPI, 0.2 * TWOPI, 0.1 * TWOPI, 0.3 * TWOPI};
+    double a9[10] = {0.05, 0.1, 0.5, 0.6, 0, 0.15, 0.7, 0.8, 0.75, TWOPI};
+    ck_assert(fabs(exposed_arc_length(a1, 2) - 0.8 * TWOPI) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a2, 2) - 0.8 * TWOPI) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a3, 2)) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a4, 2)) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a5, 2) - 0.8 * TWOPI) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a6, 2) - 0.8 * TWOPI) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a7, 2) - 0.8 * TWOPI) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a8, 2) - 0.8 * TWOPI) < 1e-10);
+    ck_assert(fabs(exposed_arc_length(a9, 5) - 0.45) < 1e-10);
+    /* can't think of anything more qualitatively different here */
+}
+END_TEST
+
+TCase *
+test_LR_static()
+{
+    TCase *tc = tcase_create("sasa_lr.c static");
+    tcase_add_test(tc, test_sort_arcs);
+    tcase_add_test(tc, test_exposed_arc_length);
+
+    return tc;
+}
+
+#endif /* USE_CHECK */

.venv_haddock/include/site/python3.12/freesasa/sasa_sr.c

@@ -0,0 +1,338 @@
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+#define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+
+#if USE_THREADS
+#include <pthread.h>
+#define MAX_SR_THREADS 16
+#else
+#define MAX_SR_THREADS 1
+#endif
+
+#include "freesasa_internal.h"
+#include "nb.h"
+
+#ifdef __GNUC__
+#define __attrib_pure__ __attribute__((pure))
+#else
+#define __attrib_pure__
+#endif
+
+/* calculation parameters (results stored in *sasa) */
+typedef struct {
+    int i1, i2; /* for multithreading, range of atoms */
+    int thread_index;
+    int n_atoms;
+    int n_points;
+    int n_threads;
+    double probe_radius;
+    const coord_t *xyz;
+    coord_t *srp;                      /* test-points */
+    coord_t *tp_local[MAX_SR_THREADS]; /* coord object for storing intermediates */
+    int *spcount[MAX_SR_THREADS];
+    double *r;
+    double *r2;
+    nb_list *nb;
+    double *sasa;
+} sr_data;
+
+#if USE_THREADS
+static int sr_do_threads(int n_threads, sr_data *sr);
+static void *sr_thread(void *arg);
+#endif
+
+static double
+sr_atom_area(int i, const sr_data *sr, int thread_index) __attrib_pure__;
+
+static coord_t *
+test_points(int N)
+{
+    /* Golden section spiral on a sphere
+       from http://web.archive.org/web/20120421191837/http://www.cgafaq.info/wiki/Evenly_distributed_points_on_sphere */
+    double dlong = M_PI * (3 - sqrt(5)), dz = 2.0 / N, longitude = 0, z = 1 - dz / 2, r;
+    coord_t *coord = freesasa_coord_new();
+    double *tp = malloc(3 * N * sizeof(double)), *p;
+    if (tp == NULL || coord == NULL) {
+        mem_fail();
+        goto cleanup;
+    }
+
+    for (p = tp; p - tp < 3 * N; p += 3) {
+        r = sqrt(1 - z * z);
+        p[0] = cos(longitude) * r;
+        p[1] = sin(longitude) * r;
+        p[2] = z;
+        z -= dz;
+        longitude += dlong;
+    }
+
+    if (freesasa_coord_append(coord, tp, N) == FREESASA_FAIL) {
+        fail_msg("");
+        goto cleanup;
+    }
+    free(tp);
+
+    return coord;
+
+cleanup:
+    free(tp);
+    freesasa_coord_free(coord);
+    return NULL;
+}
+
+/* free contents */
+void release_sr(sr_data *sr)
+{
+    int i;
+
+    freesasa_coord_free(sr->srp);
+    freesasa_nb_free(sr->nb);
+    free(sr->r);
+    free(sr->r2);
+
+    for (i = 0; i < sr->n_threads; ++i) {
+        freesasa_coord_free(sr->tp_local[i]);
+        free(sr->spcount[i]);
+    }
+}
+
+int init_sr(sr_data *sr,
+            double *sasa,
+            const coord_t *xyz,
+            const double *r,
+            double probe_radius,
+            int n_points,
+            int n_threads)
+{
+    int n_atoms = freesasa_coord_n(xyz), i;
+    coord_t *srp = test_points(n_points);
+    double ri;
+
+    if (srp == NULL) return fail_msg("failed to initialize test points");
+
+    /* store parameters and reference arrays */
+    sr->n_atoms = n_atoms;
+    sr->n_points = n_points;
+    sr->n_threads = n_threads;
+    sr->probe_radius = probe_radius;
+    sr->xyz = xyz;
+    sr->srp = srp;
+    sr->sasa = sasa;
+    sr->nb = NULL;
+
+    /* should be done before any mallocs (to avoid problems in potential cleanup) */
+    for (i = 0; i < n_threads; ++i) {
+        sr->tp_local[i] = NULL;
+        sr->spcount[i] = NULL;
+    }
+
+    sr->r = malloc(sizeof(double) * n_atoms);
+    sr->r2 = malloc(sizeof(double) * n_atoms);
+
+    if (sr->r == NULL || sr->r2 == NULL) goto cleanup;
+
+    for (i = 0; i < n_atoms; ++i) {
+        ri = r[i] + probe_radius;
+        sr->r[i] = ri;
+        sr->r2[i] = ri * ri;
+    }
+
+    for (i = 0; i < n_threads; ++i) {
+        sr->tp_local[i] = freesasa_coord_clone(sr->srp);
+        sr->spcount[i] = malloc(sizeof(int) * n_points);
+        if (sr->tp_local[i] == NULL || sr->spcount[i] == NULL) {
+            goto cleanup;
+        }
+    }
+
+    /* calculate distances */
+    sr->nb = freesasa_nb_new(xyz, sr->r);
+    if (sr->nb == NULL) goto cleanup;
+
+    return FREESASA_SUCCESS;
+
+cleanup:
+    release_sr(sr);
+    return mem_fail();
+}
+
+int freesasa_shrake_rupley(double *sasa,
+                           const coord_t *xyz,
+                           const double *r,
+                           const freesasa_parameters *param)
+{
+    int i, n_atoms, n_threads = param->n_threads, resolution, return_value;
+    double probe_radius = param->probe_radius;
+    sr_data sr;
+
+    assert(sasa);
+    assert(xyz);
+    assert(r);
+
+    if (param == NULL) param = &freesasa_default_parameters;
+
+    n_atoms = freesasa_coord_n(xyz);
+    n_threads = param->n_threads;
+    resolution = param->shrake_rupley_n_points;
+    return_value = FREESASA_SUCCESS;
+
+    if (n_threads > MAX_SR_THREADS) {
+        return fail_msg("S&R does not support more than %d threads", MAX_SR_THREADS);
+    }
+    if (resolution <= 0) {
+        return fail_msg("%f test points invalid resolution in S&R, must be > 0\n", resolution);
+    }
+    if (n_atoms == 0) return freesasa_warn("in %s(): empty coordinates", __func__);
+    if (n_threads > n_atoms) {
+        n_threads = n_atoms;
+        freesasa_warn("no sense in having more threads than atoms, only using %d threads",
+                      n_threads);
+    }
+
+    if (init_sr(&sr, sasa, xyz, r, probe_radius, resolution, n_threads))
+        return FREESASA_FAIL;
+
+    /* calculate SASA */
+    if (n_threads > 1) {
+#if USE_THREADS
+        return_value = sr_do_threads(n_threads, &sr);
+#else
+        return_value = freesasa_warn("in %s(): program compiled for single-threaded use, "
+                                     "but multiple threads were requested, will "
+                                     "proceed in single-threaded mode\n",
+                                     __func__);
+        n_threads = 1;
+#endif
+    }
+    if (n_threads == 1) {
+        /* don't want the overhead of generating threads if only one is used */
+        for (i = 0; i < n_atoms; ++i) {
+            sasa[i] = sr_atom_area(i, &sr, 0);
+        }
+    }
+    release_sr(&sr);
+    return return_value;
+}
+
+#if USE_THREADS
+static int
+sr_do_threads(int n_threads,
+              sr_data *sr)
+{
+    pthread_t thread[MAX_SR_THREADS];
+    sr_data srt[MAX_SR_THREADS];
+    int thread_block_size = sr->n_atoms / n_threads;
+    int res, return_value = FREESASA_SUCCESS;
+    int threads_created = 0, t;
+
+    /*  divide atoms evenly over threads */
+    for (t = 0; t < n_threads; ++t) {
+        srt[t] = *sr;
+        srt[t].i1 = t * thread_block_size;
+        if (t == n_threads - 1)
+            srt[t].i2 = sr->n_atoms;
+        else
+            srt[t].i2 = (t + 1) * thread_block_size;
+        srt[t].thread_index = t;
+        res = pthread_create(&thread[t], NULL, sr_thread, (void *)&srt[t]);
+        if (res) {
+            return_value = fail_msg(freesasa_thread_error(res));
+            break;
+        }
+        ++threads_created;
+    }
+    for (t = 0; t < threads_created; ++t) {
+        res = pthread_join(thread[t], NULL);
+        if (res) {
+            return_value = fail_msg(freesasa_thread_error(res));
+        }
+    }
+    return return_value;
+}
+
+static void *
+sr_thread(void *arg)
+{
+    int i;
+    sr_data *sr = ((sr_data *)arg);
+
+    for (i = sr->i1; i < sr->i2; ++i) {
+        /* mutex should not be necessary, writes to non-overlapping regions */
+        sr->sasa[i] = sr_atom_area(i, sr, sr->thread_index);
+    }
+    pthread_exit(NULL);
+}
+#endif
+
+static double
+sr_atom_area(int i,
+             const sr_data *sr,
+             int thread_index)
+{
+    const int n_points = sr->n_points;
+    /* this array keeps track of which testpoints belonging to
+       a certain atom do not overlap with any other atoms */
+    int *spcount = sr->spcount[thread_index];
+    const int nni = sr->nb->nn[i];
+    const int *restrict nbi = sr->nb->nb[i];
+    const double ri = sr->r[i];
+    const double *restrict r2 = sr->r2;
+    const double *restrict v = freesasa_coord_all(sr->xyz);
+    const double *restrict vi = v + 3 * i;
+    const double *restrict tp;
+    int n_surface = 0, current_nb, a, j, k;
+    double dx, dy, dz;
+    /* testpoints for this atom */
+    coord_t *restrict tp_coord_ri = sr->tp_local[thread_index];
+
+    freesasa_coord_copy(tp_coord_ri, sr->srp);
+    freesasa_coord_scale(tp_coord_ri, ri);
+    freesasa_coord_translate(tp_coord_ri, vi);
+    tp = freesasa_coord_all(tp_coord_ri);
+
+    /* initialize with all surface points hidden */
+    memset(spcount, 0, n_points * sizeof(int));
+
+    /* Using the trick from NSOL to check points one by one for all
+       atoms, start comparing with the first neighbor. If there is no
+       overlap for a given test-point, try with other neighbors
+       instead. Would probably work even better if test points were
+       organized in patches and not spirals. */
+    current_nb = 0;
+    for (j = 0; j < n_points; ++j) {
+        /* a is the index of the atom under consideration */
+        a = nbi[current_nb];
+        dx = tp[j * 3] - v[a * 3];
+        dy = tp[j * 3 + 1] - v[a * 3 + 1];
+        dz = tp[j * 3 + 2] - v[a * 3 + 2];
+        if (dx * dx + dy * dy + dz * dz > r2[a]) {
+            k = 0;
+            for (; k < nni; ++k) {
+                a = nbi[k];
+                dx = tp[j * 3] - v[a * 3];
+                dy = tp[j * 3 + 1] - v[a * 3 + 1];
+                dz = tp[j * 3 + 2] - v[a * 3 + 2];
+                if (dx * dx + dy * dy + dz * dz <= r2[a]) {
+                    current_nb = k;
+                    break;
+                }
+            }
+            /* we have gone through the whole list without overlap */
+            if (k == nni) spcount[j] = 1;
+        }
+    }
+    for (k = 0; k < n_points; ++k) {
+        if (spcount[k]) ++n_surface;
+    }
+
+    return (4.0 * M_PI * ri * ri * n_surface) / n_points;
+}

.venv_haddock/include/site/python3.12/freesasa/selection.c

@@ -0,0 +1,1003 @@
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+#include "freesasa_internal.h"
+#include "pdb.h"
+#include "selection.h"
+
+#include "parser.h"
+
+#include "lexer.h"
+
+struct freesasa_selection {
+    char *name;
+    char *command;
+    double area;
+    int n_atoms;
+};
+
+struct selection {
+    const char *name;
+    int *atom;
+    int size;
+};
+
+static const char *
+e_str(expression_type e)
+{
+    switch (e) {
+    case E_SELECTION:
+        return "<selection>";
+    case E_SYMBOL:
+        return "symbol";
+    case E_NAME:
+        return "name";
+    case E_RESN:
+        return "resn";
+    case E_RESI:
+        return "resi";
+    case E_CHAIN:
+        return "chain";
+    case E_ID:
+        return "<id>";
+    case E_NUMBER:
+        return "<number>";
+    case E_NEGNUM:
+        return "<neg_number>";
+    case E_AND:
+        return "and";
+    case E_OR:
+        return "or";
+    case E_NOT:
+        return "not";
+    case E_PLUS:
+        return "< + >";
+    case E_RANGE:
+        return "< - >";
+    case E_RANGE_OPEN_R:
+        return "< - R >";
+    case E_RANGE_OPEN_L:
+        return "< - L >";
+    }
+    return NULL;
+}
+
+extern int freesasa_yyparse(expression **expression, yyscan_t scanner);
+
+static expression *
+expression_new()
+{
+    struct expression *e = malloc(sizeof(expression));
+
+    if (e == NULL)
+        mem_fail();
+    else {
+        e->type = E_SELECTION;
+        e->left = NULL;
+        e->right = NULL;
+        e->value = NULL;
+    }
+    return e;
+}
+
+static void
+expression_free(expression *expression)
+{
+    if (expression) {
+        expression_free(expression->left);
+        expression_free(expression->right);
+        free(expression->value);
+        free(expression);
+    }
+}
+
+expression *
+freesasa_selection_atom(expression_type type,
+                        const char *val)
+{
+    expression *e = expression_new();
+    int i, n;
+    char *buf;
+
+    assert(val);
+
+    if (e != NULL) {
+        if (type == E_NEGNUM) {
+            n = strlen(val) + 2;
+            buf = malloc(n);
+            if (buf == NULL) {
+                mem_fail();
+                expression_free(e);
+                return NULL;
+            }
+            sprintf(buf, "-%s", val);
+            e->type = E_NUMBER;
+            e->value = strdup(buf);
+            free(buf);
+        } else {
+            e->type = type;
+            e->value = strdup(val);
+        }
+
+        if (e->value == NULL) {
+            mem_fail();
+            expression_free(e);
+            return NULL;
+        }
+
+        for (i = 0; i < strlen(e->value); ++i)
+            e->value[i] = toupper(e->value[i]);
+    }
+    return e;
+}
+
+expression *
+freesasa_selection_create(expression *selection,
+                          const char *id)
+{
+    expression *e = expression_new();
+
+    assert(id);
+
+    if (e == NULL)
+        expression_free(selection);
+    else {
+        e->type = E_SELECTION;
+        e->left = selection;
+        e->value = strdup(id);
+
+        if (e->value == NULL) {
+            mem_fail();
+            expression_free(e);
+            e = NULL;
+        }
+    }
+
+    return e;
+}
+
+expression *
+freesasa_selection_selector(expression_type type,
+                            expression *list)
+{
+    expression *e = expression_new();
+
+    if (e == NULL) {
+        expression_free(list);
+    } else {
+        e->type = type;
+        e->left = list;
+    }
+
+    return e;
+}
+
+expression *
+freesasa_selection_operation(expression_type type,
+                             expression *left,
+                             expression *right)
+{
+    expression *e = expression_new();
+
+    if (e == NULL) {
+        expression_free(left);
+        expression_free(right);
+    } else {
+        e->type = type;
+        e->left = left;
+        e->right = right;
+    }
+
+    return e;
+}
+
+/* for debugging */
+static void
+print_expr(FILE *output, const expression *e, int level)
+{
+    int i;
+    fprintf(output, "\n");
+    for (i = 0; i < level; ++i)
+        fprintf(output, "  ");
+
+    if (e == NULL) {
+        fprintf(output, "()");
+    } else {
+        fprintf(output, "(%s ", e_str(e->type));
+        if (e->value) fprintf(output, ": %s ", e->value);
+        print_expr(output, e->left, level + 1);
+        print_expr(output, e->right, level + 1);
+        fprintf(output, ")");
+    }
+    fflush(output);
+}
+
+static expression *
+get_expression(const char *selector)
+{
+    freesasa_yyscan_t scanner;
+    YY_BUFFER_STATE state;
+    int err;
+    expression *expression = NULL;
+
+    if (freesasa_yylex_init(&scanner)) {
+        fail_msg("lexer failed");
+    } else {
+        state = freesasa_yy_scan_string(selector, scanner);
+        err = freesasa_yyparse(&expression, scanner);
+        if (err) {
+            if (err == 1) fail_msg("parser failed");
+            if (err == 2) mem_fail();
+            expression_free(expression);
+            expression = NULL;
+        }
+        freesasa_yy_delete_buffer(state, scanner);
+        freesasa_yylex_destroy(scanner);
+    }
+
+    return expression;
+}
+
+static struct selection *
+selection_new(int n)
+{
+    struct selection *selection = malloc(sizeof(struct selection));
+    int i;
+
+    if (selection == NULL) {
+        mem_fail();
+    } else {
+        selection->size = n;
+        selection->atom = malloc(sizeof(int) * n);
+
+        if (selection->atom == NULL) {
+            free(selection);
+            mem_fail();
+            selection = NULL;
+        } else {
+            for (i = 0; i < n; ++i)
+                selection->atom[i] = 0;
+        }
+    }
+
+    return selection;
+}
+
+static void
+selection_free(struct selection *selection)
+{
+    if (selection) {
+        free(selection->atom);
+        free(selection);
+    }
+}
+
+/* Looks for exact match between the atom-name and expr->value */
+static int
+match_name(const freesasa_structure *structure,
+           const char *id,
+           int i)
+{
+    char atom[PDB_ATOM_NAME_STRL + 1];
+    sscanf(freesasa_structure_atom_name(structure, i), "%s", atom);
+    if (strcmp(atom, id) == 0)
+        return 1;
+    return 0;
+}
+
+/** Looks for match of strlen(expr->value) first characters of atom-name and expr->value */
+static int
+match_symbol(const freesasa_structure *structure,
+             const char *id,
+             int i)
+{
+    char symbol[PDB_ATOM_SYMBOL_STRL + 1];
+    sscanf(freesasa_structure_atom_symbol(structure, i), "%s", symbol);
+    if (strcmp(id, symbol) == 0) {
+        return 1;
+    }
+    return 0;
+}
+
+static int
+match_resn(const freesasa_structure *structure,
+           const char *id,
+           int i)
+{
+    char resn[PDB_ATOM_RES_NAME_STRL + 1];
+    sscanf(freesasa_structure_atom_res_name(structure, i), "%s", resn);
+    if (strcmp(resn, id) == 0)
+        return 1;
+    return 0;
+}
+
+static int
+match_resi(const freesasa_structure *structure,
+           const char *id,
+           int i)
+{
+    char resi[PDB_ATOM_RES_NUMBER_STRL + 1];
+    sscanf(freesasa_structure_atom_res_number(structure, i), "%s", resi);
+    if (strcmp(resi, id) == 0)
+        return 1;
+    return 0;
+}
+
+static int
+match_chain(const freesasa_structure *structure,
+            const char *id,
+            int i)
+{
+    return id[0] == freesasa_structure_atom_chain(structure, i);
+}
+
+static void
+select_id(expression_type parent_type,
+          struct selection *selection,
+          const freesasa_structure *structure,
+          const char *id)
+{
+    int count = 0, match, i;
+
+    assert(id);
+
+    for (i = 0; i < selection->size; ++i) {
+        match = 0;
+        switch (parent_type) {
+        case E_NAME:
+            match = match_name(structure, id, i);
+            break;
+        case E_SYMBOL:
+            match = match_symbol(structure, id, i);
+            break;
+        case E_RESN:
+            match = match_resn(structure, id, i);
+            break;
+        case E_RESI:
+            match = match_resi(structure, id, i);
+            break;
+        case E_CHAIN:
+            match = match_chain(structure, id, i);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+        if (match) selection->atom[i] = 1;
+        count += match;
+    }
+    if (count == 0) freesasa_warn("Found no matches to %s '%s', typo?",
+                                  e_str(parent_type), id);
+}
+
+static int
+is_valid_id(int parent_type,
+            const expression *expr)
+{
+    int type, n, warn, i;
+    const char *val;
+
+    assert(expr->type == E_NUMBER || expr->type == E_ID);
+
+    type = expr->type;
+    val = expr->value;
+
+    switch (parent_type) {
+    case E_NAME:
+        if (strlen(val) > PDB_ATOM_NAME_STRL)
+            return freesasa_warn("select: %s: atom name '%s' invalid (string too long), "
+                                 "will be ignored",
+                                 e_str(parent_type), val);
+        break;
+    case E_SYMBOL:
+        if (type != E_ID)
+            return freesasa_warn("select: %s: '%s' invalid (should be 1 or 2 letters, 'C', 'N', 'SE', etc), "
+                                 "will be ignored",
+                                 e_str(parent_type), val);
+        if (strlen(val) > 2)
+            return freesasa_warn("select: %s: '%s' invalid (element names have 1 or 2 characters), "
+                                 "will be ignored",
+                                 e_str(parent_type), val);
+        break;
+    case E_RESN:
+        if (strlen(val) > PDB_ATOM_RES_NAME_STRL)
+            return freesasa_warn("select: %s: '%s' invalid (string too long), "
+                                 "will be ignored",
+                                 e_str(parent_type), val);
+        break;
+    case E_RESI:
+        if (type == E_ID) {
+            /* these should have format 1, 2, 345, etc or 12A, 12B, etc. */
+            n = strlen(val);
+            if (n > PDB_ATOM_RES_NUMBER_STRL) {
+                return freesasa_warn("select: %s: '%s' invalid (string too long), "
+                                     "will be ignored",
+                                     e_str(parent_type), val);
+            } else {
+                warn = 0;
+                if (n == 1) ++warn;
+                if (!warn && (toupper(val[n - 1]) < 'A' || toupper(val[n - 1]) > 'Z')) {
+                    ++warn;
+                }
+                for (i = 0; !warn && i < n - 1; ++i) {
+                    if (val[i] < '0' || val[i] > '9') {
+                        ++warn;
+                    }
+                }
+                if (warn) {
+                    return freesasa_warn("select: %s: '%s' invalid, should either be "
+                                         "number (1, 2, 3) or number with insertion code (1A, 1B, ...), "
+                                         "will be ignored",
+                                         e_str(parent_type), val);
+                }
+            }
+        } else if (type != E_NUMBER) {
+            return freesasa_warn("select: %s: '%s' invalid, will be ignored",
+                                 e_str(parent_type), val);
+        }
+        break;
+    case E_CHAIN:
+        if (strlen(val) > 1)
+            return freesasa_warn("select: %s: '%s' invalid (string too long), "
+                                 "will be ignored",
+                                 e_str(parent_type), val);
+        break;
+    default:
+        assert(0);
+        break;
+    }
+    return FREESASA_SUCCESS;
+}
+
+static int
+select_range(expression_type range_type,
+             expression_type parent_type,
+             struct selection *selection,
+             const freesasa_structure *structure,
+             const expression *left,
+             const expression *right)
+{
+    int lower, upper, i, j;
+
+    assert(range_type == E_RANGE || range_type == E_RANGE_OPEN_L || range_type == E_RANGE_OPEN_R);
+    assert(parent_type == E_RESI || parent_type == E_CHAIN);
+
+    if (parent_type == E_RESI) { /* residues have integer numbering */
+        if ((left && left->type != E_NUMBER) ||
+            (right && right->type != E_NUMBER)) {
+            return freesasa_warn("select: %s: range '%s-%s' invalid, needs to be two numbers, "
+                                 "will be ignored",
+                                 e_str(parent_type), left->value, right->value);
+        }
+    } else { /* chains can be numbered by both letters (common) and numbers (uncommon) */
+        if (left->type != right->type ||
+            (left->type == E_ID && (strlen(left->value) > 1 || strlen(right->value) > 1)))
+            return freesasa_warn("select: %s: range '%s-%s' invalid, should be two letters (A-C) or numbers (1-5), "
+                                 "will be ignored",
+                                 e_str(parent_type), left->value, right->value);
+    }
+    if (range_type == E_RANGE_OPEN_L) {
+        lower = atoi(freesasa_structure_atom_res_number(structure, 0));
+        upper = atoi(right->value);
+    } else if (range_type == E_RANGE_OPEN_R) {
+        lower = atoi(left->value);
+        upper = atoi(freesasa_structure_atom_res_number(structure, freesasa_structure_n(structure) - 1));
+    } else if (left->type == E_NUMBER) {
+        lower = atoi(left->value);
+        upper = atoi(right->value);
+    } else {
+        lower = (int)left->value[0];
+        upper = (int)right->value[0];
+    }
+    for (i = 0; i < selection->size; ++i) {
+        if (parent_type == E_RESI)
+            j = atoi(freesasa_structure_atom_res_number(structure, i));
+        else
+            j = (int)freesasa_structure_atom_chain(structure, i);
+        if (j >= lower && j <= upper)
+            selection->atom[i] = 1;
+    }
+    return FREESASA_SUCCESS;
+}
+
+static int
+select_list(expression_type parent_type,
+            struct selection *selection,
+            const freesasa_structure *structure,
+            const expression *expr)
+{
+    int resr, resl;
+    expression *left, *right;
+
+    if (expr == NULL)
+        return fail_msg("NULL expression");
+
+    left = expr->left;
+    right = expr->right;
+
+    switch (expr->type) {
+    case E_PLUS:
+        if (left == NULL || right == NULL)
+            return fail_msg("NULL expression");
+        resl = select_list(parent_type, selection, structure, left);
+        resr = select_list(parent_type, selection, structure, right);
+        if (resl == FREESASA_WARN || resr == FREESASA_WARN)
+            return FREESASA_WARN;
+        break;
+    case E_RANGE:
+        if (left == NULL || right == NULL)
+            return fail_msg("NULL expression");
+        return select_range(E_RANGE, parent_type, selection, structure, left, right);
+    case E_RANGE_OPEN_L:
+        if (left != NULL || right == NULL)
+            return fail_msg("NULL expression");
+        return select_range(E_RANGE_OPEN_L, parent_type, selection, structure, left, right);
+    case E_RANGE_OPEN_R:
+        if (left == NULL || right != NULL)
+            return fail_msg("NULL expression");
+        return select_range(E_RANGE_OPEN_R, parent_type, selection, structure, left, right);
+    case E_ID:
+    case E_NUMBER:
+        if (is_valid_id(parent_type, expr) == FREESASA_SUCCESS)
+            select_id(parent_type, selection, structure, expr->value);
+        else
+            return freesasa_warn("select: %s: '%s' invalid %s",
+                                 e_str(parent_type), expr->value, e_str(expr->type));
+        break;
+    default:
+        return freesasa_fail("select: parse error (expression: '%s %s')",
+                             e_str(parent_type), e_str(expr->type));
+    }
+    return FREESASA_SUCCESS;
+}
+
+static int
+selection_join(struct selection *target,
+               const struct selection *s1,
+               const struct selection *s2,
+               int type)
+{
+    int n, i;
+
+    if (s1 == NULL || s2 == NULL || target == NULL)
+        return fail_msg("trying to join NULL selections");
+
+    assert(s1->size == s2->size);
+    assert(s1->size == target->size);
+
+    n = target->size;
+
+    switch (type) {
+    case E_AND:
+        for (i = 0; i < n; ++i)
+            target->atom[i] = s1->atom[i] && s2->atom[i];
+        break;
+    case E_OR:
+        for (i = 0; i < n; ++i)
+            target->atom[i] = s1->atom[i] || s2->atom[i];
+        break;
+    default:
+        assert(0);
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+static int
+selection_not(struct selection *s)
+{
+    int i;
+
+    if (s == NULL) return fail_msg("NULL selection");
+
+    for (i = 0; i < s->size; ++i) {
+        s->atom[i] = !s->atom[i];
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+/* Called recursively, the selection is built as we cover the expression tree */
+static int
+select_atoms(struct selection *selection,
+             const expression *expr,
+             const freesasa_structure *structure)
+{
+    int warn = 0, err = 0, n, ret;
+    struct selection *sl, *sr;
+
+    assert(selection);
+    assert(structure);
+
+    n = selection->size;
+
+    /* this should only happen if memory allocation failed during parsing */
+    if (expr == NULL) return fail_msg("NULL expression");
+
+    switch (expr->type) {
+    case E_SELECTION:
+        assert(expr->value != NULL);
+        selection->name = expr->value;
+        return select_atoms(selection, expr->left, structure);
+        break;
+    case E_SYMBOL:
+    case E_NAME:
+    case E_RESN:
+    case E_RESI:
+    case E_CHAIN:
+        return select_list(expr->type, selection, structure, expr->left);
+        break;
+    case E_AND:
+    case E_OR: {
+        sl = selection_new(n);
+        sr = selection_new(n);
+
+        if (sl != NULL && sr != NULL) {
+            if ((ret = select_atoms(sl, expr->left, structure))) {
+                if (ret == FREESASA_WARN) ++warn;
+                if (ret == FREESASA_FAIL) ++err;
+            }
+            if ((ret = select_atoms(sr, expr->right, structure))) {
+                if (ret == FREESASA_WARN) ++warn;
+                if (ret == FREESASA_FAIL) ++err;
+            }
+            selection_join(selection, sl, sr, expr->type);
+        } else {
+            ++err;
+        }
+
+        selection_free(sl);
+        selection_free(sr);
+
+        if (err) return fail_msg("error joining selections");
+        break;
+    }
+    case E_NOT: {
+        ret = select_atoms(selection, expr->right, structure);
+        if (ret == FREESASA_WARN) ++warn;
+        if (ret == FREESASA_FAIL) return FREESASA_FAIL;
+        if (selection_not(selection)) return FREESASA_FAIL;
+        break;
+    }
+    case E_ID:
+    case E_NUMBER:
+    case E_PLUS:
+    case E_RANGE:
+        /* these four are handled by the RESN,SYMBOL,ETC */
+    default:
+        return fail_msg("parser error");
+    }
+    if (warn) return FREESASA_WARN;
+    return FREESASA_SUCCESS;
+}
+
+static int
+select_area_impl(const char *command,
+                 char *name,
+                 double *area,
+                 const freesasa_structure *structure,
+                 const freesasa_result *result)
+{
+    struct selection *selection = NULL;
+    struct expression *expression = NULL;
+    const int maxlen = FREESASA_MAX_SELECTION_NAME;
+    double sasa = 0;
+    int err = 0, warn = 0, n_atoms = 0, j, len;
+
+    assert(name);
+    assert(area);
+    assert(command);
+    assert(structure);
+    assert(result);
+    assert(freesasa_structure_n(structure) == result->n_atoms);
+
+    *area = 0;
+    name[0] = '\0';
+
+    expression = get_expression(command);
+    selection = selection_new(result->n_atoms);
+
+    if (selection == NULL) {
+        return fail_msg("");
+    }
+
+    if (expression != NULL && selection != NULL) {
+        switch (select_atoms(selection, expression, structure)) {
+        case FREESASA_FAIL:
+            err = 1;
+            break;
+        case FREESASA_WARN:
+            warn = 1; /* proceed with calculation, print warning later */
+        case FREESASA_SUCCESS: {
+            for (j = 0; j < selection->size; ++j) {
+                ++n_atoms;
+                sasa += selection->atom[j] * result->sasa[j];
+            }
+
+            *area = sasa;
+            len = strlen(selection->name);
+            strncpy(name, selection->name, maxlen);
+
+            if (len > maxlen) {
+                name[maxlen] = '\0';
+            } else {
+                name[len] = '\0';
+            }
+
+            break;
+        }
+        default:
+            assert(0);
+        }
+    } else {
+        err = 1;
+    }
+    selection_free(selection);
+    expression_free(expression);
+
+    if (err)
+        return fail_msg("problems parsing expression '%s'", command);
+    if (warn)
+        return freesasa_warn("in %s(): There were warnings", __func__);
+    return n_atoms;
+}
+
+freesasa_selection *
+freesasa_selection_alloc(const char *name, const char *command)
+{
+    freesasa_selection *selection = malloc(sizeof(freesasa_selection));
+
+    if (selection == NULL) {
+        mem_fail();
+        return NULL;
+    }
+
+    selection->name = NULL;
+    selection->command = NULL;
+    selection->area = 0;
+    selection->n_atoms = 0;
+
+    selection->name = strdup(name);
+    if (selection->name == NULL) {
+        mem_fail();
+        goto cleanup;
+    }
+
+    selection->command = strdup(command);
+    if (selection->command == NULL) {
+        mem_fail();
+        goto cleanup;
+    }
+
+    return selection;
+
+cleanup:
+    freesasa_selection_free(selection);
+    return NULL;
+}
+
+void freesasa_selection_free(freesasa_selection *selection)
+{
+    if (selection != NULL) {
+        free(selection->name);
+        free(selection->command);
+        free(selection);
+    }
+}
+
+freesasa_selection *
+freesasa_selection_clone(const freesasa_selection *src)
+{
+    freesasa_selection *cpy = freesasa_selection_alloc(src->name, src->command);
+
+    if (cpy == NULL) {
+        fail_msg("");
+        goto cleanup;
+    }
+
+    cpy->area = src->area;
+    cpy->n_atoms = src->n_atoms;
+
+    return cpy;
+
+cleanup:
+    freesasa_selection_free(cpy);
+    return NULL;
+}
+
+const char *
+freesasa_selection_name(const freesasa_selection *selection)
+{
+    assert(selection);
+    return selection->name;
+}
+
+const char *
+freesasa_selection_command(const freesasa_selection *selection)
+{
+    assert(selection);
+    return selection->command;
+}
+
+double
+freesasa_selection_area(const freesasa_selection *selection)
+{
+    assert(selection);
+    return selection->area;
+}
+
+freesasa_selection *
+freesasa_selection_new(const char *command,
+                       const freesasa_structure *structure,
+                       const freesasa_result *result)
+{
+    char name[FREESASA_MAX_SELECTION_NAME];
+    double area;
+    freesasa_selection *selection;
+    int n_atoms;
+
+    n_atoms = select_area_impl(command, name, &area, structure, result);
+
+    if (n_atoms == FREESASA_FAIL) {
+        fail_msg("");
+        return NULL;
+    }
+
+    selection = freesasa_selection_alloc(name, command);
+    if (selection == NULL) {
+        mem_fail();
+        return NULL;
+    }
+
+    selection->area = area;
+    selection->n_atoms = n_atoms;
+
+    return selection;
+}
+
+int freesasa_select_area(const char *command,
+                         char *name,
+                         double *area,
+                         const freesasa_structure *structure,
+                         const freesasa_result *result)
+{
+    int ret = select_area_impl(command, name, area, structure, result);
+    if (ret >= 0) return FREESASA_SUCCESS;
+    return ret;
+}
+
+int freesasa_selection_parse_error(expression *e,
+                                   yyscan_t scanner,
+                                   const char *msg)
+{
+    if (freesasa_get_verbosity() == FREESASA_V_DEBUG) print_expr(stderr, e, 0);
+    if (freesasa_get_verbosity() == FREESASA_V_NORMAL) fprintf(stderr, "\n");
+    return freesasa_fail(msg);
+}
+
+#if USE_CHECK
+#include <check.h>
+
+START_TEST(test_selection)
+{
+    struct selection *s1, *s2, *s3, *s4;
+    static const expression empty_expression = {
+        .right = NULL, .left = NULL, .value = NULL, .type = E_SELECTION};
+    freesasa_structure *structure = freesasa_structure_new();
+    expression r, l, e, e_symbol;
+
+    freesasa_structure_add_atom(structure, " CA ", "ALA", "   1", 'A', 0, 0, 0);
+    freesasa_structure_add_atom(structure, " O  ", "ALA", "   1", 'A', 10, 10, 10);
+
+    s1 = selection_new(freesasa_structure_n(structure));
+    s2 = selection_new(freesasa_structure_n(structure));
+    s3 = selection_new(freesasa_structure_n(structure));
+    s4 = selection_new(freesasa_structure_n(structure));
+
+    r = l = e = e_symbol = empty_expression;
+    e.type = E_PLUS;
+    e.right = &r;
+    e.left = &l;
+    r.value = "C";
+    r.type = E_ID;
+    l.value = "O";
+    l.type = E_ID;
+    e_symbol.type = E_SYMBOL;
+    e_symbol.left = &e;
+
+    /* select_symbol */
+    select_list(E_SYMBOL, s1, structure, &r);
+    ck_assert_int_eq(s1->atom[0], 1);
+    ck_assert_int_eq(s1->atom[1], 0);
+    select_list(E_SYMBOL, s2, structure, &l);
+    ck_assert_int_eq(s2->atom[0], 0);
+    ck_assert_int_eq(s2->atom[1], 1);
+    select_list(E_SYMBOL, s3, structure, &e);
+    ck_assert_int_eq(s3->atom[0], 1);
+    ck_assert_int_eq(s3->atom[1], 1);
+    select_atoms(s4, &e_symbol, structure);
+    ck_assert_int_eq(s4->atom[0], 1);
+    ck_assert_int_eq(s4->atom[1], 1);
+
+    /* selection_join */
+    selection_join(s3, s1, s2, E_AND);
+    ck_assert_int_eq(s3->atom[0], 0);
+    ck_assert_int_eq(s3->atom[1], 0);
+    selection_join(s3, s1, s2, E_OR);
+    ck_assert_int_eq(s3->atom[0], 1);
+    ck_assert_int_eq(s3->atom[1], 1);
+    freesasa_set_verbosity(FREESASA_V_SILENT);
+    ck_assert_int_eq(selection_join(NULL, s1, s2, E_OR), FREESASA_FAIL);
+    ck_assert_int_eq(selection_join(s3, NULL, s1, E_OR), FREESASA_FAIL);
+    ck_assert_int_eq(selection_join(NULL, NULL, NULL, E_OR), FREESASA_FAIL);
+
+    /* selection_not */
+    ck_assert_int_eq(selection_not(s3), FREESASA_SUCCESS);
+    ck_assert_int_eq(s3->atom[0], 0);
+    ck_assert_int_eq(s3->atom[1], 0);
+    ck_assert_int_eq(selection_not(NULL), FREESASA_FAIL);
+    freesasa_set_verbosity(FREESASA_V_NORMAL);
+}
+END_TEST
+
+START_TEST(test_expression)
+{
+    int i;
+    expression *e = get_expression("c1, symbol O+C");
+
+    ck_assert_ptr_ne(e, NULL);
+    ck_assert_int_eq(e->type, E_SELECTION);
+    ck_assert_ptr_ne(e->left, NULL);
+    ck_assert_ptr_eq(e->right, NULL);
+    ck_assert_str_eq(e->value, "c1");
+    ck_assert_int_eq(e->left->type, E_SYMBOL);
+    ck_assert_ptr_ne(e->left->left, NULL);
+    ck_assert_ptr_eq(e->left->right, NULL);
+    ck_assert_int_eq(e->left->left->type, E_PLUS);
+    ck_assert_int_eq(e->left->left->left->type, E_ID);
+    ck_assert_int_eq(e->left->left->right->type, E_ID);
+    ck_assert_str_eq(e->left->left->right->value, "C");
+    ck_assert_str_eq(e->left->left->left->value, "O");
+    for (i = E_SELECTION; i <= E_RANGE_OPEN_R; ++i) {
+        ck_assert_ptr_ne(e_str(i), NULL);
+    }
+    ck_assert_ptr_eq(e_str(E_RANGE_OPEN_R + 1), NULL);
+}
+END_TEST
+
+START_TEST(test_debug) /* this test just runs the debug output code to not get artificially low coverage */
+{
+    FILE *devnull = fopen("/dev/null", "w");
+    expression *e = get_expression("c1, symbol O+C");
+    print_expr(devnull, e, 0);
+}
+END_TEST
+
+struct selection selection_dummy = {.size = 1, .name = NULL, .atom = NULL};
+
+void *freesasa_selection_dummy_ptr = &selection_dummy;
+
+int freesasa_wrap_select_atoms(struct selection *selection,
+                               const expression *expr,
+                               const freesasa_structure *structure)
+{
+    return select_atoms(selection, expr, structure);
+}
+
+TCase *
+test_selection_static()
+{
+    TCase *tc = tcase_create("selection.c static");
+    tcase_add_test(tc, test_selection);
+    tcase_add_test(tc, test_expression);
+    tcase_add_test(tc, test_debug);
+
+    return tc;
+}
+
+#endif /* USE_CHECK */

.venv_haddock/include/site/python3.12/freesasa/selection.h

@@ -0,0 +1,49 @@
+#ifndef SELECTION_H
+#define SELECTION_H
+
+typedef enum { E_SELECTION,
+               E_SYMBOL,
+               E_NAME,
+               E_RESN,
+               E_RESI,
+               E_CHAIN,
+               E_ID,
+               E_NUMBER,
+               E_NEGNUM,
+               E_AND,
+               E_OR,
+               E_NOT,
+               E_PLUS,
+               E_RANGE,
+               E_RANGE_OPEN_L,
+               E_RANGE_OPEN_R } expression_type;
+
+typedef struct expression {
+    struct expression *left;
+    struct expression *right;
+    expression_type type;
+    char *value;
+} expression;
+
+/** Create an atomic value E_ID or E_NUMBER */
+expression *
+freesasa_selection_atom(expression_type type,
+                        const char *val);
+
+/** Create a top level selection (E_SELECTION) */
+expression *
+freesasa_selection_create(expression *selection,
+                          const char *id);
+
+/** Create a property selector (E_SYMBOL, E_NAME, E_RESN, E_RESI or E_CHAIN) */
+expression *
+freesasa_selection_selector(expression_type type,
+                            expression *list);
+
+/** Create an operation (E_AND, E_OR, E_NOT, E_PLUS or E_RANGE) */
+expression *
+freesasa_selection_operation(expression_type type,
+                             expression *left,
+                             expression *right);
+
+#endif /* SELECTION_H */

.venv_haddock/include/site/python3.12/freesasa/structure.c

@@ -0,0 +1,1243 @@
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "classifier.h"
+#include "coord.h"
+#include "freesasa_internal.h"
+#include "pdb.h"
+
+/**
+   This file contains the functions that turn lines in PDB files to
+   atom records. It's all pretty messy because one needs to keep track
+   of when a new chain/new residue is encountered, and skip atoms that
+   are duplicates (only first of alt coordinates are used). It is both
+   possible to add atoms one by one, or by reading a whole file at
+   once, and the user can supply some options about what to do when
+   encountering atoms that are not recognized, whether to include
+   hydrogrens, hetatm, etc. The current implementation results in a
+   rather convoluted logic, that is difficult to maintain, debug and
+   extend.
+
+   TODO: Refactor.
+*/
+#define ATOMS_CHUNK 512
+#define RESIDUES_CHUNK 64
+#define CHAINS_CHUNK 64
+
+struct atom {
+    char *res_name;
+    char *res_number;
+    char *atom_name;
+    char *symbol;
+    char *line;
+    int res_index;
+    char chain_label;
+    freesasa_atom_class the_class;
+};
+
+static const struct atom empty_atom = {
+    NULL,                 /* res_name */
+    NULL,                 /* res_number */
+    NULL,                 /* atom_name */
+    NULL,                 /* symbol */
+    NULL,                 /* line */
+    -1,                   /* res_index */
+    '\0',                 /* chain_label */
+    FREESASA_ATOM_UNKNOWN /* the_class */
+};
+
+struct atoms {
+    int n;
+    int n_alloc;
+    struct atom **atom;
+    double *radius;
+};
+
+struct residues {
+    int n;
+    int n_alloc;
+    int *first_atom;
+    freesasa_nodearea **reference_area;
+};
+
+struct chains {
+    int n;
+    int n_alloc;
+    char *labels;    /* all chain labels found (as string) */
+    int *first_atom; /* first atom of each chain */
+};
+
+struct freesasa_structure {
+    struct atoms atoms;
+    struct residues residues;
+    struct chains chains;
+    char *classifier_name;
+    coord_t *xyz;
+    int model; /* model number */
+    size_t cif_ref;
+    void (*release_cif_ref)(size_t);
+};
+
+static int
+guess_symbol(char *symbol,
+             const char *name);
+
+static void
+atom_free(struct atom *a)
+{
+    if (a != NULL) {
+        free(a->res_name);
+        free(a->res_number);
+        free(a->atom_name);
+        free(a->symbol);
+        free(a->line);
+        free(a);
+    }
+}
+
+struct atoms
+atoms_init(void)
+{
+    struct atoms atoms;
+    atoms.n = 0;
+    atoms.n_alloc = 0;
+    atoms.atom = NULL;
+    atoms.radius = NULL;
+    return atoms;
+}
+
+/* Allocates memory in chunks, ticks up atoms->n if allocation successful */
+static int
+atoms_alloc(struct atoms *atoms)
+{
+    int i, new_size;
+    void *aa, *ar;
+
+    assert(atoms);
+    assert(atoms->n <= atoms->n_alloc);
+
+    if (atoms->n == atoms->n_alloc) {
+        new_size = atoms->n_alloc + ATOMS_CHUNK;
+        aa = atoms->atom;
+        ar = atoms->radius;
+
+        atoms->atom = realloc(atoms->atom, sizeof(struct atom *) * new_size);
+        if (atoms->atom == NULL) {
+            atoms->atom = aa;
+            return mem_fail();
+        }
+
+        for (i = atoms->n_alloc; i < new_size; ++i) {
+            atoms->atom[i] = NULL;
+        }
+
+        atoms->radius = realloc(atoms->radius, sizeof(double) * new_size);
+        if (atoms->radius == NULL) {
+            atoms->radius = ar;
+            return mem_fail();
+        }
+
+        atoms->n_alloc = new_size;
+    }
+    ++atoms->n;
+    return FREESASA_SUCCESS;
+}
+
+static void
+atoms_dealloc(struct atoms *atoms)
+{
+    int i;
+    struct atom **atom;
+
+    if (atoms) {
+        atom = atoms->atom;
+        if (atom) {
+            for (i = 0; i < atoms->n; ++i)
+                if (atom[i]) atom_free(atom[i]);
+            free(atom);
+        }
+        free(atoms->radius);
+        *atoms = atoms_init();
+    }
+}
+
+static struct atom *
+atom_new(const char *residue_name,
+         const char *residue_number,
+         const char *atom_name,
+         const char *symbol,
+         char chain_label)
+{
+    struct atom *a = malloc(sizeof(struct atom));
+    if (a == NULL) goto memerr;
+
+    *a = empty_atom;
+
+    a->line = NULL;
+    a->chain_label = chain_label;
+    a->res_index = -1;
+
+    a->res_name = strdup(residue_name);
+    a->res_number = strdup(residue_number);
+    a->atom_name = strdup(atom_name);
+    a->symbol = strdup(symbol);
+    a->the_class = FREESASA_ATOM_UNKNOWN;
+
+    if (!a->res_name || !a->res_number || !a->atom_name ||
+        !a->symbol) {
+        goto memerr;
+    }
+
+    return a;
+
+memerr:
+    mem_fail();
+    atom_free(a);
+    return NULL;
+}
+
+static struct atom *
+atom_new_from_line(const char *line,
+                   char *alt_label)
+{
+    char aname[PDB_ATOM_NAME_STRL + 1], rname[PDB_ATOM_RES_NAME_STRL + 1],
+        rnumber[PDB_ATOM_RES_NUMBER_STRL + 1], symbol[PDB_ATOM_SYMBOL_STRL + 1];
+    int flag;
+    struct atom *a;
+
+    assert(line);
+
+    if (alt_label) *alt_label = freesasa_pdb_get_alt_coord_label(line);
+
+    freesasa_pdb_get_atom_name(aname, line);
+    freesasa_pdb_get_res_name(rname, line);
+    freesasa_pdb_get_res_number(rnumber, line);
+
+    flag = freesasa_pdb_get_symbol(symbol, line);
+    if (flag == FREESASA_FAIL || (symbol[0] == ' ' && symbol[1] == ' ')) {
+        guess_symbol(symbol, aname);
+    }
+
+    a = atom_new(rname, rnumber, aname, symbol, freesasa_pdb_get_chain_label(line));
+
+    if (a != NULL) {
+        a->line = strdup(line);
+        if (a->line == NULL) {
+            mem_fail();
+            atom_free(a);
+            a = NULL;
+        }
+    }
+
+    return a;
+}
+
+static struct residues
+residues_init(void)
+{
+    struct residues res;
+
+    res.n = 0;
+    res.n_alloc = 0;
+    res.first_atom = 0;
+    res.reference_area = 0;
+
+    return res;
+}
+
+static int
+residues_alloc(struct residues *residues)
+{
+    int new_size;
+    void *fa, *ra;
+
+    assert(residues);
+    assert(residues->n <= residues->n_alloc);
+
+    if (residues->n == residues->n_alloc) {
+        new_size = residues->n_alloc + RESIDUES_CHUNK;
+        fa = residues->first_atom;
+        ra = residues->reference_area;
+
+        residues->first_atom = realloc(residues->first_atom,
+                                       sizeof(int) * new_size);
+        if (residues->first_atom == NULL) {
+            residues->first_atom = fa;
+            return mem_fail();
+        }
+
+        residues->reference_area = realloc(residues->reference_area,
+                                           sizeof(freesasa_nodearea *) * new_size);
+        if (residues->reference_area == NULL) {
+            residues->reference_area = ra;
+            return mem_fail();
+        }
+
+        residues->n_alloc = new_size;
+    }
+    ++residues->n;
+    return FREESASA_SUCCESS;
+}
+
+static void
+residues_dealloc(struct residues *residues)
+{
+    int i;
+
+    if (residues) {
+        free(residues->first_atom);
+        if (residues->reference_area) {
+            for (i = 0; i < residues->n; ++i) {
+                free(residues->reference_area[i]);
+            }
+        }
+        free(residues->reference_area);
+        *residues = residues_init();
+    }
+}
+
+static struct chains
+chains_init(void)
+{
+    struct chains ch;
+
+    ch.n = 0;
+    ch.n_alloc = 0;
+    ch.first_atom = NULL;
+    ch.labels = NULL;
+
+    return ch;
+}
+
+static int
+chains_alloc(struct chains *chains)
+{
+    int new_size;
+    void *fa, *lbl;
+
+    assert(chains);
+    assert(chains->n <= chains->n_alloc);
+
+    if (chains->n == chains->n_alloc) {
+        new_size = chains->n_alloc + CHAINS_CHUNK;
+        fa = chains->first_atom;
+        lbl = chains->labels;
+
+        chains->first_atom = realloc(chains->first_atom,
+                                     sizeof(int) * new_size);
+        if (chains->first_atom == NULL) {
+            chains->first_atom = fa;
+            return mem_fail();
+        }
+
+        chains->labels = realloc(chains->labels, new_size + 1);
+        if (chains->labels == NULL) {
+            chains->labels = lbl;
+            return mem_fail();
+        }
+
+        chains->n_alloc = new_size;
+    }
+    ++chains->n;
+    return FREESASA_SUCCESS;
+}
+
+static void
+chains_dealloc(struct chains *chains)
+{
+    if (chains) {
+        free(chains->first_atom);
+        free(chains->labels);
+        *chains = chains_init();
+    }
+}
+
+freesasa_structure *
+freesasa_structure_new(void)
+{
+    freesasa_structure *s = malloc(sizeof(freesasa_structure));
+
+    if (s == NULL) goto memerr;
+
+    s->atoms = atoms_init();
+    s->residues = residues_init();
+    s->chains = chains_init();
+    s->xyz = freesasa_coord_new();
+    s->model = 1;
+    s->classifier_name = NULL;
+    s->cif_ref = 0;
+    s->release_cif_ref = 0;
+
+    if (s->xyz == NULL) goto memerr;
+
+    return s;
+memerr:
+    freesasa_structure_free(s);
+    mem_fail();
+    return NULL;
+}
+
+void freesasa_structure_free(freesasa_structure *s)
+{
+    if (s != NULL) {
+        atoms_dealloc(&s->atoms);
+        residues_dealloc(&s->residues);
+        chains_dealloc(&s->chains);
+
+        if (s->xyz != NULL) {
+            freesasa_coord_free(s->xyz);
+        }
+
+        free(s->classifier_name);
+
+        if (s->cif_ref > 0 && s->release_cif_ref != NULL) {
+            s->release_cif_ref(s->cif_ref);
+        }
+
+        free(s);
+    }
+}
+
+/**
+    This function is called when either the symbol field is missing
+    from an ATOM record, or when an atom is added directly using
+    freesasa_structure_add_atom() or
+    freesasa_structure_add_atom_wopt(). The symbol is in turn only
+    used if the atom cannot be recognized by the classifier.
+*/
+static int
+guess_symbol(char *symbol,
+             const char *name)
+{
+    /* if the first position is empty, or a number, assume that it is
+       a one letter element e.g. " C ", or "1H " */
+    if (name[0] == ' ' || (name[0] >= '1' && name[0] <= '9')) {
+        symbol[0] = ' ';
+        symbol[1] = name[1];
+        symbol[2] = '\0';
+    } else {
+        /* if the string has padding to the right, it's a
+           two-letter element, e.g. "FE  " */
+        if (name[3] == ' ') {
+            strncpy(symbol, name, 2);
+            symbol[2] = '\0';
+        } else {
+            /* If it's a four-letter string, it's hard to say,
+               assume only the first letter signifies the element */
+            symbol[0] = ' ';
+            symbol[1] = name[0];
+            symbol[2] = '\0';
+            return freesasa_warn("guessing that atom '%s' is symbol '%s'",
+                                 name, symbol);
+        }
+    }
+    return FREESASA_SUCCESS;
+}
+static int
+structure_add_chain(freesasa_structure *s,
+                    char chain_label,
+                    int i_latest_atom)
+{
+    int n;
+    if (s->chains.n == 0 || strchr(s->chains.labels, chain_label) == NULL) {
+
+        if (chains_alloc(&s->chains) == FREESASA_FAIL)
+            return fail_msg("");
+
+        n = s->chains.n;
+        s->chains.labels[n - 1] = chain_label;
+        s->chains.labels[n] = '\0';
+
+        assert(strlen(s->chains.labels) == s->chains.n);
+
+        s->chains.first_atom[n - 1] = i_latest_atom;
+    }
+    return FREESASA_SUCCESS;
+}
+
+static int
+structure_add_residue(freesasa_structure *s,
+                      const freesasa_classifier *classifier,
+                      const struct atom *a,
+                      int i_latest_atom)
+{
+    int n = s->residues.n + 1;
+    const freesasa_nodearea *reference = NULL;
+
+    /* register a new residue if it's the first atom, or if the
+       residue number or chain label of the current atom is different
+       from the previous one */
+    if (!(s->residues.n == 0 ||
+          (i_latest_atom > 0 &&
+           (strcmp(a->res_number, s->atoms.atom[i_latest_atom - 1]->res_number) ||
+            a->chain_label != s->atoms.atom[i_latest_atom - 1]->chain_label)))) {
+        return FREESASA_SUCCESS;
+    }
+
+    if (residues_alloc(&s->residues) == FREESASA_FAIL) {
+        return fail_msg("");
+    }
+    s->residues.first_atom[n - 1] = i_latest_atom;
+
+    s->residues.reference_area[n - 1] = NULL;
+    reference = freesasa_classifier_residue_reference(classifier, a->res_name);
+    if (reference != NULL) {
+        s->residues.reference_area[n - 1] = malloc(sizeof(freesasa_nodearea));
+        if (s->residues.reference_area[n - 1] == NULL)
+            return mem_fail();
+        *s->residues.reference_area[n - 1] = *reference;
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+/**
+    Get the radius of an atom, and fail, warn and/or guess depending
+    on the options.
+ */
+static int
+structure_check_atom_radius(double *radius,
+                            struct atom *a,
+                            const freesasa_classifier *classifier,
+                            int options)
+{
+    *radius = freesasa_classifier_radius(classifier, a->res_name, a->atom_name);
+    if (*radius < 0) {
+        if (options & FREESASA_HALT_AT_UNKNOWN) {
+            return fail_msg("atom '%s %s' unknown",
+                            a->res_name, a->atom_name);
+        } else if (options & FREESASA_SKIP_UNKNOWN) {
+            return freesasa_warn("skipping unknown atom '%s %s'",
+                                 a->res_name, a->atom_name, a->symbol, *radius);
+        } else {
+            *radius = freesasa_guess_radius(a->symbol);
+            if (*radius < 0) {
+                *radius = +0.;
+                freesasa_warn("atom '%s %s' unknown and "
+                              "can't guess radius of symbol '%s', "
+                              "assigning radius 0 A",
+                              a->res_name, a->atom_name, a->symbol);
+            } else {
+                freesasa_warn("atom '%s %s' unknown, guessing element is '%s', "
+                              "and radius %.3f A",
+                              a->res_name, a->atom_name, a->symbol, *radius);
+            }
+            /* do not return FREESASA_WARN here, because we will keep the atom */
+        }
+    }
+    return FREESASA_SUCCESS;
+}
+
+static int
+structure_register_classifier(freesasa_structure *structure,
+                              const freesasa_classifier *classifier)
+{
+    if (structure->classifier_name == NULL) {
+        structure->classifier_name = strdup(freesasa_classifier_name(classifier));
+        if (structure->classifier_name == NULL) {
+            return mem_fail();
+        }
+    } else if (strcmp(structure->classifier_name, freesasa_classifier_name(classifier)) != 0) {
+        structure->classifier_name = strdup(FREESASA_CONFLICTING_CLASSIFIERS);
+        if (structure->classifier_name == NULL) {
+            return mem_fail();
+        }
+        return FREESASA_WARN;
+    }
+
+    return FREESASA_SUCCESS;
+}
+
+/**
+   Adds an atom to the structure using the rules specified by
+   'options'. If it includes FREESASA_RADIUS_FROM_* a dummy radius is
+   assigned and the caller is expected to replace it with a correct
+   radius later.
+
+   The atom a should be a pointer to a heap address, this will not be cloned.
+ */
+static int
+structure_add_atom(freesasa_structure *structure,
+                   struct atom *atom,
+                   double *xyz,
+                   const freesasa_classifier *classifier,
+                   int options)
+{
+    int na, ret;
+    double r;
+
+    assert(structure);
+    assert(atom);
+    assert(xyz);
+
+    /* let the stricter option override if both are specified */
+    if (options & FREESASA_SKIP_UNKNOWN && options & FREESASA_HALT_AT_UNKNOWN)
+        options &= ~FREESASA_SKIP_UNKNOWN;
+
+    if (classifier == NULL) {
+        classifier = &freesasa_default_classifier;
+    }
+    structure_register_classifier(structure, classifier);
+
+    /* calculate radius and check if we should keep the atom (based on options) */
+    if (options & FREESASA_RADIUS_FROM_OCCUPANCY) {
+        r = 1; /* fix it later */
+    } else {
+        ret = structure_check_atom_radius(&r, atom, classifier, options);
+        if (ret == FREESASA_FAIL) return fail_msg("halting at unknown atom");
+        if (ret == FREESASA_WARN) return FREESASA_WARN;
+    }
+    assert(r >= 0);
+
+    /* If it's a keeper, allocate memory */
+    if (atoms_alloc(&structure->atoms) == FREESASA_FAIL)
+        return fail_msg("");
+    na = structure->atoms.n;
+
+    /* Store coordinates */
+    if (freesasa_coord_append(structure->xyz, xyz, 1) == FREESASA_FAIL)
+        return mem_fail();
+
+    /* Check if this is a new chain and if so add it */
+    if (structure_add_chain(structure, atom->chain_label, na - 1) == FREESASA_FAIL)
+        return mem_fail();
+
+    /* Check if this is a new residue, and if so add it */
+    if (structure_add_residue(structure, classifier, atom, na - 1) == FREESASA_FAIL)
+        return mem_fail();
+
+    atom->the_class = freesasa_classifier_class(classifier, atom->res_name, atom->atom_name);
+    atom->res_index = structure->residues.n - 1;
+    structure->atoms.radius[na - 1] = r;
+    structure->atoms.atom[na - 1] = atom;
+
+    return FREESASA_SUCCESS;
+}
+
+/**
+    Handles the reading of PDB-files, returns NULL if problems reading
+    or input or malloc failure. Error-messages should explain what
+    went wrong.
+ */
+static freesasa_structure *
+from_pdb_impl(FILE *pdb_file,
+              struct file_range it,
+              const freesasa_classifier *classifier,
+              int options)
+{
+    char line[PDB_MAX_LINE_STRL];
+    char alt, the_alt = ' ';
+    double v[3], r;
+    int ret;
+    struct atom *a = NULL;
+    freesasa_structure *s = freesasa_structure_new();
+
+    assert(pdb_file);
+
+    if (s == NULL) return NULL;
+
+    fseek(pdb_file, it.begin, SEEK_SET);
+
+    while (fgets(line, PDB_MAX_LINE_STRL, pdb_file) != NULL && ftell(pdb_file) <= it.end) {
+
+        if (strncmp("ATOM", line, 4) == 0 || ((options & FREESASA_INCLUDE_HETATM) &&
+                                              (strncmp("HETATM", line, 6) == 0))) {
+            if (freesasa_pdb_ishydrogen(line) &&
+                !(options & FREESASA_INCLUDE_HYDROGEN))
+                continue;
+
+            a = atom_new_from_line(line, &alt);
+            if (a == NULL)
+                goto cleanup;
+
+            if ((alt != ' ' && the_alt == ' ') || (alt == ' '))
+                the_alt = alt;
+            else if (alt != ' ' && alt != the_alt) {
+                atom_free(a);
+                a = NULL;
+                continue;
+            }
+
+            ret = freesasa_pdb_get_coord(v, line);
+            if (ret == FREESASA_FAIL)
+                goto cleanup;
+
+            ret = structure_add_atom(s, a, v, classifier, options);
+            if (ret == FREESASA_FAIL) {
+                goto cleanup;
+            } else if (ret == FREESASA_WARN) {
+                atom_free(a);
+                a = NULL;
+                continue;
+            }
+
+            if (options & FREESASA_RADIUS_FROM_OCCUPANCY) {
+                ret = freesasa_pdb_get_occupancy(&r, line);
+                if (ret == FREESASA_FAIL)
+                    goto cleanup;
+                s->atoms.radius[s->atoms.n - 1] = r;
+            }
+        }
+
+        if (!(options & FREESASA_JOIN_MODELS)) {
+            if (strncmp("MODEL", line, 5) == 0) sscanf(line + 10, "%d", &s->model);
+            if (strncmp("ENDMDL", line, 6) == 0) break;
+        }
+    }
+
+    if (s->atoms.n == 0) {
+        fail_msg("input had no valid ATOM or HETATM lines");
+        goto cleanup;
+    }
+
+    return s;
+
+cleanup:
+    fail_msg("");
+    atom_free(a);
+    freesasa_structure_free(s);
+    return NULL;
+}
+
+static int
+structure_add_atom_wopt_impl(freesasa_structure *structure,
+                             const char *atom_name,
+                             const char *residue_name,
+                             const char *residue_number,
+                             const char *symbol,
+                             char chain_label,
+                             double x, double y, double z,
+                             const freesasa_classifier *classifier,
+                             int options)
+{
+    struct atom *a;
+    char my_symbol[PDB_ATOM_SYMBOL_STRL + 1];
+    double v[3] = {x, y, z};
+    int ret, warn = 0;
+
+    assert(structure);
+    assert(atom_name);
+    assert(residue_name);
+    assert(residue_number);
+
+    /* this option can not be used here, and needs to be unset */
+    options &= ~FREESASA_RADIUS_FROM_OCCUPANCY;
+
+    if (symbol != NULL) {
+        strncpy(my_symbol, symbol, sizeof(my_symbol));
+    } else if (guess_symbol(my_symbol, atom_name) == FREESASA_WARN &&
+               options & FREESASA_SKIP_UNKNOWN) {
+        ++warn;
+    }
+
+    a = atom_new(residue_name, residue_number, atom_name, my_symbol, chain_label);
+    if (a == NULL) return mem_fail();
+
+    ret = structure_add_atom(structure, a, v, classifier, options);
+
+    if (ret == FREESASA_FAIL ||
+        (ret == FREESASA_WARN && options & FREESASA_SKIP_UNKNOWN))
+        atom_free(a);
+
+    if (!ret && warn) return FREESASA_WARN;
+
+    return ret;
+}
+
+int freesasa_structure_add_atom_wopt(freesasa_structure *structure,
+                                     const char *atom_name,
+                                     const char *residue_name,
+                                     const char *residue_number,
+                                     char chain_label,
+                                     double x, double y, double z,
+                                     const freesasa_classifier *classifier,
+                                     int options)
+{
+    return structure_add_atom_wopt_impl(structure, atom_name, residue_name, residue_number, NULL,
+                                        chain_label, x, y, z, classifier, options);
+}
+int freesasa_structure_add_atom(freesasa_structure *structure,
+                                const char *atom_name,
+                                const char *residue_name,
+                                const char *residue_number,
+                                char chain_label,
+                                double x, double y, double z)
+{
+    return structure_add_atom_wopt_impl(structure, atom_name, residue_name, residue_number, NULL,
+                                        chain_label, x, y, z, NULL, 0);
+}
+
+int freesasa_structure_add_cif_atom(freesasa_structure *structure,
+                                    freesasa_cif_atom *atom,
+                                    const freesasa_classifier *classifier,
+                                    int options)
+{
+    char res_number[PDB_ATOM_RES_NUMBER_STRL + 1];
+
+    if (atom->pdbx_PDB_ins_code[0] != '?') {
+        snprintf(res_number, sizeof res_number, "%s%c", atom->auth_seq_id, atom->pdbx_PDB_ins_code[0]);
+    } else {
+        snprintf(res_number, sizeof res_number, "%s", atom->auth_seq_id);
+    }
+
+    return structure_add_atom_wopt_impl(structure, atom->auth_atom_id, atom->auth_comp_id,
+                                        res_number, atom->type_symbol, atom->auth_asym_id,
+                                        atom->Cartn_x, atom->Cartn_y, atom->Cartn_z,
+                                        classifier, options);
+}
+
+freesasa_structure *
+freesasa_structure_from_pdb(FILE *pdb_file,
+                            const freesasa_classifier *classifier,
+                            int options)
+{
+    assert(pdb_file);
+    return from_pdb_impl(pdb_file, freesasa_whole_file(pdb_file),
+                         classifier, options);
+}
+
+freesasa_structure **
+freesasa_structure_array(FILE *pdb,
+                         int *n,
+                         const freesasa_classifier *classifier,
+                         int options)
+{
+    struct file_range *models = NULL, *chains = NULL;
+    struct file_range whole_file;
+    int n_models = 0, n_chains = 0, j0, n_new_chains, i, j;
+    freesasa_structure **ss = NULL, **ssb;
+
+    assert(pdb);
+    assert(n);
+
+    if (!(options & FREESASA_SEPARATE_MODELS ||
+          options & FREESASA_SEPARATE_CHAINS)) {
+        fail_msg("options need to specify at least one of FREESASA_SEPARATE_CHAINS "
+                 "and FREESASA_SEPARATE_MODELS");
+        return NULL;
+    }
+
+    whole_file = freesasa_whole_file(pdb);
+    n_models = freesasa_pdb_get_models(pdb, &models);
+
+    if (n_models == FREESASA_FAIL) {
+        fail_msg("problems reading PDB-file");
+        return NULL;
+    }
+    if (n_models == 0) {
+        models = &whole_file;
+        n_models = 1;
+    }
+
+    /* only keep first model if option not provided */
+    if (!(options & FREESASA_SEPARATE_MODELS)) n_models = 1;
+
+    /* for each model read chains if requested */
+    if (options & FREESASA_SEPARATE_CHAINS) {
+        for (i = 0; i < n_models; ++i) {
+            chains = NULL;
+            n_new_chains = freesasa_pdb_get_chains(pdb, models[i], &chains, options);
+
+            if (n_new_chains == FREESASA_FAIL) goto cleanup;
+            if (n_new_chains == 0) {
+                freesasa_warn("in %s(): no chains found (in model %d)", __func__, i + 1);
+                continue;
+            }
+
+            ssb = ss;
+            ss = realloc(ss, sizeof(freesasa_structure *) * (n_chains + n_new_chains));
+
+            if (!ss) {
+                ss = ssb;
+                mem_fail();
+                goto cleanup;
+            }
+
+            j0 = n_chains;
+            n_chains += n_new_chains;
+
+            for (j = 0; j < n_new_chains; ++j)
+                ss[j0 + j] = NULL;
+
+            for (j = 0; j < n_new_chains; ++j) {
+                ss[j0 + j] = from_pdb_impl(pdb, chains[j], classifier, options);
+                if (ss[j0 + j] == NULL) goto cleanup;
+                ss[j0 + j]->model = i + 1;
+            }
+
+            free(chains);
+        }
+        *n = n_chains;
+    } else {
+        ss = malloc(sizeof(freesasa_structure *) * n_models);
+        if (!ss) {
+            mem_fail();
+            goto cleanup;
+        }
+
+        for (i = 0; i < n_models; ++i)
+            ss[i] = NULL;
+        *n = n_models;
+
+        for (i = 0; i < n_models; ++i) {
+            ss[i] = from_pdb_impl(pdb, models[i], classifier, options);
+            if (ss[i] == NULL) goto cleanup;
+            ss[i]->model = i + 1;
+        }
+    }
+
+    if (*n == 0) goto cleanup;
+
+    if (models != &whole_file) free(models);
+
+    return ss;
+
+cleanup:
+    if (ss)
+        for (i = 0; i < *n; ++i)
+            freesasa_structure_free(ss[i]);
+    if (models != &whole_file) free(models);
+    free(chains);
+    *n = 0;
+    free(ss);
+    return NULL;
+}
+
+freesasa_structure *
+freesasa_structure_get_chains(const freesasa_structure *structure,
+                              const char *chains,
+                              const freesasa_classifier *classifier,
+                              int options)
+{
+    freesasa_structure *new_s;
+    struct atom *ai;
+    int i, res;
+    char c;
+    const double *v;
+
+    assert(structure);
+    if (strlen(chains) == 0) return NULL;
+
+    new_s = freesasa_structure_new();
+
+    if (!new_s) {
+        mem_fail();
+        return NULL;
+    }
+
+    new_s->model = structure->model;
+
+    for (i = 0; i < structure->atoms.n; ++i) {
+        ai = structure->atoms.atom[i];
+        c = ai->chain_label;
+        if (strchr(chains, c) != NULL) {
+            v = freesasa_coord_i(structure->xyz, i);
+            res = structure_add_atom_wopt_impl(new_s, ai->atom_name,
+                                               ai->res_name, ai->res_number, ai->symbol,
+                                               c, v[0], v[1], v[2], classifier, options);
+            if (res == FREESASA_FAIL) {
+                fail_msg("");
+                goto cleanup;
+            }
+        }
+    }
+
+    /* the following two tests could have been done by comparing the
+       chain-strings before the loop, but this logic is simpler. */
+    if (new_s->atoms.n == 0) {
+        goto cleanup;
+    }
+    if (strlen(new_s->chains.labels) != strlen(chains)) {
+        fail_msg("structure has chains '%s', but '%s' requested",
+                 structure->chains.labels, chains);
+        goto cleanup;
+    }
+
+    return new_s;
+
+cleanup:
+    freesasa_structure_free(new_s);
+    return NULL;
+}
+
+const char *
+freesasa_structure_chain_labels(const freesasa_structure *structure)
+{
+    assert(structure);
+    return structure->chains.labels;
+}
+
+const coord_t *
+freesasa_structure_xyz(const freesasa_structure *structure)
+{
+    assert(structure);
+    return structure->xyz;
+}
+
+int freesasa_structure_n(const freesasa_structure *structure)
+{
+    assert(structure);
+    return structure->atoms.n;
+}
+
+int freesasa_structure_n_residues(const freesasa_structure *structure)
+{
+    assert(structure);
+    return structure->residues.n;
+}
+
+const char *
+freesasa_structure_atom_name(const freesasa_structure *structure,
+                             int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.atom[i]->atom_name;
+}
+
+const char *
+freesasa_structure_atom_res_name(const freesasa_structure *structure,
+                                 int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.atom[i]->res_name;
+}
+
+const char *
+freesasa_structure_atom_res_number(const freesasa_structure *structure,
+                                   int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.atom[i]->res_number;
+}
+
+char freesasa_structure_atom_chain(const freesasa_structure *structure,
+                                   int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.atom[i]->chain_label;
+}
+const char *
+freesasa_structure_atom_symbol(const freesasa_structure *structure,
+                               int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.atom[i]->symbol;
+}
+
+double
+freesasa_structure_atom_radius(const freesasa_structure *structure,
+                               int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.radius[i];
+}
+
+void freesasa_structure_atom_set_radius(freesasa_structure *structure,
+                                        int i,
+                                        double radius)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    structure->atoms.radius[i] = radius;
+}
+
+freesasa_atom_class
+freesasa_structure_atom_class(const freesasa_structure *structure,
+                              int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.atom[i]->the_class;
+}
+
+const char *
+freesasa_structure_atom_pdb_line(const freesasa_structure *structure,
+                                 int i)
+{
+    assert(structure);
+    assert(i < structure->atoms.n && i >= 0);
+    return structure->atoms.atom[i]->line;
+}
+const freesasa_nodearea *
+freesasa_structure_residue_reference(const freesasa_structure *structure,
+                                     int r_i)
+{
+    assert(structure);
+    assert(r_i >= 0 && r_i < structure->residues.n);
+
+    return structure->residues.reference_area[r_i];
+}
+int freesasa_structure_residue_atoms(const freesasa_structure *structure,
+                                     int r_i,
+                                     int *first,
+                                     int *last)
+{
+    int naa;
+    assert(structure);
+    assert(first);
+    assert(last);
+
+    naa = structure->residues.n;
+
+    assert(r_i >= 0 && r_i < naa);
+
+    *first = structure->residues.first_atom[r_i];
+    if (r_i == naa - 1)
+        *last = structure->atoms.n - 1;
+    else
+        *last = structure->residues.first_atom[r_i + 1] - 1;
+    assert(*last >= *first);
+
+    return FREESASA_SUCCESS;
+}
+
+const char *
+freesasa_structure_residue_name(const freesasa_structure *structure,
+                                int r_i)
+{
+    assert(structure);
+    assert(r_i < structure->residues.n && r_i >= 0);
+    return structure->atoms.atom[structure->residues.first_atom[r_i]]->res_name;
+}
+
+const char *
+freesasa_structure_residue_number(const freesasa_structure *structure,
+                                  int r_i)
+{
+    assert(structure);
+    assert(r_i < structure->residues.n && r_i >= 0);
+    return structure->atoms.atom[structure->residues.first_atom[r_i]]->res_number;
+}
+
+char freesasa_structure_residue_chain(const freesasa_structure *structure,
+                                      int r_i)
+{
+    assert(structure);
+    assert(r_i < structure->residues.n && r_i >= 0);
+
+    return structure->atoms.atom[structure->residues.first_atom[r_i]]->chain_label;
+}
+
+int freesasa_structure_n_chains(const freesasa_structure *structure)
+{
+    return structure->chains.n;
+}
+
+int freesasa_structure_chain_index(const freesasa_structure *structure,
+                                   char chain)
+{
+    int i;
+
+    assert(structure);
+
+    for (i = 0; i < structure->chains.n; ++i) {
+        if (structure->chains.labels[i] == chain) return i;
+    }
+    return fail_msg("chain %c not found", chain);
+}
+
+int freesasa_structure_chain_atoms(const freesasa_structure *structure,
+                                   char chain,
+                                   int *first,
+                                   int *last)
+{
+    int c_i, n;
+
+    assert(structure);
+
+    c_i = freesasa_structure_chain_index(structure, chain);
+    n = freesasa_structure_n_chains(structure);
+
+    if (c_i < 0) return fail_msg("");
+
+    *first = structure->chains.first_atom[c_i];
+    if (c_i == n - 1)
+        *last = freesasa_structure_n(structure) - 1;
+    else
+        *last = structure->chains.first_atom[c_i + 1] - 1;
+    assert(*last >= *first);
+
+    return FREESASA_SUCCESS;
+}
+
+int freesasa_structure_chain_residues(const freesasa_structure *structure,
+                                      char chain,
+                                      int *first,
+                                      int *last)
+{
+    int first_atom, last_atom;
+
+    assert(structure);
+
+    if (freesasa_structure_chain_atoms(structure, chain, &first_atom, &last_atom))
+        return fail_msg("");
+
+    *first = structure->atoms.atom[first_atom]->res_index;
+    *last = structure->atoms.atom[last_atom]->res_index;
+
+    return FREESASA_SUCCESS;
+}
+
+const char *
+freesasa_structure_classifier_name(const freesasa_structure *structure)
+{
+    assert(structure);
+    return structure->classifier_name;
+}
+
+int freesasa_structure_model(const freesasa_structure *structure)
+{
+    return structure->model;
+}
+
+const double *
+freesasa_structure_coord_array(const freesasa_structure *structure)
+{
+    return freesasa_coord_all(structure->xyz);
+}
+
+const double *
+freesasa_structure_radius(const freesasa_structure *structure)
+{
+    assert(structure);
+    return structure->atoms.radius;
+}
+
+void freesasa_structure_set_radius(freesasa_structure *structure,
+                                   const double *radii)
+{
+    assert(structure);
+    assert(radii);
+    memcpy(structure->atoms.radius, radii, structure->atoms.n * sizeof(double));
+}
+
+void freesasa_structure_set_model(freesasa_structure *structure,
+                                  int model)
+{
+    structure->model = model;
+}
+
+void freesasa_structure_set_cif_ref(freesasa_structure *structure,
+                                    size_t ref,
+                                    void (*release_func)(size_t))
+{
+    assert(structure);
+    structure->cif_ref = ref;
+    structure->release_cif_ref = release_func;
+}
+
+size_t freesasa_structure_cif_ref(const freesasa_structure *structure)
+{
+    assert(structure);
+    return structure->cif_ref;
+}

.venv_haddock/include/site/python3.12/freesasa/util.c

@@ -0,0 +1,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;
+}

.venv_haddock/lib/python3.12/site-packages/._distutils-precedence.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbd1f4c19356c9f782c0fce50a927d08f5a7a89ae88cc56fe8e671aeba8ef15d
+size 4096