mandoc/roff.c - diff

Return to roff.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/roff.c between version 1.99 and 1.130

version 1.99, 2010/08/24 12:48:43

version 1.130, 2011/03/29 09:00:48

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

* copyright notice and this permission notice appear in all copies.

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES

* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

Line 28

#include <stdio.h>

#include "mandoc.h"

#include "roff.h"

#include "libroff.h"

#include "libmandoc.h"

#define RSTACK_MAX 128

#define ROFF_CTL(c) \

('.' == (c) || '\'' == (c))

#if 1

#define ROFF_DEBUG(fmt, args...) \

do { /* Nothing. */ } while (/*CONSTCOND*/ 0)

#else

#define ROFF_DEBUG(fmt, args...) \

do { fprintf(stderr, fmt , ##args); } while (/*CONSTCOND*/ 0)

#endif

enum rofft {

ROFF_ad,

ROFF_am,

ROFF_ami,

ROFF_am1,

Line 53 enum rofft {

Line 43 enum rofft {

ROFF_de1,

ROFF_ds,

ROFF_el,

ROFF_hy,

ROFF_ie,

ROFF_if,

ROFF_ig,

ROFF_it,

ROFF_ne,

ROFF_nh,

ROFF_nr,

ROFF_ns,

ROFF_ps,

ROFF_rm,

ROFF_so,

ROFF_ta,

ROFF_tr,

ROFF_TS,

ROFF_TE,

ROFF_T_,

ROFF_EQ,

ROFF_EN,

ROFF_cblock,

ROFF_ccond,

ROFF_ccond, /* FIXME: remove this. */

ROFF_nr,

ROFF_USERDEF,

ROFF_MAX

};

Line 69 enum roffrule {

Line 73 enum roffrule {

ROFFRULE_DENY

};

struct roffstr {

char *name; /* key of symbol */

char *string; /* current value */

Line 77 struct roffstr {

Line 80 struct roffstr {

};

struct roff {

struct mparse *parse; /* parse point */

struct roffnode *last; /* leaf of stack */

mandocmsg msg; /* err/warn/fatal messages */

void *data; /* privdata for messages */

enum roffrule rstack[RSTACK_MAX]; /* stack of !`ie' rules */

int rstackpos; /* position in rstack */

struct regset *regs; /* read/writable registers */

struct roffstr *first_string;

struct roffstr *first_string; /* user-defined strings & macros */

const char *current_string; /* value of last called user macro */

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 roffnode {

Line 91 struct roffnode {

Line 100 struct roffnode {

struct roffnode *parent; /* up one in stack */

int line; /* parse line */

int col; /* parse col */

char *name; /* node name, e.g. macro name */

char *end; /* end-rules: custom token */

int endspan; /* end-rules: next-line or infty */

enum roffrule rule; /* current evaluation rule */

Line 128 static enum rofferr roff_cond_sub(ROFF_ARGS);

Line 138 static enum rofferr roff_cond_sub(ROFF_ARGS);

static enum rofferr roff_ds(ROFF_ARGS);

static enum roffrule roff_evalcond(const char *, int *);

static void roff_freestr(struct roff *);

static char *roff_getname(struct roff *, char **, int, int);

static const char *roff_getstrn(const struct roff *,

const char *, size_t);

static enum rofferr roff_line(ROFF_ARGS);

static enum rofferr roff_line_ignore(ROFF_ARGS);

static enum rofferr roff_nr(ROFF_ARGS);

static int roff_res(struct roff *,

char **, size_t *, int);

static enum rofferr roff_rm(ROFF_ARGS);

static void roff_setstr(struct roff *,

const char *, const char *);

const char *, const char *, int);

static char *roff_strdup(const char *);

static enum rofferr roff_so(ROFF_ARGS);

static enum rofferr roff_TE(ROFF_ARGS);

static enum rofferr roff_TS(ROFF_ARGS);

static enum rofferr roff_EQ(ROFF_ARGS);

static enum rofferr roff_EN(ROFF_ARGS);

static enum rofferr roff_T_(ROFF_ARGS);

static enum rofferr roff_userdef(ROFF_ARGS);

/* See roff_hash_find() */

Line 147 static char *roff_strdup(const char *);

Line 165 static char *roff_strdup(const char *);

static struct roffmac *hash[HASHWIDTH];

static struct roffmac roffs[ROFF_MAX] = {

{ "ad", roff_line_ignore, NULL, NULL, 0, NULL },

{ "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },

{ "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL },

{ "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },

Line 155 static struct roffmac roffs[ROFF_MAX] = {

Line 174 static struct roffmac roffs[ROFF_MAX] = {

{ "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },

{ "ds", roff_ds, NULL, NULL, 0, NULL },

{ "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },

{ "hy", roff_line_ignore, NULL, NULL, 0, NULL },

{ "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },

{ "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },

{ "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },

{ "rm", roff_line, NULL, NULL, 0, NULL },

{ "it", roff_line_ignore, NULL, NULL, 0, NULL },

{ "tr", roff_line, NULL, NULL, 0, NULL },

{ "ne", roff_line_ignore, NULL, NULL, 0, NULL },

{ "nh", roff_line_ignore, NULL, NULL, 0, NULL },

{ "nr", roff_nr, NULL, NULL, 0, NULL },

{ "ns", roff_line_ignore, NULL, NULL, 0, NULL },

{ "ps", roff_line_ignore, NULL, NULL, 0, NULL },

{ "rm", roff_rm, NULL, NULL, 0, NULL },

{ "so", roff_so, NULL, NULL, 0, NULL },

{ "ta", roff_line_ignore, NULL, NULL, 0, NULL },

{ "tr", roff_line_ignore, NULL, NULL, 0, NULL },

{ "TS", roff_TS, NULL, NULL, 0, NULL },

{ "TE", roff_TE, NULL, NULL, 0, NULL },

{ "T&", roff_T_, NULL, NULL, 0, NULL },

{ "EQ", roff_EQ, NULL, NULL, 0, NULL },

{ "EN", roff_EN, NULL, NULL, 0, NULL },

{ ".", roff_cblock, NULL, NULL, 0, NULL },

{ "\\}", roff_ccond, NULL, NULL, 0, NULL },

{ "nr", roff_nr, NULL, NULL, 0, NULL },

{ NULL, roff_userdef, NULL, NULL, 0, NULL },

};

static void roff_free1(struct roff *);

static enum rofft roff_hash_find(const char *);

static enum rofft roff_hash_find(const char *, size_t);

static void roff_hash_init(void);

static void roffnode_cleanscope(struct roff *);

static void roffnode_push(struct roff *,

static void roffnode_push(struct roff *, enum rofft,

enum rofft, int, int);

const char *, int, int);

static void roffnode_pop(struct roff *);

static enum rofft roff_parse(const char *, int *);

static enum rofft roff_parse(struct roff *, const char *, int *);

static int roff_parse_nat(const char *, unsigned int *);

/* See roff_hash_find() */

Line 184 roff_hash_init(void)

Line 217 roff_hash_init(void)

struct roffmac *n;

int buc, i;

for (i = 0; i < (int)ROFF_MAX; i++) {

for (i = 0; i < (int)ROFF_USERDEF; i++) {

assert(roffs[i].name[0] >= ASCII_LO);

assert(roffs[i].name[0] <= ASCII_HI);

Line 205 roff_hash_init(void)

Line 238 roff_hash_init(void)

* the nil-terminated string name could be found.

static enum rofft

roff_hash_find(const char *p)

roff_hash_find(const char *p, size_t s)

{

int buc;

struct roffmac *n;

Line 225 roff_hash_find(const char *p)

Line 258 roff_hash_find(const char *p)

if (NULL == (n = hash[buc]))

return(ROFF_MAX);

for ( ; n; n = n->next)

if (0 == strcmp(n->name, p))

if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s])

return((enum rofft)(n - roffs));

return(ROFF_MAX);

Line 249 roffnode_pop(struct roff *r)

Line 282 roffnode_pop(struct roff *r)

r->rstackpos--;

r->last = r->last->parent;

if (p->end)

free(p->name);

free(p->end);

free(p);

}

Line 260 roffnode_pop(struct roff *r)

Line 293 roffnode_pop(struct roff *r)

* removed with roffnode_pop().

static void

roffnode_push(struct roff *r, enum rofft tok, int line, int col)

roffnode_push(struct roff *r, enum rofft tok, const char *name,

int line, int col)

{

struct roffnode *p;

p = mandoc_calloc(1, sizeof(struct roffnode));

p->tok = tok;

if (name)

p->name = mandoc_strdup(name);

p->parent = r->last;

p->line = line;

p->col = col;

Line 278 roffnode_push(struct roff *r, enum rofft tok, int line

Line 314 roffnode_push(struct roff *r, enum rofft tok, int line

static void

roff_free1(struct roff *r)

{

struct tbl_node *t;

struct eqn_node *e;

while (NULL != (t = r->first_tbl)) {

r->first_tbl = t->next;

tbl_free(t);

}

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;

while (r->last)

roffnode_pop(r);

roff_freestr(r);

}

Line 303 roff_free(struct roff *r)

Line 356 roff_free(struct roff *r)

struct roff *

roff_alloc(struct regset *regs, void *data, const mandocmsg msg)

roff_alloc(struct regset *regs, struct mparse *parse)

{

struct roff *r;

r = mandoc_calloc(1, sizeof(struct roff));

r->regs = regs;

r->msg = msg;

r->parse = parse;

r->data = data;

r->rstackpos = -1;

roff_hash_init();

Line 326 roff_alloc(struct regset *regs, void *data, const mand

Line 378 roff_alloc(struct regset *regs, void *data, const mand

static int

roff_res(struct roff *r, char **bufp, size_t *szp, int pos)

{

const char *cp, *cpp, *st, *res;

const char *stesc; /* start of an escape sequence ('\\') */

const char *stnam; /* start of the name, after "[(*" */

const char *cp; /* end of the name, e.g. before ']' */

const char *res; /* the string to be substituted */

int i, maxl;

size_t nsz;

char *n;

/* LINTED */

/* Search for a leading backslash and save a pointer to it. */

for (cp = &(*bufp)[pos]; (cpp = strstr(cp, "\\*")); cp++) {

cp = cpp + 2;

cp = *bufp + pos;

while (NULL != (cp = strchr(cp, '\\'))) {

stesc = cp++;

* The second character must be an asterisk.

* If it isn't, skip it anyway: It is escaped,

* so it can't start another escape sequence.

if ('\0' == *cp)

return(1);

if ('*' != *cp++)

continue;

* The third character decides the length

* of the name of the string.

* Save a pointer to the name.

switch (*cp) {

case ('\0'):

return(1);

case ('('):

cp++;

maxl = 2;

Line 347 roff_res(struct roff *r, char **bufp, size_t *szp, int

Line 424 roff_res(struct roff *r, char **bufp, size_t *szp, int

maxl = 1;

break;

}

stnam = cp;

st = cp;

/* Advance to the end of the name. */

for (i = 0; 0 == maxl || i < maxl; i++, cp++) {

if ('\0' == *cp)

Line 357 roff_res(struct roff *r, char **bufp, size_t *szp, int

Line 435 roff_res(struct roff *r, char **bufp, size_t *szp, int

break;

}

res = roff_getstrn(r, st, (size_t)i);

* Retrieve the replacement string; if it is

* undefined, resume searching for escapes.

res = roff_getstrn(r, stnam, (size_t)i);

if (NULL == res) {

cp -= maxl ? 1 : 0;

continue;

}

ROFF_DEBUG("roff: splicing reserved: [%.*s]\n", i, st);

/* Replace the escape sequence by the string. */

nsz = *szp + strlen(res) + 1;

n = mandoc_malloc(nsz);

*n = '\0';

strlcpy(n, *bufp, (size_t)(stesc - *bufp + 1));

strlcat(n, *bufp, (size_t)(cpp - *bufp + 1));

strlcat(n, res, nsz);

strlcat(n, cp + (maxl ? 0 : 1), nsz);

Line 391 roff_parseln(struct roff *r, int ln, char **bufp,

Line 472 roff_parseln(struct roff *r, int ln, char **bufp,

size_t *szp, int pos, int *offs)

{

enum rofft t;

int ppos;

enum rofferr e;

int ppos, ctl;

* Run the reserved-word filter only if we have some reserved

Line 399 roff_parseln(struct roff *r, int ln, char **bufp,

Line 481 roff_parseln(struct roff *r, int ln, char **bufp,

if (r->first_string && ! roff_res(r, bufp, szp, pos))

return(ROFF_RERUN);

return(ROFF_REPARSE);

ppos = pos;

ctl = mandoc_getcontrol(*bufp, &pos);

* First, if a scope is open and we're not a macro, pass the

* text through the macro's filter. If a scope isn't open and

* we're not a macro, just let it through.

* Finally, if there's an equation scope open, divert it into it

* no matter our state.

if (r->last && ! ROFF_CTL((*bufp)[pos])) {

if (r->last && ! ctl) {

t = r->last->tok;

assert(roffs[t].text);

ROFF_DEBUG("roff: intercept scoped text: %s, [%s]\n",

e = (*roffs[t].text)

roffs[t].name, &(*bufp)[pos]);

(r, t, bufp, szp, ln, pos, pos, offs);

return((*roffs[t].text)

assert(ROFF_IGN == e || ROFF_CONT == e);

(r, t, bufp, szp,

if (ROFF_CONT != e)

ln, pos, pos, offs));

return(e);

} else if ( ! ROFF_CTL((*bufp)[pos]))

if (r->eqn)

return(eqn_read(&r->eqn, ln, *bufp, pos));

if (r->tbl)

return(tbl_read(r->tbl, ln, *bufp, pos));

return(ROFF_CONT);

} else if ( ! ctl) {

if (r->eqn)

return(eqn_read(&r->eqn, ln, *bufp, pos));

if (r->tbl)

return(tbl_read(r->tbl, ln, *bufp, pos));

return(ROFF_CONT);

} else if (r->eqn)

return(eqn_read(&r->eqn, ln, *bufp, ppos));

* If a scope is open, go to the child handler for that macro,

* as it may want to preprocess before doing anything with it.

* Don't do so if an equation is open.

if (r->last) {

t = r->last->tok;

assert(roffs[t].sub);

ROFF_DEBUG("roff: intercept scoped context: %s\n",

roffs[t].name);

return((*roffs[t].sub)

(r, t, bufp, szp,

ln, pos, pos, offs));

ln, ppos, pos, offs));

}

Line 439 roff_parseln(struct roff *r, int ln, char **bufp,

Line 536 roff_parseln(struct roff *r, int ln, char **bufp,

* the compilers handle it.

ppos = pos;

if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos)))

if (ROFF_MAX == (t = roff_parse(*bufp, &pos)))

return(ROFF_CONT);

ROFF_DEBUG("roff: intercept new-scope: %s, [%s]\n",

roffs[t].name, &(*bufp)[pos]);

assert(roffs[t].proc);

return((*roffs[t].proc)

(r, t, bufp, szp,

Line 452 roff_parseln(struct roff *r, int ln, char **bufp,

Line 546 roff_parseln(struct roff *r, int ln, char **bufp,

}

int

void

roff_endparse(struct roff *r)

{

if (NULL == r->last)

if (r->last)

return(1);

mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse,

return((*r->msg)(MANDOCERR_SCOPEEXIT, r->data, r->last->line,

r->last->line, r->last->col, NULL);

r->last->col, NULL));

}

if (r->eqn) {

mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse,

r->eqn->eqn.line, r->eqn->eqn.pos, NULL);

eqn_end(r->eqn);

r->eqn = NULL;

}

if (r->tbl) {

mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse,

r->tbl->line, r->tbl->pos, NULL);

tbl_end(r->tbl);

r->tbl = NULL;

}

* Parse a roff node's type from the input buffer. This must be in the

* form of ".foo xxx" in the usual way.

static enum rofft

roff_parse(const char *buf, int *pos)

roff_parse(struct roff *r, const char *buf, int *pos)

{

int j;

const char *mac;

char mac[5];

size_t maclen;

enum rofft t;

assert(ROFF_CTL(buf[*pos]));

if ('\0' == buf[*pos] || '"' == buf[*pos])

(*pos)++;

while (buf[*pos] && (' ' == buf[*pos] || '\t' == buf[*pos]))

(*pos)++;

if ('\0' == buf[*pos])

return(ROFF_MAX);

for (j = 0; j < 4; j++, (*pos)++)

mac = buf + *pos;

if ('\0' == (mac[j] = buf[*pos]))

maclen = strcspn(mac, " \\\t\0");

break;

else if (' ' == buf[*pos] || (j && '\\' == buf[*pos]))

break;

if (j == 4 || j < 1)

t = (r->current_string = roff_getstrn(r, mac, maclen))

return(ROFF_MAX);

? ROFF_USERDEF : roff_hash_find(mac, maclen);

mac[j] = '\0';

*pos += (int)maclen;

if (ROFF_MAX == (t = roff_hash_find(mac)))

return(t);

while (buf[*pos] && ' ' == buf[*pos])

(*pos)++;

Line 535 roff_cblock(ROFF_ARGS)

Line 629 roff_cblock(ROFF_ARGS)

if (NULL == r->last) {

if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

return(ROFF_ERR);

return(ROFF_IGN);

}

Line 548 roff_cblock(ROFF_ARGS)

Line 641 roff_cblock(ROFF_ARGS)

case (ROFF_am1):

/* FALLTHROUGH */

case (ROFF_de):

/* ROFF_de1 is remapped to ROFF_de in roff_block(). */

/* FALLTHROUGH */

case (ROFF_dei):

/* FALLTHROUGH */

case (ROFF_de1):

/* FALLTHROUGH */

case (ROFF_ig):

break;

default:

if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

return(ROFF_ERR);

return(ROFF_IGN);

}

if ((*bufp)[pos])

if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))

mandoc_msg(MANDOCERR_ARGSLOST, r->parse, ln, pos, NULL);

return(ROFF_ERR);

roffnode_pop(r);

roffnode_cleanscope(r);

Line 590 roff_ccond(ROFF_ARGS)

Line 680 roff_ccond(ROFF_ARGS)

{

if (NULL == r->last) {

if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

return(ROFF_ERR);

return(ROFF_IGN);

}

Line 603 roff_ccond(ROFF_ARGS)

Line 692 roff_ccond(ROFF_ARGS)

case (ROFF_if):

break;

default:

if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

return(ROFF_ERR);

return(ROFF_IGN);

}

if (r->last->endspan > -1) {

if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

return(ROFF_ERR);

return(ROFF_IGN);

}

if ((*bufp)[pos])

if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))

mandoc_msg(MANDOCERR_ARGSLOST, r->parse, ln, pos, NULL);

return(ROFF_ERR);

roffnode_pop(r);

roffnode_cleanscope(r);

Line 630 roff_block(ROFF_ARGS)

Line 716 roff_block(ROFF_ARGS)

{

int sv;

size_t sz;

char *name;

if (ROFF_ig != tok && '\0' == (*bufp)[pos]) {

name = NULL;

if ( ! (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL))

return(ROFF_ERR);

if (ROFF_ig != tok) {

return(ROFF_IGN);

if ('\0' == (*bufp)[pos]) {

} else if (ROFF_ig != tok) {

mandoc_msg(MANDOCERR_NOARGS, r->parse, ln, ppos, NULL);

return(ROFF_IGN);

}

* Re-write `de1', since we don't really care about

* groff's strange compatibility mode, into `de'.

if (ROFF_de1 == tok)

tok = ROFF_de;

if (ROFF_de == tok)

name = *bufp + pos;

else

mandoc_msg(MANDOCERR_REQUEST, r->parse, ln, ppos,

roffs[tok].name);

while ((*bufp)[pos] && ' ' != (*bufp)[pos])

pos++;

while (' ' == (*bufp)[pos])

pos++;

(*bufp)[pos++] = '\0';

}

roffnode_push(r, tok, ln, ppos);

roffnode_push(r, tok, name, ln, ppos);

* At the beginning of a `de' macro, clear the existing string

* with the same name, if there is one. New content will be

* added from roff_block_text() in multiline mode.

if (ROFF_de == tok)

roff_setstr(r, name, "", 0);

if ('\0' == (*bufp)[pos])

return(ROFF_IGN);

/* If present, process the custom end-of-line marker. */

sv = pos;

while ((*bufp)[pos] && ' ' != (*bufp)[pos] &&

while ((*bufp)[pos] &&

' ' != (*bufp)[pos] &&

'\t' != (*bufp)[pos])

pos++;

Line 670 roff_block(ROFF_ARGS)

Line 786 roff_block(ROFF_ARGS)

r->last->end[(int)sz] = '\0';

if ((*bufp)[pos])

if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))

mandoc_msg(MANDOCERR_ARGSLOST, r->parse, ln, pos, NULL);

return(ROFF_ERR);

return(ROFF_IGN);

}

Line 694 roff_block_sub(ROFF_ARGS)

Line 809 roff_block_sub(ROFF_ARGS)

if (r->last->end) {

i = pos + 1;

for (i = pos, j = 0; r->last->end[j]; j++, i++)

while (' ' == (*bufp)[i] || '\t' == (*bufp)[i])

i++;

for (j = 0; r->last->end[j]; j++, i++)

if ((*bufp)[i] != r->last->end[j])

break;

Line 709 roff_block_sub(ROFF_ARGS)

Line 820 roff_block_sub(ROFF_ARGS)

roffnode_pop(r);

roffnode_cleanscope(r);

if (ROFF_MAX != roff_parse(*bufp, &pos))

while (' ' == (*bufp)[i] || '\t' == (*bufp)[i])

i++;

pos = i;

if (ROFF_MAX != roff_parse(r, *bufp, &pos))

return(ROFF_RERUN);

return(ROFF_IGN);

}

Line 720 roff_block_sub(ROFF_ARGS)

Line 835 roff_block_sub(ROFF_ARGS)

* pulling it out of the hashtable.

ppos = pos;

if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos)))

t = roff_parse(*bufp, &pos);

return(ROFF_IGN);

/* If we're not a comment-end, then throw it away. */

if (ROFF_cblock != t)

* Macros other than block-end are only significant

* in `de' blocks; elsewhere, simply throw them away.

if (ROFF_cblock != t) {

if (ROFF_de == tok)

roff_setstr(r, r->last->name, *bufp + ppos, 1);

return(ROFF_IGN);

}

assert(roffs[t].proc);

return((*roffs[t].proc)(r, t, bufp, szp,

Line 738 static enum rofferr

Line 859 static enum rofferr

roff_block_text(ROFF_ARGS)

{

if (ROFF_de == tok)

roff_setstr(r, r->last->name, *bufp + pos, 1);

return(ROFF_IGN);

}

Line 748 roff_cond_sub(ROFF_ARGS)

Line 872 roff_cond_sub(ROFF_ARGS)

{

enum rofft t;

enum roffrule rr;

struct roffnode *l;

ppos = pos;

rr = r->last->rule;

Line 758 roff_cond_sub(ROFF_ARGS)

Line 880 roff_cond_sub(ROFF_ARGS)

* continue.

l = r->last;

roffnode_cleanscope(r);

if (l != r->last)

if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos))) {

if ('\\' == (*bufp)[pos] && '}' == (*bufp)[pos + 1])

return(roff_ccond

(r, ROFF_ccond, bufp, szp,

ln, pos, pos + 2, offs));

return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);

}

if (ROFF_MAX == (t = roff_parse(*bufp, &pos)))

return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);

* A denied conditional must evaluate its children if and only

* if they're either structurally required (such as loops and

Line 797 roff_cond_text(ROFF_ARGS)

Line 920 roff_cond_text(ROFF_ARGS)

* scope permits us to do so.

/* FIXME: use roff_ccond? */

st = &(*bufp)[pos];

if (NULL == (ep = strstr(st, "\\}"))) {

roffnode_cleanscope(r);

Line 835 roff_evalcond(const char *v, int *pos)

Line 960 roff_evalcond(const char *v, int *pos)

return(ROFFRULE_DENY);

}

/* ARGSUSED */

static enum rofferr

roff_line(ROFF_ARGS)

roff_line_ignore(ROFF_ARGS)

{

if (ROFF_it == tok)

mandoc_msg(MANDOCERR_REQUEST, r->parse, ln, ppos, "it");

return(ROFF_IGN);

}

/* ARGSUSED */

static enum rofferr

roff_cond(ROFF_ARGS)

Line 855 roff_cond(ROFF_ARGS)

Line 981 roff_cond(ROFF_ARGS)

/* Stack overflow! */

if (ROFF_ie == tok && r->rstackpos == RSTACK_MAX - 1) {

(*r->msg)(MANDOCERR_MEM, r->data, ln, ppos, NULL);

mandoc_msg(MANDOCERR_MEM, r->parse, ln, ppos, NULL);

return(ROFF_ERR);

}

Line 886 roff_cond(ROFF_ARGS)

Line 1012 roff_cond(ROFF_ARGS)

if ('\0' == (*bufp)[pos] && sv != pos) {

if ((*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL))

mandoc_msg(MANDOCERR_NOARGS, r->parse, ln, ppos, NULL);

return(ROFF_IGN);

return(ROFF_ERR);

}

roffnode_push(r, tok, ln, ppos);

roffnode_push(r, tok, NULL, ln, ppos);

r->last->rule = rule;

ROFF_DEBUG("roff: cond: %s -> %s\n", roffs[tok].name,

ROFFRULE_ALLOW == rule ? "allow" : "deny");

if (ROFF_ie == tok) {

* An if-else will put the NEGATION of the current

Line 912 roff_cond(ROFF_ARGS)

Line 1034 roff_cond(ROFF_ARGS)

/* If the parent has false as its rule, then so do we. */

if (r->last->parent && ROFFRULE_DENY == r->last->parent->rule) {

if (r->last->parent && ROFFRULE_DENY == r->last->parent->rule)

r->last->rule = ROFFRULE_DENY;

ROFF_DEBUG("roff: cond override: %s -> deny\n",

roffs[tok].name);

}

* Determine scope. If we're invoked with "\{" trailing the

Line 929 roff_cond(ROFF_ARGS)

Line 1048 roff_cond(ROFF_ARGS)

if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) {

r->last->endspan = -1;

pos += 2;

ROFF_DEBUG("roff: cond-scope: %s, multi-line\n",

}

roffs[tok].name);

} else

ROFF_DEBUG("roff: cond-scope: %s, one-line\n",

roffs[tok].name);

* If there are no arguments on the line, the next-line scope is

Line 966 roff_ds(ROFF_ARGS)

Line 1081 roff_ds(ROFF_ARGS)

* will have `bar " ' as its value.

name = *bufp + pos;

string = *bufp + pos;

name = roff_getname(r, &string, ln, pos);

if ('\0' == *name)

return(ROFF_IGN);

string = name;

/* Read past initial double-quote. */

/* Read until end of name. */

if ('"' == *string)

while (*string && ' ' != *string)

string++;

/* Nil-terminate name. */

if (*string)

*(string++) = '\0';

/* Read past spaces. */

while (*string && ' ' == *string)

string++;

/* Read passed initial double-quote. */

if (*string && '"' == *string)

string++;

/* The rest is the value. */

roff_setstr(r, name, string);

roff_setstr(r, name, string, 0);

return(ROFF_IGN);

}

Line 997 roff_ds(ROFF_ARGS)

Line 1100 roff_ds(ROFF_ARGS)

static enum rofferr

roff_nr(ROFF_ARGS)

{

const char *key, *val;

const char *key;

char *val;

struct reg *rg;

key = &(*bufp)[pos];

val = *bufp + pos;

key = roff_getname(r, &val, ln, pos);

rg = r->regs->regs;

/* Parse register request. */

if (0 == strcmp(key, "nS")) {

while ((*bufp)[pos] && ' ' != (*bufp)[pos])

rg[(int)REG_nS].set = 1;

pos++;

if ( ! roff_parse_nat(val, &rg[(int)REG_nS].v.u))

rg[(int)REG_nS].v.u = 0;

}

return(ROFF_IGN);

* Set our nil terminator. Because this line is going to be

}

* ignored anyway, we can munge it as we please.

if ((*bufp)[pos])

(*bufp)[pos++] = '\0';

/* Skip whitespace to register token. */

/* ARGSUSED */

while ((*bufp)[pos] && ' ' == (*bufp)[pos])

static enum rofferr

pos++;

roff_rm(ROFF_ARGS)

{

const char *name;

char *cp;

val = &(*bufp)[pos];

cp = *bufp + pos;

while ('\0' != *cp) {

name = roff_getname(r, &cp, ln, (int)(cp - *bufp));

if ('\0' != *name)

roff_setstr(r, name, NULL, 0);

}

return(ROFF_IGN);

}

/* Process register token. */

/* ARGSUSED */

static enum rofferr

roff_TE(ROFF_ARGS)

{

if (0 == strcmp(key, "nS")) {

if (NULL == r->tbl)

rg[(int)REG_nS].set = 1;

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

if ( ! roff_parse_nat(val, &rg[(int)REG_nS].v.u))

else

rg[(int)REG_nS].v.u = 0;

tbl_end(r->tbl);

ROFF_DEBUG("roff: register nS: %u\n",

r->tbl = NULL;

rg[(int)REG_nS].v.u);

return(ROFF_IGN);

} else

}

ROFF_DEBUG("roff: ignoring register: %s\n", key);

/* ARGSUSED */

static enum rofferr

roff_T_(ROFF_ARGS)

{

if (NULL == r->tbl)

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

else

tbl_restart(ppos, ln, r->tbl);

return(ROFF_IGN);

}

/* ARGSUSED */

static enum rofferr

roff_EQ(ROFF_ARGS)

{

struct eqn_node *e;

static char *

assert(NULL == r->eqn);

roff_strdup(const char *name)

e = eqn_alloc(ppos, ln);

if (r->last_eqn)

r->last_eqn->next = e;

else

r->first_eqn = r->last_eqn = e;

r->eqn = r->last_eqn = e;

return(ROFF_IGN);

}

/* ARGSUSED */

static enum rofferr

roff_EN(ROFF_ARGS)

{

char *namecopy, *sv;

mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);

* This isn't a nice simple mandoc_strdup() because we must

return(ROFF_IGN);

* handle roff's stupid double-escape rule.

}

/* ARGSUSED */

static enum rofferr

roff_TS(ROFF_ARGS)

{

struct tbl_node *t;

if (r->tbl) {

mandoc_msg(MANDOCERR_SCOPEBROKEN, r->parse, ln, ppos, NULL);

tbl_end(r->tbl);

}

t = tbl_alloc(ppos, ln, r->parse);

if (r->last_tbl)

r->last_tbl->next = t;

else

r->first_tbl = r->last_tbl = t;

r->tbl = r->last_tbl = t;

return(ROFF_IGN);

}

/* ARGSUSED */

static enum rofferr

roff_so(ROFF_ARGS)

{

char *name;

mandoc_msg(MANDOCERR_SO, r->parse, ln, ppos, NULL);

* Handle `so'. Be EXTREMELY careful, as we shouldn't be

* opening anything that's not in our cwd or anything beneath

* it. Thus, explicitly disallow traversing up the file-system

* or using absolute paths.

sv = namecopy = mandoc_malloc(strlen(name) + 1);

while (*name) {

name = *bufp + pos;

if ('\\' == *name && '\\' == *(name + 1))

if ('/' == *name || strstr(name, "../") || strstr(name, "/..")) {

name++;

mandoc_msg(MANDOCERR_SOPATH, r->parse, ln, pos, NULL);

*namecopy++ = *name++;

return(ROFF_ERR);

}

*namecopy = '\0';

*offs = pos;

return(sv);

return(ROFF_SO);

}

/* ARGSUSED */

static enum rofferr

roff_userdef(ROFF_ARGS)

{

const char *arg[9];

char *cp, *n1, *n2;

int i;

* Collect pointers to macro argument strings

* and null-terminate them.

cp = *bufp + pos;

for (i = 0; i < 9; i++)

arg[i] = '\0' == *cp ? "" :

mandoc_getarg(r->parse, &cp, ln, &pos);

* Expand macro arguments.

*szp = 0;

n1 = cp = mandoc_strdup(r->current_string);

while (NULL != (cp = strstr(cp, "\\$"))) {

i = cp[2] - '1';

if (0 > i || 8 < i) {

/* Not an argument invocation. */

cp += 2;

continue;

}

*szp = strlen(n1) - 3 + strlen(arg[i]) + 1;

n2 = mandoc_malloc(*szp);

strlcpy(n2, n1, (size_t)(cp - n1 + 1));

strlcat(n2, arg[i], *szp);

strlcat(n2, cp + 3, *szp);

cp = n2 + (cp - n1);

free(n1);

n1 = n2;

}

* Replace the macro invocation

* by the expanded macro.

free(*bufp);

*bufp = n1;

if (0 == *szp)

*szp = strlen(*bufp) + 1;

return(*szp > 1 && '\n' == (*bufp)[(int)*szp - 2] ?

ROFF_REPARSE : ROFF_APPEND);

}

static char *

roff_getname(struct roff *r, char **cpp, int ln, int pos)

{

char *name, *cp;

name = *cpp;

if ('\0' == *name)

return(name);

/* Read until end of name. */

for (cp = name; '\0' != *cp && ' ' != *cp; cp++) {

if ('\\' != *cp)

continue;

cp++;

if ('\\' == *cp)

continue;

mandoc_msg(MANDOCERR_NAMESC, r->parse, ln, pos, NULL);

*cp = '\0';

name = cp;

}

/* Nil-terminate name. */

if ('\0' != *cp)

*(cp++) = '\0';

/* Read past spaces. */

while (' ' == *cp)

cp++;

*cpp = cp;

return(name);

}

* Store *string into the user-defined string called *name.

* In multiline mode, append to an existing entry and append '\n';

* else replace the existing entry, if there is one.

* To clear an existing entry, call with (*r, *name, NULL, 0).

static void

roff_setstr(struct roff *r, const char *name, const char *string)

roff_setstr(struct roff *r, const char *name, const char *string,

int multiline)

{

struct roffstr *n;

char *namecopy;

char *c;

size_t oldch, newch;

/* Search for an existing string with the same name. */

n = r->first_string;

while (n && strcmp(name, n->name))

n = n->next;

if (NULL == n) {

namecopy = mandoc_strdup(name);

/* Create a new string table entry. */

n = mandoc_malloc(sizeof(struct roffstr));

n->name = namecopy;

n->name = mandoc_strdup(name);

n->string = NULL;

n->next = r->first_string;

r->first_string = n;

} else

} else if (0 == multiline) {

/* In multiline mode, append; else replace. */

free(n->string);

n->string = NULL;

}

/* Don't use mandoc_strdup: clean out double-escapes. */

if (NULL == string)

n->string = string ? roff_strdup(string) : NULL;

return;

ROFF_DEBUG("roff: new symbol: [%s] = [%s]\n", name, n->string);

}

* One additional byte for the '\n' in multiline mode,

* and one for the terminating '\0'.

newch = strlen(string) + (multiline ? 2u : 1u);

if (NULL == n->string) {

n->string = mandoc_malloc(newch);

*n->string = '\0';

oldch = 0;

} else {

oldch = strlen(n->string);

n->string = mandoc_realloc(n->string, oldch + newch);

}

/* Skip existing content in the destination buffer. */

c = n->string + (int)oldch;

/* Append new content to the destination buffer. */

while (*string) {

* Rudimentary roff copy mode:

* Handle escaped backslashes.

if ('\\' == *string && '\\' == *(string + 1))

string++;

*c++ = *string++;

}

/* Append terminating bytes. */

if (multiline)

*c++ = '\n';

*c = '\0';

}

static const char *

roff_getstrn(const struct roff *r, const char *name, size_t len)

{

Line 1094 roff_getstrn(const struct roff *r, const char *name, s

Line 1403 roff_getstrn(const struct roff *r, const char *name, s

return(n ? n->string : NULL);

}

static void

roff_freestr(struct roff *r)

{

Line 1108 roff_freestr(struct roff *r)

Line 1416 roff_freestr(struct roff *r)

}

r->first_string = NULL;

}

const struct tbl_span *

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);

}

CVSweb