Return to mandoc_xr.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/mandoc_xr.c, Revision 1.1

1.1     ! schwarze    1: /*     $Id$ */
        !             2: /*
        !             3:  * Copyright (c) 2017 Ingo Schwarze <schwarze@openbsd.org>
        !             4:  *
        !             5:  * Permission to use, copy, modify, and distribute this software for any
        !             6:  * purpose with or without fee is hereby granted, provided that the above
        !             7:  * copyright notice and this permission notice appear in all copies.
        !             8:  *
        !             9:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
        !            10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
        !            11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
        !            12:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
        !            13:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
        !            14:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
        !            15:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
        !            16:  */
        !            17: #include <sys/types.h>
        !            18:
        !            19: #include <assert.h>
        !            20: #include <stddef.h>
        !            21: #include <stdint.h>
        !            22: #include <stdlib.h>
        !            23: #include <string.h>
        !            24:
        !            25: #include "mandoc_aux.h"
        !            26: #include "mandoc_ohash.h"
        !            27: #include "mandoc_xr.h"
        !            28:
        !            29: static struct ohash     *xr_hash = NULL;
        !            30: static struct mandoc_xr         *xr_first = NULL;
        !            31: static struct mandoc_xr         *xr_last = NULL;
        !            32:
        !            33: static void              mandoc_xr_clear(void);
        !            34:
        !            35:
        !            36: static void
        !            37: mandoc_xr_clear(void)
        !            38: {
        !            39:        struct mandoc_xr        *xr;
        !            40:        unsigned int             slot;
        !            41:
        !            42:        if (xr_hash == NULL)
        !            43:                return;
        !            44:        for (xr = ohash_first(xr_hash, &slot); xr != NULL;
        !            45:             xr = ohash_next(xr_hash, &slot))
        !            46:                free(xr);
        !            47:        ohash_delete(xr_hash);
        !            48: }
        !            49:
        !            50: void
        !            51: mandoc_xr_reset(void)
        !            52: {
        !            53:        if (xr_hash == NULL)
        !            54:                xr_hash = mandoc_malloc(sizeof(*xr_hash));
        !            55:        else
        !            56:                mandoc_xr_clear();
        !            57:        mandoc_ohash_init(xr_hash, 5,
        !            58:            offsetof(struct mandoc_xr, hashkey));
        !            59:        xr_first = xr_last = NULL;
        !            60: }
        !            61:
        !            62: void
        !            63: mandoc_xr_add(const char *sec, const char *name, int line, int pos)
        !            64: {
        !            65:        struct mandoc_xr         *xr;
        !            66:        const char               *pend;
        !            67:        size_t                    ssz, nsz, tsz;
        !            68:        unsigned int              slot;
        !            69:        uint32_t                  hv;
        !            70:
        !            71:        if (xr_hash == NULL)
        !            72:                return;
        !            73:
        !            74:        ssz = strlen(sec) + 1;
        !            75:        nsz = strlen(name) + 1;
        !            76:        tsz = ssz + nsz;
        !            77:        xr = mandoc_malloc(sizeof(*xr) + tsz);
        !            78:        xr->next = NULL;
        !            79:        xr->sec = xr->hashkey;
        !            80:        xr->name = xr->hashkey + ssz;
        !            81:        xr->line = line;
        !            82:        xr->pos = pos;
        !            83:        memcpy(xr->sec, sec, ssz);
        !            84:        memcpy(xr->name, name, nsz);
        !            85:
        !            86:        pend = xr->hashkey + tsz;
        !            87:        hv = ohash_interval(xr->hashkey, &pend);
        !            88:        slot = ohash_lookup_memory(xr_hash, xr->hashkey, tsz, hv);
        !            89:        if (ohash_find(xr_hash, slot) == NULL) {
        !            90:                ohash_insert(xr_hash, slot, xr);
        !            91:                if (xr_first == NULL)
        !            92:                        xr_first = xr;
        !            93:                else
        !            94:                        xr_last->next = xr;
        !            95:                xr_last = xr;
        !            96:        } else
        !            97:                free(xr);
        !            98: }
        !            99:
        !           100: struct mandoc_xr *
        !           101: mandoc_xr_get(void)
        !           102: {
        !           103:        return xr_first;
        !           104: }
        !           105:
        !           106: void
        !           107: mandoc_xr_free(void)
        !           108: {
        !           109:        mandoc_xr_clear();
        !           110:        free(xr_hash);
        !           111:        xr_hash = NULL;
        !           112: }