=================================================================== RCS file: /cvs/mandoc/tag.c,v retrieving revision 1.4 retrieving revision 1.32 diff -u -p -r1.4 -r1.32 --- mandoc/tag.c 2015/07/25 14:02:06 1.4 +++ mandoc/tag.c 2020/04/03 10:30:09 1.32 @@ -1,6 +1,6 @@ -/* $Id: tag.c,v 1.4 2015/07/25 14:02:06 schwarze Exp $ */ +/* $Id: tag.c,v 1.32 2020/04/03 10:30:09 schwarze Exp $ */ /* - * Copyright (c) 2015 Ingo Schwarze + * Copyright (c) 2015,2016,2018,2019,2020 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -13,183 +13,172 @@ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Functions to tag syntax tree nodes. + * For internal use by mandoc(1) validation modules only. */ +#include "config.h" + #include -#include +#include +#include #include -#include +#include #include #include -#include -#if HAVE_OHASH -#include -#else -#include "compat_ohash.h" -#endif - #include "mandoc_aux.h" +#include "mandoc_ohash.h" +#include "roff.h" #include "tag.h" struct tag_entry { - size_t line; + struct roff_node **nodes; + size_t maxnodes; + size_t nnodes; int prio; char s[]; }; -static void tag_signal(int); -static void *tag_alloc(size_t, void *); -static void tag_free(void *, void *); -static void *tag_calloc(size_t, size_t, void *); - static struct ohash tag_data; -static char *tag_fn = NULL; -static int tag_fd = -1; /* - * Set up the ohash table to collect output line numbers - * where various marked-up terms are documented and create - * the temporary tags file, saving the name for the pager. + * Set up the ohash table to collect nodes + * where various marked-up terms are documented. */ -char * -tag_init(void) +void +tag_alloc(void) { - struct ohash_info tag_info; - - tag_fn = mandoc_strdup("/tmp/man.XXXXXXXXXX"); - signal(SIGHUP, tag_signal); - signal(SIGINT, tag_signal); - signal(SIGTERM, tag_signal); - if ((tag_fd = mkstemp(tag_fn)) == -1) { - free(tag_fn); - tag_fn = NULL; - return(NULL); - } - - tag_info.alloc = tag_alloc; - tag_info.calloc = tag_calloc; - tag_info.free = tag_free; - tag_info.key_offset = offsetof(struct tag_entry, s); - tag_info.data = NULL; - ohash_init(&tag_data, 4, &tag_info); - return(tag_fn); + mandoc_ohash_init(&tag_data, 4, offsetof(struct tag_entry, s)); } -/* - * Return the line number where a term is defined, - * or 0 if the term is unknown. - */ -size_t -tag_get(const char *s, size_t len, int prio) +void +tag_free(void) { struct tag_entry *entry; - const char *end; unsigned int slot; - if (tag_fd == -1) - return(0); - if (len == 0) - len = strlen(s); - end = s + len; - slot = ohash_qlookupi(&tag_data, s, &end); - entry = ohash_find(&tag_data, slot); - return((entry == NULL || prio < entry->prio) ? 0 : entry->line); + if (tag_data.info.free == NULL) + return; + entry = ohash_first(&tag_data, &slot); + while (entry != NULL) { + free(entry->nodes); + free(entry); + entry = ohash_next(&tag_data, &slot); + } + ohash_delete(&tag_data); + tag_data.info.free = NULL; } /* - * Set the line number where a term is defined. + * Set a node where a term is defined, + * unless it is already defined at a lower priority. */ void -tag_put(const char *s, size_t len, int prio, size_t line) +tag_put(const char *s, int prio, struct roff_node *n) { struct tag_entry *entry; - const char *end; + const char *se; + size_t len; unsigned int slot; - if (tag_fd == -1) - return; + assert(prio <= TAG_FALLBACK); + + if (s == NULL) { + if (n->child == NULL || n->child->type != ROFFT_TEXT) + return; + s = n->child->string; + switch (s[0]) { + case '-': + s++; + break; + case '\\': + switch (s[1]) { + case '&': + case '-': + case 'e': + s += 2; + break; + default: + break; + } + break; + default: + break; + } + } + + /* + * Skip whitespace and escapes and whatever follows, + * and if there is any, downgrade the priority. + */ + + len = strcspn(s, " \t\\"); if (len == 0) - len = strlen(s); - end = s + len; - slot = ohash_qlookupi(&tag_data, s, &end); + return; + + se = s + len; + if (*se != '\0' && prio < TAG_WEAK) + prio = TAG_WEAK; + + slot = ohash_qlookupi(&tag_data, s, &se); entry = ohash_find(&tag_data, slot); + + /* Build a new entry. */ + if (entry == NULL) { entry = mandoc_malloc(sizeof(*entry) + len + 1); memcpy(entry->s, s, len); entry->s[len] = '\0'; + entry->nodes = NULL; + entry->maxnodes = entry->nnodes = 0; ohash_insert(&tag_data, slot, entry); } - entry->line = line; - entry->prio = prio; -} -/* - * Write out the tags file using the previously collected - * information and clear the ohash table while going along. - */ -void -tag_write(void) -{ - FILE *stream; - struct tag_entry *entry; - unsigned int slot; + /* + * Lower priority numbers take precedence. + * If a better entry is already present, ignore the new one. + */ - if (tag_fd == -1) - return; - stream = fdopen(tag_fd, "w"); - entry = ohash_first(&tag_data, &slot); - while (entry != NULL) { - if (stream != NULL) - fprintf(stream, "%s - %zu\n", entry->s, entry->line); - free(entry); - entry = ohash_next(&tag_data, &slot); - } - ohash_delete(&tag_data); - if (stream != NULL) - fclose(stream); -} + else if (entry->prio < prio) + return; -void -tag_unlink(void) -{ + /* + * If the existing entry is worse, clear it. + * In addition, a tag with priority TAG_FALLBACK + * is only used if the tag occurs exactly once. + */ - if (tag_fn != NULL) - unlink(tag_fn); -} + else if (entry->prio > prio || prio == TAG_FALLBACK) { + while (entry->nnodes > 0) + entry->nodes[--entry->nnodes]->flags &= ~NODE_ID; -static void -tag_signal(int signum) -{ + if (prio == TAG_FALLBACK) { + entry->prio = TAG_DELETE; + return; + } + } - tag_unlink(); - signal(signum, SIG_DFL); - kill(getpid(), signum); - /* NOTREACHED */ - _exit(1); -} + /* Remember the new node. */ -/* - * Memory management callback functions for ohash. - */ -static void * -tag_alloc(size_t sz, void *arg) -{ - - return(mandoc_malloc(sz)); + if (entry->maxnodes == entry->nnodes) { + entry->maxnodes += 4; + entry->nodes = mandoc_reallocarray(entry->nodes, + entry->maxnodes, sizeof(*entry->nodes)); + } + entry->nodes[entry->nnodes++] = n; + entry->prio = prio; + n->flags |= NODE_ID; + if (n->child == NULL || n->child->string != s || *se != '\0') { + assert(n->string == NULL); + n->string = mandoc_strndup(s, len); + } } -static void * -tag_calloc(size_t nmemb, size_t sz, void *arg) +int +tag_exists(const char *tag) { - - return(mandoc_calloc(nmemb, sz)); -} - -static void -tag_free(void *p, void *arg) -{ - - free(p); + return ohash_find(&tag_data, ohash_qlookup(&tag_data, tag)) != NULL; }