* mandoc: The upcoming .while request will have to re-execute roff(7)
@ 2018-08-23 19:33 schwarze
0 siblings, 0 replies; only message in thread
From: schwarze @ 2018-08-23 19:33 UTC (permalink / raw)
To: source
Log Message:
-----------
The upcoming .while request will have to re-execute roff(7) lines
parsed earlier, so they will have to be saved for reuse - but the
read.c preparser does not know yet whether a line contains a .while
request before passing it to the roff parser. To cope with that,
save all parsed lines for now. Even shortens the code by 20 lines.
Modified Files:
--------------
mandoc:
libmandoc.h
main.c
main.h
man.c
man.h
mandoc.3
mandoc.h
mdoc_man.c
read.c
Revision Data
-------------
Index: mandoc.3
===================================================================
RCS file: /home/cvs/mandoc/mandoc/mandoc.3,v
retrieving revision 1.41
retrieving revision 1.42
diff -Lmandoc.3 -Lmandoc.3 -u -p -r1.41 -r1.42
--- mandoc.3
+++ mandoc.3
@@ -22,13 +22,11 @@
.Nm mandoc ,
.Nm deroff ,
.Nm mandocmsg ,
-.Nm man_mparse ,
.Nm man_validate ,
.Nm mdoc_validate ,
.Nm mparse_alloc ,
+.Nm mparse_copy ,
.Nm mparse_free ,
-.Nm mparse_getkeep ,
-.Nm mparse_keep ,
.Nm mparse_open ,
.Nm mparse_readfd ,
.Nm mparse_reset ,
@@ -65,13 +63,9 @@
.Fo mparse_free
.Fa "struct mparse *parse"
.Fc
-.Ft const char *
-.Fo mparse_getkeep
-.Fa "const struct mparse *parse"
-.Fc
.Ft void
-.Fo mparse_keep
-.Fa "struct mparse *parse"
+.Fo mparse_copy
+.Fa "const struct mparse *parse"
.Fc
.Ft int
.Fo mparse_open
@@ -126,10 +120,6 @@
.In mandoc.h
.In man.h
.Vt extern const char * const * man_macronames;
-.Ft "const struct mparse *"
-.Fo man_mparse
-.Fa "const struct roff_man *man"
-.Fc
.Ft void
.Fo man_validate
.Fa "struct roff_man *man"
@@ -250,12 +240,6 @@ When it is no longer needed, the pointer
.Fn deroff
can be passed to
.Xr free 3 .
-.It Fn man_mparse
-Get the parser used for the current output.
-Declared in
-.In man.h ,
-implemented in
-.Pa man.c .
.It Fn man_validate
Validate the
.Dv MACROSET_MAN
@@ -361,19 +345,9 @@ Declared in
.In mandoc.h ,
implemented in
.Pa read.c .
-.It Fn mparse_getkeep
-Acquire the keep buffer.
-Must follow a call of
-.Fn mparse_keep .
-Declared in
-.In mandoc.h ,
-implemented in
-.Pa read.c .
-.It Fn mparse_keep
-Instruct the parser to retain a copy of its parsed input.
-This can be acquired with subsequent
-.Fn mparse_getkeep
-calls.
+.It Fn mparse_copy
+Dump a copy of the input to the standard output; used for
+.Fl man T Ns Cm man .
Declared in
.In mandoc.h ,
implemented in
Index: man.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/man.h,v
retrieving revision 1.78
retrieving revision 1.79
diff -Lman.h -Lman.h -u -p -r1.78 -r1.79
--- man.h
+++ man.h
@@ -18,5 +18,4 @@
struct roff_man;
-const struct mparse *man_mparse(const struct roff_man *);
void man_validate(struct roff_man *);
Index: mandoc.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/mandoc.h,v
retrieving revision 1.250
retrieving revision 1.251
diff -Lmandoc.h -Lmandoc.h -u -p -r1.250 -r1.251
--- mandoc.h
+++ mandoc.h
@@ -462,7 +462,6 @@ const char *mchars_spec2str(const char
struct mparse *mparse_alloc(int, enum mandocerr, mandocmsg,
enum mandoc_os, const char *);
void mparse_free(struct mparse *);
-void mparse_keep(struct mparse *);
int mparse_open(struct mparse *, const char *);
enum mandoclevel mparse_readfd(struct mparse *, int, const char *);
enum mandoclevel mparse_readmem(struct mparse *, void *, size_t,
@@ -470,7 +469,7 @@ enum mandoclevel mparse_readmem(struct
void mparse_reset(struct mparse *);
void mparse_result(struct mparse *,
struct roff_man **, char **);
-const char *mparse_getkeep(const struct mparse *);
+void mparse_copy(const struct mparse *);
const char *mparse_strerror(enum mandocerr);
const char *mparse_strlevel(enum mandoclevel);
void mparse_updaterc(struct mparse *, enum mandoclevel *);
Index: libmandoc.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/libmandoc.h,v
retrieving revision 1.72
retrieving revision 1.73
diff -Llibmandoc.h -Llibmandoc.h -u -p -r1.72 -r1.73
--- libmandoc.h
+++ libmandoc.h
@@ -28,8 +28,9 @@ enum rofferr {
};
struct buf {
- char *buf;
- size_t sz;
+ char *buf;
+ size_t sz;
+ struct buf *next;
};
Index: man.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/man.c,v
retrieving revision 1.177
retrieving revision 1.178
diff -Lman.c -Lman.c -u -p -r1.177 -r1.178
--- man.c
+++ man.c
@@ -339,14 +339,6 @@ man_breakscope(struct roff_man *man, int
}
}
-const struct mparse *
-man_mparse(const struct roff_man *man)
-{
-
- assert(man && man->parse);
- return man->parse;
-}
-
void
man_state(struct roff_man *man, struct roff_node *n)
{
Index: mdoc_man.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/mdoc_man.c,v
retrieving revision 1.127
retrieving revision 1.128
diff -Lmdoc_man.c -Lmdoc_man.c -u -p -r1.127 -r1.128
--- mdoc_man.c
+++ mdoc_man.c
@@ -600,19 +600,6 @@ print_count(int *count)
}
void
-man_man(void *arg, const struct roff_man *man)
-{
-
- /*
- * Dump the keep buffer.
- * We're guaranteed by now that this exists (is non-NULL).
- * Flush stdout afterward, just in case.
- */
- fputs(mparse_getkeep(man_mparse(man)), stdout);
- fflush(stdout);
-}
-
-void
man_mdoc(void *arg, const struct roff_man *mdoc)
{
struct roff_node *n;
Index: read.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/read.c,v
retrieving revision 1.197
retrieving revision 1.198
diff -Lread.c -Lread.c -u -p -r1.197 -r1.198
--- read.c
+++ read.c
@@ -48,7 +48,7 @@ struct mparse {
char *sodest; /* filename pointed to by .so */
const char *file; /* filename of current input file */
struct buf *primary; /* buffer currently being parsed */
- struct buf *secondary; /* preprocessed copy of input */
+ struct buf *secondary; /* copy of top level input */
const char *os_s; /* default operating system */
mandocmsg mmsg; /* warning/error message handler */
enum mandoclevel file_status; /* status of current parse */
@@ -61,6 +61,7 @@ struct mparse {
};
static void choose_parser(struct mparse *);
+static void free_buf_list(struct buf *);
static void resize_buf(struct buf *, size_t);
static enum rofferr mparse_buf_r(struct mparse *, struct buf, size_t, int);
static int read_whole_file(struct mparse *, const char *, int,
@@ -290,6 +291,19 @@ resize_buf(struct buf *buf, size_t initi
}
static void
+free_buf_list(struct buf *buf)
+{
+ struct buf *tmp;
+
+ while (buf != NULL) {
+ tmp = buf;
+ buf = tmp->next;
+ free(tmp->buf);
+ free(tmp);
+ }
+}
+
+static void
choose_parser(struct mparse *curp)
{
char *cp, *ep;
@@ -346,19 +360,23 @@ static enum rofferr
mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
{
struct buf ln;
+ struct buf *firstln, *lastln, *thisln;
const char *save_file;
char *cp;
size_t pos; /* byte number in the ln buffer */
- enum rofferr line_result, sub_result;
+ enum rofferr line_result, result;
int of;
int lnn; /* line number in the real file */
int fd;
unsigned char c;
- memset(&ln, 0, sizeof(ln));
-
+ ln.sz = 256;
+ ln.buf = mandoc_malloc(ln.sz);
+ ln.next = NULL;
+ firstln = NULL;
lnn = curp->line;
pos = 0;
+ result = ROFF_CONT;
while (i < blk.sz) {
if (0 == pos && '\0' == blk.buf[i])
@@ -393,10 +411,10 @@ mparse_buf_r(struct mparse *curp, struct
/*
* Make sure we have space for the worst
- * case of 11 bytes: "\\[u10ffff]\0"
+ * case of 12 bytes: "\\[u10ffff]\n\0"
*/
- if (pos + 11 > ln.sz)
+ if (pos + 12 > ln.sz)
resize_buf(&ln, 256);
/*
@@ -432,13 +450,32 @@ mparse_buf_r(struct mparse *curp, struct
ln.buf[pos++] = blk.buf[i++];
}
+ ln.buf[pos] = '\0';
+
+ /*
+ * Maintain a lookaside buffer of all lines.
+ * parsed from this input source.
+ */
+
+ thisln = mandoc_malloc(sizeof(*thisln));
+ thisln->buf = mandoc_strdup(ln.buf);
+ thisln->sz = strlen(ln.buf) + 1;
+ thisln->next = NULL;
+ if (firstln == NULL) {
+ firstln = lastln = thisln;
+ if (curp->secondary == NULL)
+ curp->secondary = firstln;
+ } else {
+ lastln->next = thisln;
+ lastln = thisln;
+ }
- if (pos + 1 >= ln.sz)
- resize_buf(&ln, 256);
+ /* XXX Ugly hack to mark the end of the input. */
- if (i == blk.sz || blk.buf[i] == '\0')
+ if (i == blk.sz || blk.buf[i] == '\0') {
ln.buf[pos++] = '\n';
- ln.buf[pos] = '\0';
+ ln.buf[pos] = '\0';
+ }
/*
* A significant amount of complexity is contained by
@@ -450,27 +487,6 @@ mparse_buf_r(struct mparse *curp, struct
*/
of = 0;
-
- /*
- * Maintain a lookaside buffer of all parsed lines. We
- * only do this if mparse_keep() has been invoked (the
- * buffer may be accessed with mparse_getkeep()).
- */
-
- if (curp->secondary) {
- curp->secondary->buf = mandoc_realloc(
- curp->secondary->buf,
- curp->secondary->sz + pos + 2);
- memcpy(curp->secondary->buf +
- curp->secondary->sz,
- ln.buf, pos);
- curp->secondary->sz += pos;
- curp->secondary->buf
- [curp->secondary->sz] = '\n';
- curp->secondary->sz++;
- curp->secondary->buf
- [curp->secondary->sz] = '\0';
- }
rerun:
line_result = roff_parseln(curp->roff, curp->line, &ln, &of);
@@ -478,30 +494,29 @@ rerun:
case ROFF_REPARSE:
case ROFF_USERCALL:
if (++curp->reparse_count > REPARSE_LIMIT) {
- sub_result = ROFF_IGN;
+ result = ROFF_IGN;
mandoc_msg(MANDOCERR_ROFFLOOP, curp,
curp->line, pos, NULL);
} else {
- sub_result = mparse_buf_r(curp, ln, of, 0);
+ result = mparse_buf_r(curp, ln, of, 0);
if (line_result == ROFF_USERCALL) {
- if (sub_result == ROFF_USERRET)
- sub_result = ROFF_CONT;
+ if (result == ROFF_USERRET)
+ result = ROFF_CONT;
roff_userret(curp->roff);
}
- if (start || sub_result == ROFF_CONT) {
+ if (start || result == ROFF_CONT) {
pos = 0;
continue;
}
}
- free(ln.buf);
- return sub_result;
+ goto out;
case ROFF_USERRET:
if (start) {
pos = 0;
continue;
}
- free(ln.buf);
- return ROFF_USERRET;
+ result = ROFF_USERRET;
+ goto out;
case ROFF_APPEND:
pos = strlen(ln.buf);
continue;
@@ -514,16 +529,8 @@ rerun:
if ( ! (curp->options & MPARSE_SO) &&
(i >= blk.sz || blk.buf[i] == '\0')) {
curp->sodest = mandoc_strdup(ln.buf + of);
- free(ln.buf);
- return ROFF_CONT;
+ goto out;
}
- /*
- * We remove `so' clauses from our lookaside
- * buffer because we're going to descend into
- * the file recursively.
- */
- if (curp->secondary)
- curp->secondary->sz -= pos + 1;
save_file = curp->file;
if ((fd = mparse_open(curp, ln.buf + of)) != -1) {
mparse_readfd(curp, fd, ln.buf + of);
@@ -565,9 +572,11 @@ rerun:
pos = 0;
}
-
+out:
free(ln.buf);
- return ROFF_CONT;
+ if (firstln != curp->secondary)
+ free_buf_list(firstln);
+ return result;
}
static int
@@ -837,13 +846,12 @@ mparse_reset(struct mparse *curp)
{
roff_reset(curp->roff);
roff_man_reset(curp->man);
+ free_buf_list(curp->secondary);
+ curp->secondary = NULL;
free(curp->sodest);
curp->sodest = NULL;
- if (curp->secondary)
- curp->secondary->sz = 0;
-
curp->file_status = MANDOCLEVEL_OK;
curp->gzip = 0;
}
@@ -851,15 +859,11 @@ mparse_reset(struct mparse *curp)
void
mparse_free(struct mparse *curp)
{
-
roffhash_free(curp->man->mdocmac);
roffhash_free(curp->man->manmac);
roff_man_free(curp->man);
roff_free(curp->roff);
- if (curp->secondary)
- free(curp->secondary->buf);
-
- free(curp->secondary);
+ free_buf_list(curp->secondary);
free(curp->sodest);
free(curp);
}
@@ -932,17 +936,10 @@ mparse_strlevel(enum mandoclevel lvl)
}
void
-mparse_keep(struct mparse *p)
-{
-
- assert(NULL == p->secondary);
- p->secondary = mandoc_calloc(1, sizeof(struct buf));
-}
-
-const char *
-mparse_getkeep(const struct mparse *p)
+mparse_copy(const struct mparse *p)
{
+ struct buf *buf;
- assert(p->secondary);
- return p->secondary->sz ? p->secondary->buf : NULL;
+ for (buf = p->secondary; buf != NULL; buf = buf->next)
+ puts(buf->buf);
}
Index: main.h
===================================================================
RCS file: /home/cvs/mandoc/mandoc/main.h,v
retrieving revision 1.27
retrieving revision 1.28
diff -Lmain.h -Lmain.h -u -p -r1.27 -r1.28
--- main.h
+++ main.h
@@ -35,7 +35,6 @@ void tree_mdoc(void *, const struct r
void tree_man(void *, const struct roff_man *);
void man_mdoc(void *, const struct roff_man *);
-void man_man(void *, const struct roff_man *);
void *locale_alloc(const struct manoutput *);
void *utf8_alloc(const struct manoutput *);
Index: main.c
===================================================================
RCS file: /home/cvs/mandoc/mandoc/main.c,v
retrieving revision 1.307
retrieving revision 1.308
diff -Lmain.c -Lmain.c -u -p -r1.307 -r1.308
--- main.c
+++ main.c
@@ -486,12 +486,6 @@ main(int argc, char *argv[])
curp.mp = mparse_alloc(options, curp.mmin, mmsg,
curp.os_e, curp.os_s);
- /*
- * Conditionally start up the lookaside buffer before parsing.
- */
- if (OUTT_MAN == curp.outtype)
- mparse_keep(curp.mp);
-
if (argc < 1) {
if (use_pager)
tag_files = tag_init();
@@ -878,7 +872,7 @@ parse(struct curparse *curp, int fd, con
tree_man(curp->outdata, man);
break;
case OUTT_MAN:
- man_man(curp->outdata, man);
+ mparse_copy(curp->mp);
break;
case OUTT_PDF:
case OUTT_ASCII:
--
To unsubscribe send an email to source+unsubscribe@mandoc.bsd.lv
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2018-08-23 19:33 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-08-23 19:33 mandoc: The upcoming .while request will have to re-execute roff(7) 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).