* mandoc: 1.
@ 2023-11-24 5:02 schwarze
0 siblings, 0 replies; 2+ messages in thread
From: schwarze @ 2023-11-24 5:02 UTC (permalink / raw)
To: source
Log Message:
-----------
1. Do not put ASCII_HYPH (0x1c) into the tag file.
That happened when tagging a string containing '-' on an input text line,
most commonly in man(7) .TP next line scope.
2. Do not let "\-" end the tag.
In both cases, translate ASCII_HYPH and "\-" to plain '-' for output.
For example, this improves handling of unbound.conf(5).
These two bugs were found thanks to a posting by weerd@.
Modified Files:
--------------
mandoc:
TODO
tag.c
mandoc/regress/mdoc/Cm:
tag.out_html
tag.out_tag
Revision Data
-------------
Index: tag.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/tag.c,v
retrieving revision 1.37
retrieving revision 1.38
diff -Ltag.c -Ltag.c -u -p -r1.37 -r1.38
--- tag.c
+++ tag.c
@@ -1,6 +1,6 @@
/* $Id$ */
/*
- * Copyright (c) 2015, 2016, 2018, 2019, 2020, 2022
+ * Copyright (c) 2015, 2016, 2018, 2019, 2020, 2022, 2023
* Ingo Schwarze <schwarze@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
@@ -26,11 +26,13 @@
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
+#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mandoc_aux.h"
#include "mandoc_ohash.h"
+#include "mandoc.h"
#include "roff.h"
#include "mdoc.h"
#include "roff_int.h"
@@ -88,9 +90,11 @@ tag_put(const char *s, int prio, struct
{
struct tag_entry *entry;
struct roff_node *nold;
- const char *se;
+ const char *se, *src;
+ char *cpy;
size_t len;
unsigned int slot;
+ int changed;
assert(prio <= TAG_FALLBACK);
@@ -106,6 +110,7 @@ tag_put(const char *s, int prio, struct
/* Determine the implicit tag. */
+ changed = 1;
if (s == NULL) {
if (n->child == NULL || n->child->type != ROFFT_TEXT)
return;
@@ -122,27 +127,53 @@ tag_put(const char *s, int prio, struct
s += 2;
break;
default:
- break;
+ return;
}
break;
default:
+ changed = 0;
break;
}
}
/*
+ * Translate \- and ASCII_HYPH to plain '-'.
* Skip whitespace and escapes and whatever follows,
* and if there is any, downgrade the priority.
*/
- len = strcspn(s, " \t\\");
+ cpy = mandoc_malloc(strlen(s) + 1);
+ for (src = s, len = 0; *src != '\0'; src++, len++) {
+ switch (*src) {
+ case '\t':
+ case ' ':
+ changed = 1;
+ break;
+ case ASCII_HYPH:
+ cpy[len] = '-';
+ changed = 1;
+ continue;
+ case '\\':
+ if (src[1] != '-')
+ break;
+ src++;
+ changed = 1;
+ /* FALLTHROUGH */
+ default:
+ cpy[len] = *src;
+ continue;
+ }
+ break;
+ }
if (len == 0)
- return;
+ goto out;
+ cpy[len] = '\0';
- se = s + len;
- if (*se != '\0' && prio < TAG_WEAK)
+ if (*src != '\0' && prio < TAG_WEAK)
prio = TAG_WEAK;
+ s = cpy;
+ se = cpy + len;
slot = ohash_qlookupi(&tag_data, s, &se);
entry = ohash_find(&tag_data, slot);
@@ -150,8 +181,7 @@ tag_put(const char *s, int prio, struct
if (entry == NULL) {
entry = mandoc_malloc(sizeof(*entry) + len + 1);
- memcpy(entry->s, s, len);
- entry->s[len] = '\0';
+ memcpy(entry->s, s, len + 1);
entry->nodes = NULL;
entry->maxnodes = entry->nnodes = 0;
ohash_insert(&tag_data, slot, entry);
@@ -163,7 +193,7 @@ tag_put(const char *s, int prio, struct
*/
else if (entry->prio < prio)
- return;
+ goto out;
/*
* If the existing entry is worse, clear it.
@@ -180,7 +210,7 @@ tag_put(const char *s, int prio, struct
}
if (prio == TAG_FALLBACK) {
entry->prio = TAG_DELETE;
- return;
+ goto out;
}
}
@@ -194,10 +224,13 @@ tag_put(const char *s, int prio, struct
entry->nodes[entry->nnodes++] = n;
entry->prio = prio;
n->flags |= NODE_ID;
- if (n->child == NULL || n->child->string != s || *se != '\0') {
+ if (changed) {
assert(n->tag == NULL);
n->tag = mandoc_strndup(s, len);
}
+
+ out:
+ free(cpy);
}
int
Index: TODO
===================================================================
RCS file: /home/cvs/mandoc/mandoc/TODO,v
retrieving revision 1.333
retrieving revision 1.334
diff -LTODO -LTODO -u -p -r1.333 -r1.334
--- TODO
+++ TODO
@@ -76,11 +76,6 @@ are mere guesses, and some may be wrong.
to Nab 8 Aug 2023 20:05:32 +0200 Subject: if/ie d condition always true
loc ** exist *** algo *** size ** imp *
-- tag.c, tag_put() should not put ASCII_HYPH into the tag file,
- which happens when the tag contains "-" on the input side
- weerd@ 28 Sep 2021 12:44:07 +0200
- loc * exist * algo * size * imp ***
-
************************************************************************
* missing features
@@ -323,12 +318,6 @@ are mere guesses, and some may be wrong.
this may be feasible using fts_set(FTS_FOLLOW)
mail to sternenseemann 19 Aug 2021 19:11:50 +0200
loc * exist ** algo ** size * imp **
-
-- tag.c, tag_put() and callers like man_validate.c, check_tag()
- should not mistake "\-" as a word-ending escape sequence but
- instead translate it to plain "-" in the tag name
- weerd@ 28 Sep 2021 12:44:07 +0200
- loc ** exist * algo * size * imp ***
- handle Unicode letters in tags in both HTML and terminal output
thread "section headers with diacritics" starting with
Index: tag.out_tag
===================================================================
RCS file: /home/cvs/mandoc/mandoc/regress/mdoc/Cm/tag.out_tag,v
retrieving revision 1.4
retrieving revision 1.5
diff -Lregress/mdoc/Cm/tag.out_tag -Lregress/mdoc/Cm/tag.out_tag -u -p -r1.4 -r1.5
--- regress/mdoc/Cm/tag.out_tag
+++ regress/mdoc/Cm/tag.out_tag
@@ -4,6 +4,6 @@ one tag.mandoc_ascii 9
two tag.mandoc_ascii 9
three tag.mandoc_ascii 12
hyphen tag.mandoc_ascii 14
-minus tag.mandoc_ascii 17
+minus-sign tag.mandoc_ascii 17
backslash tag.mandoc_ascii 20
four tag.mandoc_ascii 22
Index: tag.out_html
===================================================================
RCS file: /home/cvs/mandoc/mandoc/regress/mdoc/Cm/tag.out_html,v
retrieving revision 1.3
retrieving revision 1.4
diff -Lregress/mdoc/Cm/tag.out_html -Lregress/mdoc/Cm/tag.out_html -u -p -r1.3 -r1.4
--- regress/mdoc/Cm/tag.out_html
+++ regress/mdoc/Cm/tag.out_html
@@ -7,7 +7,7 @@
<dd>text</dd>
<dt id="hyphen"><a class="permalink" href="#hyphen"><code class="Cm">-hyphen</code></a></dt>
<dd>text</dd>
- <dt id="minus"><a class="permalink" href="#minus"><code class="Cm">-minus-sign</code></a></dt>
+ <dt id="minus-sign"><a class="permalink" href="#minus-sign"><code class="Cm">-minus-sign</code></a></dt>
<dd>text</dd>
<dt id="backslash"><a class="permalink" href="#backslash"><code class="Cm">\backslash</code></a></dt>
<dd>text</dd>
--
To unsubscribe send an email to source+unsubscribe@mandoc.bsd.lv
^ permalink raw reply [flat|nested] 2+ messages in thread
* mandoc: 1.
@ 2017-07-08 14:51 schwarze
0 siblings, 0 replies; 2+ messages in thread
From: schwarze @ 2017-07-08 14:51 UTC (permalink / raw)
To: source
Log Message:
-----------
1. Eliminate struct eqn, instead use the existing members
of struct roff_node which is allocated for each equation anyway.
2. Do not keep a list of equation parsers, one parser is enough.
Minus fifty lines of code, no functional change.
Modified Files:
--------------
mandoc:
eqn.c
eqn_html.c
eqn_term.c
html.h
libmandoc.h
libroff.h
mandoc.h
mandoc_headers.3
read.c
roff.c
roff.h
roff_int.h
term.h
tree.c
Revision Data
-------------
Index: read.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/read.c,v
retrieving revision 1.189
retrieving revision 1.190
diff -Lread.c -Lread.c -u -p -r1.189 -r1.190
--- read.c
+++ read.c
@@ -540,14 +540,11 @@ rerun:
* currently open parse. Since we only get here if
* there does exist data (see tbl_data.c), we're
* guaranteed that something's been allocated.
- * Do the same for ROFF_EQN.
*/
if (rr == ROFF_TBL)
while ((span = roff_span(curp->roff)) != NULL)
roff_addtbl(curp->man, span);
- else if (rr == ROFF_EQN)
- roff_addeqn(curp->man, roff_eqn(curp->roff));
else if ((curp->man->macroset == MACROSET_MDOC ?
mdoc_parseln(curp->man, curp->line, ln.buf, of) :
man_parseln(curp->man, curp->line, ln.buf, of)) == 2)
Index: libmandoc.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/libmandoc.h,v
retrieving revision 1.68
retrieving revision 1.69
diff -Llibmandoc.h -Llibmandoc.h -u -p -r1.68 -r1.69
--- libmandoc.h
+++ libmandoc.h
@@ -24,7 +24,6 @@ enum rofferr {
ROFF_SO, /* include another file */
ROFF_IGN, /* ignore current line */
ROFF_TBL, /* a table row was successfully parsed */
- ROFF_EQN /* an equation was successfully parsed */
};
struct buf {
@@ -35,7 +34,6 @@ struct buf {
struct mparse;
struct tbl_span;
-struct eqn;
struct roff;
struct roff_man;
@@ -77,4 +75,3 @@ int roff_getcontrol(const struct roff
int roff_getformat(const struct roff *);
const struct tbl_span *roff_span(const struct roff *);
-const struct eqn *roff_eqn(const struct roff *);
Index: roff.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/roff.h,v
retrieving revision 1.57
retrieving revision 1.58
diff -Lroff.h -Lroff.h -u -p -r1.57 -r1.58
--- roff.h
+++ roff.h
@@ -499,7 +499,7 @@ struct roff_node {
union mdoc_data *norm; /* Normalized arguments. */
char *string; /* TEXT */
const struct tbl_span *span; /* TBL */
- const struct eqn *eqn; /* EQN */
+ struct eqn_box *eqn; /* EQN */
int line; /* Input file line number. */
int pos; /* Input file column number. */
int flags;
Index: libroff.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/libroff.h,v
retrieving revision 1.40
retrieving revision 1.41
diff -Llibroff.h -Llibroff.h -u -p -r1.40 -r1.41
--- libroff.h
+++ libroff.h
@@ -38,9 +38,8 @@ struct tbl_node {
};
struct eqn_node {
- struct eqn eqn; /* syntax tree of this equation */
struct mparse *parse; /* main parser, for error reporting */
- struct eqn_node *next; /* singly linked list of equations */
+ struct roff_node *node; /* syntax tree of this equation */
struct eqn_def *defs; /* array of definitions */
char *data; /* source code of this equation */
char *start; /* first byte of the current token */
@@ -73,8 +72,9 @@ void tbl_data(struct tbl_node *, int,
int tbl_cdata(struct tbl_node *, int, const char *, int);
const struct tbl_span *tbl_span(struct tbl_node *);
int tbl_end(struct tbl_node **);
-struct eqn_node *eqn_alloc(int, int, struct mparse *);
-enum rofferr eqn_end(struct eqn_node **);
+struct eqn_node *eqn_alloc(struct mparse *);
+void eqn_box_free(struct eqn_box *);
void eqn_free(struct eqn_node *);
-enum rofferr eqn_read(struct eqn_node **, int,
- const char *, int, int *);
+void eqn_parse(struct eqn_node *);
+void eqn_read(struct eqn_node *, const char *);
+void eqn_reset(struct eqn_node *);
Index: eqn.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/eqn.c,v
retrieving revision 1.75
retrieving revision 1.76
diff -Leqn.c -Leqn.c -u -p -r1.75 -r1.76
--- eqn.c
+++ eqn.c
@@ -27,8 +27,9 @@
#include <string.h>
#include <time.h>
-#include "mandoc.h"
#include "mandoc_aux.h"
+#include "mandoc.h"
+#include "roff.h"
#include "libmandoc.h"
#include "libroff.h"
@@ -284,76 +285,48 @@ enum parse_mode {
};
static struct eqn_box *eqn_box_alloc(struct eqn_node *, struct eqn_box *);
-static void eqn_box_free(struct eqn_box *);
static struct eqn_box *eqn_box_makebinary(struct eqn_node *,
struct eqn_box *);
static void eqn_def(struct eqn_node *);
static struct eqn_def *eqn_def_find(struct eqn_node *);
static void eqn_delim(struct eqn_node *);
static enum eqn_tok eqn_next(struct eqn_node *, enum parse_mode);
-static enum rofferr eqn_parse(struct eqn_node *, struct eqn_box *);
static void eqn_undef(struct eqn_node *);
-enum rofferr
-eqn_read(struct eqn_node **epp, int ln,
- const char *p, int pos, int *offs)
+struct eqn_node *
+eqn_alloc(struct mparse *parse)
{
- size_t sz;
- struct eqn_node *ep;
- enum rofferr er;
-
- ep = *epp;
-
- /*
- * If we're the terminating mark, unset our equation status and
- * validate the full equation.
- */
+ struct eqn_node *ep;
- if (0 == strncmp(p, ".EN", 3)) {
- er = eqn_end(epp);
- p += 3;
- while (' ' == *p || '\t' == *p)
- p++;
- if ('\0' == *p)
- return er;
- mandoc_vmsg(MANDOCERR_ARG_SKIP, ep->parse,
- ln, pos, "EN %s", p);
- return er;
- }
-
- /*
- * Build up the full string, replacing all newlines with regular
- * whitespace.
- */
-
- sz = strlen(p + pos) + 1;
- ep->data = mandoc_realloc(ep->data, ep->sz + sz + 1);
-
- /* First invocation: nil terminate the string. */
-
- if (0 == ep->sz)
- *ep->data = '\0';
-
- ep->sz += sz;
- strlcat(ep->data, p + pos, ep->sz + 1);
- strlcat(ep->data, " ", ep->sz + 1);
- return ROFF_IGN;
+ ep = mandoc_calloc(1, sizeof(*ep));
+ ep->parse = parse;
+ ep->gsize = EQN_DEFSIZE;
+ return ep;
}
-struct eqn_node *
-eqn_alloc(int pos, int line, struct mparse *parse)
+void
+eqn_reset(struct eqn_node *ep)
{
- struct eqn_node *p;
-
- p = mandoc_calloc(1, sizeof(struct eqn_node));
+ free(ep->data);
+ ep->data = ep->start = ep->end = NULL;
+ ep->sz = ep->toksz = 0;
+}
- p->parse = parse;
- p->eqn.ln = line;
- p->eqn.pos = pos;
- p->gsize = EQN_DEFSIZE;
+void
+eqn_read(struct eqn_node *ep, const char *p)
+{
+ char *cp;
- return p;
+ if (ep->data == NULL) {
+ ep->sz = strlen(p);
+ ep->data = mandoc_strdup(p);
+ } else {
+ ep->sz = mandoc_asprintf(&cp, "%s %s", ep->data, p);
+ free(ep->data);
+ ep->data = cp;
+ }
+ ep->sz += 1;
}
/*
@@ -427,7 +400,7 @@ eqn_next(struct eqn_node *ep, enum parse
ep->start++; /* Skip opening quote. */
if (ep->end == NULL) {
mandoc_msg(MANDOCERR_ARG_QUOTE, ep->parse,
- ep->eqn.ln, ep->eqn.pos, NULL);
+ ep->node->line, ep->node->pos, NULL);
ep->end = strchr(ep->start, '\0');
}
} else {
@@ -448,7 +421,7 @@ eqn_next(struct eqn_node *ep, enum parse
break;
if (++lim > EQN_NEST_MAX) {
mandoc_msg(MANDOCERR_ROFFLOOP, ep->parse,
- ep->eqn.ln, ep->eqn.pos, NULL);
+ ep->node->line, ep->node->pos, NULL);
return EQN_TOK_EOF;
}
@@ -492,7 +465,7 @@ eqn_next(struct eqn_node *ep, enum parse
return EQN_TOK__MAX;
}
-static void
+void
eqn_box_free(struct eqn_box *bp)
{
@@ -570,7 +543,7 @@ eqn_delim(struct eqn_node *ep)
{
if (ep->end[0] == '\0' || ep->end[1] == '\0') {
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, "delim");
+ ep->node->line, ep->node->pos, "delim");
if (ep->end[0] != '\0')
ep->end++;
} else if (strncmp(ep->end, "off", 3) == 0) {
@@ -597,7 +570,7 @@ eqn_undef(struct eqn_node *ep)
if (eqn_next(ep, MODE_NOSUB) == EQN_TOK_EOF) {
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, "undef");
+ ep->node->line, ep->node->pos, "undef");
return;
}
if ((def = eqn_def_find(ep)) == NULL)
@@ -616,7 +589,7 @@ eqn_def(struct eqn_node *ep)
if (eqn_next(ep, MODE_NOSUB) == EQN_TOK_EOF) {
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, "define");
+ ep->node->line, ep->node->pos, "define");
return;
}
@@ -645,7 +618,7 @@ eqn_def(struct eqn_node *ep)
if (eqn_next(ep, MODE_QUOTED) == EQN_TOK_EOF) {
mandoc_vmsg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, "define %s", def->key);
+ ep->node->line, ep->node->pos, "define %s", def->key);
free(def->key);
free(def->val);
def->key = def->val = NULL;
@@ -657,19 +630,17 @@ eqn_def(struct eqn_node *ep)
def->valsz = ep->toksz;
}
-/*
- * Recursively parse an eqn(7) expression.
- */
-static enum rofferr
-eqn_parse(struct eqn_node *ep, struct eqn_box *parent)
+void
+eqn_parse(struct eqn_node *ep)
{
- struct eqn_box *cur, *nbox, *split;
+ struct eqn_box *cur, *nbox, *parent, *split;
const char *cp, *cpn;
char *p;
enum eqn_tok tok;
enum { CCL_LET, CCL_DIG, CCL_PUN } ccl, ccln;
int size;
+ parent = ep->node->eqn;
assert(parent != NULL);
/*
@@ -678,7 +649,7 @@ eqn_parse(struct eqn_node *ep, struct eq
*/
if (ep->data == NULL)
- return ROFF_IGN;
+ return;
ep->start = ep->end = ep->data + strspn(ep->data, " ^~");
@@ -696,7 +667,7 @@ next_tok:
if (eqn_next(ep, MODE_NOSUB) == EQN_TOK_EOF ||
eqn_next(ep, MODE_QUOTED) == EQN_TOK_EOF)
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, "tdefine");
+ ep->node->line, ep->node->pos, "tdefine");
break;
case EQN_TOK_DELIM:
eqn_delim(ep);
@@ -704,7 +675,7 @@ next_tok:
case EQN_TOK_GFONT:
if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF)
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
break;
case EQN_TOK_MARK:
case EQN_TOK_LINEUP:
@@ -720,7 +691,7 @@ next_tok:
case EQN_TOK_DOTDOT:
if (parent->last == NULL) {
mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
cur = eqn_box_alloc(ep, parent);
cur->type = EQN_TEXT;
cur->text = mandoc_strdup("");
@@ -765,7 +736,7 @@ next_tok:
case EQN_TOK_UP:
if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF)
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
break;
case EQN_TOK_FAT:
case EQN_TOK_ROMAN:
@@ -803,13 +774,13 @@ next_tok:
/* Accept two values: integral size and a single. */
if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF) {
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
break;
}
size = mandoc_strntoi(ep->start, ep->toksz, 10);
if (-1 == size) {
mandoc_msg(MANDOCERR_IT_NONUM, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
break;
}
if (EQN_TOK_GSIZE == tok) {
@@ -834,7 +805,7 @@ next_tok:
*/
if (parent->last == NULL) {
mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
cur = eqn_box_alloc(ep, parent);
cur->type = EQN_TEXT;
cur->text = mandoc_strdup("");
@@ -901,7 +872,7 @@ next_tok:
*/
if (parent->last == NULL) {
mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
cur = eqn_box_alloc(ep, parent);
cur->type = EQN_TEXT;
cur->text = mandoc_strdup("");
@@ -928,15 +899,15 @@ next_tok:
break;
if (cur == NULL) {
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
break;
}
parent = cur;
if (EQN_TOK_RIGHT == tok) {
if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF) {
mandoc_msg(MANDOCERR_REQ_EMPTY,
- ep->parse, ep->eqn.ln,
- ep->eqn.pos, eqn_toks[tok]);
+ ep->parse, ep->node->line,
+ ep->node->pos, eqn_toks[tok]);
break;
}
/* Handling depends on right/left. */
@@ -971,7 +942,7 @@ next_tok:
if (EQN_TOK_LEFT == tok &&
eqn_next(ep, MODE_SUB) == EQN_TOK_EOF) {
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
break;
}
parent = eqn_box_alloc(ep, parent);
@@ -1005,7 +976,7 @@ next_tok:
break;
if (cur == NULL) {
mandoc_msg(MANDOCERR_IT_STRAY, ep->parse,
- ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
+ ep->node->line, ep->node->pos, eqn_toks[tok]);
break;
}
parent = eqn_box_alloc(ep, cur);
@@ -1019,11 +990,7 @@ next_tok:
parent->expectargs = 1;
break;
case EQN_TOK_EOF:
- /*
- * End of file!
- * TODO: make sure we're not in an open subexpression.
- */
- return ROFF_EQN;
+ return;
case EQN_TOK__MAX:
case EQN_TOK_FUNC:
case EQN_TOK_QUOTED:
@@ -1120,25 +1087,10 @@ next_tok:
goto next_tok;
}
-enum rofferr
-eqn_end(struct eqn_node **epp)
-{
- struct eqn_node *ep;
-
- ep = *epp;
- *epp = NULL;
-
- ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
- ep->eqn.root->expectargs = UINT_MAX;
- return eqn_parse(ep, ep->eqn.root);
-}
-
void
eqn_free(struct eqn_node *p)
{
int i;
-
- eqn_box_free(p->eqn.root);
for (i = 0; i < (int)p->defsz; i++) {
free(p->defs[i].key);
Index: eqn_term.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/eqn_term.c,v
retrieving revision 1.12
retrieving revision 1.13
diff -Leqn_term.c -Leqn_term.c -u -p -r1.12 -r1.13
--- eqn_term.c
+++ eqn_term.c
@@ -40,10 +40,10 @@ static void eqn_box(struct termp *, cons
void
-term_eqn(struct termp *p, const struct eqn *ep)
+term_eqn(struct termp *p, const struct eqn_box *bp)
{
- eqn_box(p, ep->root);
+ eqn_box(p, bp);
p->flags &= ~TERMP_NOSPACE;
}
Index: tree.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/tree.c,v
retrieving revision 1.76
retrieving revision 1.77
diff -Ltree.c -Ltree.c -u -p -r1.76 -r1.77
--- tree.c
+++ tree.c
@@ -202,7 +202,7 @@ print_mdoc(const struct roff_node *n, in
}
if (n->eqn)
- print_box(n->eqn->root->first, indent + 4);
+ print_box(n->eqn->first, indent + 4);
if (n->child)
print_mdoc(n->child, indent +
(n->type == ROFFT_BLOCK ? 2 : 4));
@@ -287,7 +287,7 @@ print_man(const struct roff_node *n, int
}
if (n->eqn)
- print_box(n->eqn->root->first, indent + 4);
+ print_box(n->eqn->first, indent + 4);
if (n->child)
print_man(n->child, indent +
(n->type == ROFFT_BLOCK ? 2 : 4));
Index: mandoc.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/mandoc.h,v
retrieving revision 1.244
retrieving revision 1.245
diff -Lmandoc.h -Lmandoc.h -u -p -r1.244 -r1.245
--- mandoc.h
+++ mandoc.h
@@ -402,17 +402,6 @@ struct eqn_box {
};
/*
- * An equation consists of a tree of expressions starting at a given
- * line and position.
- */
-struct eqn {
- char *name; /* identifier (or NULL) */
- struct eqn_box *root; /* root mathematical expression */
- int ln; /* invocation line */
- int pos; /* invocation position */
-};
-
-/*
* Parse options.
*/
#define MPARSE_MDOC 1 /* assume -mdoc */
Index: roff_int.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/roff_int.h,v
retrieving revision 1.7
retrieving revision 1.8
diff -Lroff_int.h -Lroff_int.h -u -p -r1.7 -r1.8
--- roff_int.h
+++ roff_int.h
@@ -25,7 +25,6 @@ void roff_elem_alloc(struct roff_man
struct roff_node *roff_block_alloc(struct roff_man *, int, int, int);
struct roff_node *roff_head_alloc(struct roff_man *, int, int, int);
struct roff_node *roff_body_alloc(struct roff_man *, int, int, int);
-void roff_addeqn(struct roff_man *, const struct eqn *);
void roff_addtbl(struct roff_man *, const struct tbl_span *);
void roff_node_unlink(struct roff_man *, struct roff_node *);
void roff_node_free(struct roff_node *);
Index: term.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/term.h,v
retrieving revision 1.129
retrieving revision 1.130
diff -Lterm.h -Lterm.h -u -p -r1.129 -r1.130
--- term.h
+++ term.h
@@ -36,7 +36,7 @@ enum termfont {
TERMFONT__MAX
};
-struct eqn;
+struct eqn_box;
struct roff_meta;
struct roff_node;
struct tbl_span;
@@ -126,7 +126,7 @@ const char *ascii_uc2str(int);
void roff_term_pre(struct termp *, const struct roff_node *);
-void term_eqn(struct termp *, const struct eqn *);
+void term_eqn(struct termp *, const struct eqn_box *);
void term_tbl(struct termp *, const struct tbl_span *);
void term_free(struct termp *);
void term_setcol(struct termp *, size_t);
Index: html.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/html.h,v
retrieving revision 1.86
retrieving revision 1.87
diff -Lhtml.h -Lhtml.h -u -p -r1.86 -r1.87
--- html.h
+++ html.h
@@ -115,7 +115,7 @@ struct html {
struct roff_node;
struct tbl_span;
-struct eqn;
+struct eqn_box;
void roff_html_pre(struct html *, const struct roff_node *);
@@ -127,7 +127,7 @@ void print_stagq(struct html *, const
void print_text(struct html *, const char *);
void print_tblclose(struct html *);
void print_tbl(struct html *, const struct tbl_span *);
-void print_eqn(struct html *, const struct eqn *);
+void print_eqn(struct html *, const struct eqn_box *);
void print_paragraph(struct html *);
void print_endline(struct html *);
Index: eqn_html.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/eqn_html.c,v
retrieving revision 1.15
retrieving revision 1.16
diff -Leqn_html.c -Leqn_html.c -u -p -r1.15 -r1.16
--- eqn_html.c
+++ eqn_html.c
@@ -227,14 +227,14 @@ out:
}
void
-print_eqn(struct html *p, const struct eqn *ep)
+print_eqn(struct html *p, const struct eqn_box *bp)
{
struct tag *t;
t = print_otag(p, TAG_MATH, "c", "eqn");
p->flags |= HTML_NONOSPACE;
- eqn_box(p, ep->root);
+ eqn_box(p, bp);
p->flags &= ~HTML_NONOSPACE;
print_tagq(p, t);
Index: mandoc_headers.3
===================================================================
RCS file: /home/cvs/mandoc/mandoc/mandoc_headers.3,v
retrieving revision 1.16
retrieving revision 1.17
diff -Lmandoc_headers.3 -Lmandoc_headers.3 -u -p -r1.16 -r1.17
--- mandoc_headers.3
+++ mandoc_headers.3
@@ -101,7 +101,6 @@ Provides
.Vt struct tbl_dat ,
.Vt struct tbl_span ,
.Vt struct eqn_box ,
-.Vt struct eqn ,
the function prototype typedef
.Fn mandocmsg ,
the function
@@ -267,8 +266,6 @@ from
for function prototypes.
Uses the types
.Vt struct tbl_span
-and
-.Vt struct eqn
from
.Pa mandoc.h
and
@@ -292,8 +289,6 @@ because the latter two are needed by
.Qq Pa roff.c .
.Pp
Uses the types
-.Vt struct eqn
-and
.Vt struct tbl_span
from
.Pa mandoc.h ,
@@ -378,7 +373,7 @@ for
for
.Vt struct tbl_*
and
-.Vt struct eqn ,
+.Vt struct eqn_box ,
and
.Qq Pa libmandoc.h
for
@@ -462,7 +457,7 @@ from
Uses
.Vt struct tbl_span
and
-.Vt struct eqn
+.Vt struct eqn_box
from
.Pa mandoc.h
and
@@ -503,7 +498,7 @@ and many HTML formatting functions.
Uses
.Vt struct tbl_span
and
-.Vt struct eqn
+.Vt struct eqn_box
from
.Pa mandoc.h
and
Index: roff.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/roff.c,v
retrieving revision 1.318
retrieving revision 1.319
diff -Lroff.c -Lroff.c -u -p -r1.318 -r1.319
--- roff.c
+++ roff.c
@@ -98,9 +98,8 @@ struct roff {
struct tbl_node *first_tbl; /* first table parsed */
struct tbl_node *last_tbl; /* last table parsed */
struct tbl_node *tbl; /* current table being parsed */
- struct eqn_node *last_eqn; /* last equation parsed */
- struct eqn_node *first_eqn; /* first equation parsed */
- struct eqn_node *eqn; /* current equation being parsed */
+ struct eqn_node *last_eqn; /* equation parser */
+ struct eqn_node *eqn; /* active equation parser */
int eqn_inline; /* current equation is inline */
int options; /* parse options */
int rstacksz; /* current size limit of rstack */
@@ -695,7 +694,6 @@ static void
roff_free1(struct roff *r)
{
struct tbl_node *tbl;
- struct eqn_node *e;
int i;
while (NULL != (tbl = r->first_tbl)) {
@@ -704,11 +702,9 @@ roff_free1(struct roff *r)
}
r->first_tbl = r->last_tbl = r->tbl = NULL;
- while (NULL != (e = r->first_eqn)) {
- r->first_eqn = e->next;
- eqn_free(e);
- }
- r->first_eqn = r->last_eqn = r->eqn = NULL;
+ if (r->last_eqn != NULL)
+ eqn_free(r->last_eqn);
+ r->last_eqn = r->eqn = NULL;
while (r->last)
roffnode_pop(r);
@@ -984,19 +980,6 @@ roff_body_alloc(struct roff_man *man, in
}
void
-roff_addeqn(struct roff_man *man, const struct eqn *eqn)
-{
- struct roff_node *n;
-
- n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);
- n->eqn = eqn;
- if (eqn->ln > man->last->line)
- n->flags |= NODE_LINE;
- roff_node_append(man, n);
- man->next = ROFF_NEXT_SIBLING;
-}
-
-void
roff_addtbl(struct roff_man *man, const struct tbl_span *tbl)
{
struct roff_node *n;
@@ -1055,6 +1038,8 @@ roff_node_free(struct roff_node *n)
mdoc_argv_free(n->args);
if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)
free(n->norm);
+ if (n->eqn != NULL)
+ eqn_box_free(n->eqn);
free(n->string);
free(n);
}
@@ -1512,8 +1497,10 @@ roff_parseln(struct roff *r, int ln, str
return e;
assert(e == ROFF_CONT);
}
- if (r->eqn != NULL)
- return eqn_read(&r->eqn, ln, buf->buf, ppos, offs);
+ if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) {
+ eqn_read(r->eqn, buf->buf + ppos);
+ return ROFF_IGN;
+ }
if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0'))
return tbl_read(r->tbl, ln, buf->buf, ppos);
if ( ! ctl)
@@ -1593,8 +1580,9 @@ roff_endparse(struct roff *r)
if (r->eqn) {
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
- r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ");
- eqn_end(&r->eqn);
+ r->eqn->node->line, r->eqn->node->pos, "EQ");
+ eqn_parse(r->eqn);
+ r->eqn = NULL;
}
if (r->tbl) {
@@ -2877,20 +2865,23 @@ roff_eqndelim(struct roff *r, struct buf
static enum rofferr
roff_EQ(ROFF_ARGS)
{
- struct eqn_node *e;
-
- assert(r->eqn == NULL);
- e = eqn_alloc(ppos, ln, r->parse);
+ struct roff_node *n;
- if (r->last_eqn) {
- r->last_eqn->next = e;
- e->delim = r->last_eqn->delim;
- e->odelim = r->last_eqn->odelim;
- e->cdelim = r->last_eqn->cdelim;
- } else
- r->first_eqn = r->last_eqn = e;
+ n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE);
+ if (ln > r->man->last->line)
+ n->flags |= NODE_LINE;
+ n->eqn = mandoc_calloc(1, sizeof(*n->eqn));
+ n->eqn->expectargs = UINT_MAX;
+ roff_node_append(r->man, n);
+ r->man->next = ROFF_NEXT_SIBLING;
- r->eqn = r->last_eqn = e;
+ assert(r->eqn == NULL);
+ if (r->last_eqn == NULL)
+ r->last_eqn = eqn_alloc(r->parse);
+ else
+ eqn_reset(r->last_eqn);
+ r->eqn = r->last_eqn;
+ r->eqn->node = n;
if (buf->buf[pos] != '\0')
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
@@ -2902,8 +2893,14 @@ roff_EQ(ROFF_ARGS)
static enum rofferr
roff_EN(ROFF_ARGS)
{
-
- mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
+ if (r->eqn != NULL) {
+ eqn_parse(r->eqn);
+ r->eqn = NULL;
+ } else
+ mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
+ if (buf->buf[pos] != '\0')
+ mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
+ "EN %s", buf->buf + pos);
return ROFF_IGN;
}
@@ -3608,13 +3605,6 @@ roff_span(const struct roff *r)
{
return r->tbl ? tbl_span(r->tbl) : NULL;
-}
-
-const struct eqn *
-roff_eqn(const struct roff *r)
-{
-
- return r->last_eqn ? &r->last_eqn->eqn : NULL;
}
/*
--
To unsubscribe send an email to source+unsubscribe@mandoc.bsd.lv
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2023-11-24 5:02 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-11-24 5:02 mandoc: 1 schwarze
-- strict thread matches above, loose matches on Subject: below --
2017-07-08 14:51 schwarze
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).