=================================================================== RCS file: /cvs/mandoc/roff.c,v retrieving revision 1.66 retrieving revision 1.67 diff -u -p -r1.66 -r1.67 --- mandoc/roff.c 2010/05/15 07:52:11 1.66 +++ mandoc/roff.c 2010/05/15 18:35:14 1.67 @@ -1,6 +1,6 @@ -/* $Id: roff.c,v 1.66 2010/05/15 07:52:11 kristaps Exp $ */ +/* $Id: roff.c,v 1.67 2010/05/15 18:35:14 kristaps Exp $ */ /* - * Copyright (c) 2008, 2009 Kristaps Dzonsons + * Copyright (c) 2010 Kristaps Dzonsons * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -18,7 +18,311 @@ #include "config.h" #endif +#include #include +#include +#include "mandoc.h" #include "roff.h" +enum rofft { + ROFF_de, + ROFF_dei, + ROFF_am, + ROFF_ami, + ROFF_ig, + ROFF_close, + ROFF_MAX +}; + +struct roff { + struct roffnode *last; /* leaf of stack */ + mandocmsg msg; /* err/warn/fatal messages */ + void *data; /* privdata for messages */ +}; + +struct roffnode { + enum rofft tok; /* type of node */ + struct roffnode *parent; /* up one in stack */ + int line; /* parse line */ + int col; /* parse col */ +}; + +#define ROFF_ARGS struct roff *r, /* parse ctx */ \ + char **bufp, /* input buffer */ \ + size_t *szp, /* size of input buffer */ \ + int ln, /* parse line */ \ + int ppos /* current pos in buffer */ + +typedef enum rofferr (*roffproc)(ROFF_ARGS); + +struct roffmac { + const char *name; /* macro name */ + roffproc sub; /* child of control black */ + roffproc new; /* root of stack (type = ROFF_MAX) */ +}; + +static enum rofferr roff_ignore(ROFF_ARGS); +static enum rofferr roff_new_close(ROFF_ARGS); +static enum rofferr roff_new_ig(ROFF_ARGS); +static enum rofferr roff_sub_ig(ROFF_ARGS); + +const struct roffmac roffs[ROFF_MAX] = { + { "de", NULL, roff_ignore }, + { "dei", NULL, roff_ignore }, + { "am", NULL, roff_ignore }, + { "ami", NULL, roff_ignore }, + { "ig", roff_sub_ig, roff_new_ig }, + { ".", NULL, roff_new_close }, +}; + +static void roff_alloc1(struct roff *); +static void roff_free1(struct roff *); +static enum rofft roff_hash_find(const char *); +static int roffnode_push(struct roff *, + enum rofft, int, int); +static void roffnode_pop(struct roff *); +static enum rofft roff_parse(const char *, int *); + + +/* + * Look up a roff token by its name. Returns ROFF_MAX if no macro by + * the nil-terminated string name could be found. + */ +static enum rofft +roff_hash_find(const char *p) +{ + int i; + + /* FIXME: make this be fast and efficient. */ + + for (i = 0; i < (int)ROFF_MAX; i++) + if (0 == strcmp(roffs[i].name, p)) + return((enum rofft)i); + + return(ROFF_MAX); +} + + +/* + * Pop the current node off of the stack of roff instructions currently + * pending. + */ +static void +roffnode_pop(struct roff *r) +{ + struct roffnode *p; + + if (NULL == (p = r->last)) + return; + r->last = p->parent; + free(p); +} + + +/* + * Push a roff node onto the instruction stack. This must later be + * removed with roffnode_pop(). + */ +static int +roffnode_push(struct roff *r, enum rofft tok, int line, int col) +{ + struct roffnode *p; + + if (NULL == (p = calloc(1, sizeof(struct roffnode)))) { + (*r->msg)(MANDOCERR_MEM, r->data, line, col, NULL); + return(0); + } + + p->tok = tok; + p->parent = r->last; + p->line = line; + p->col = col; + + r->last = p; + return(1); +} + + +static void +roff_free1(struct roff *r) +{ + + while (r->last) + roffnode_pop(r); +} + + +static void +roff_alloc1(struct roff *r) +{ + + memset(r, 0, sizeof(struct roff)); +} + + +void +roff_reset(struct roff *r) +{ + + roff_free1(r); + roff_alloc1(r); +} + + +void +roff_free(struct roff *r) +{ + + roff_free1(r); + free(r); +} + + +struct roff * +roff_alloc(const mandocmsg msg, void *data) +{ + struct roff *r; + + if (NULL == (r = calloc(1, sizeof(struct roff)))) { + (*msg)(MANDOCERR_MEM, data, 0, 0, NULL); + return(0); + } + + r->msg = msg; + r->data = data; + return(r); +} + + +enum rofferr +roff_parseln(struct roff *r, int ln, char **bufp, size_t *szp) +{ + enum rofft t; + int ppos; + + if (NULL != r->last) { + /* + * If there's a node on the stack, then jump directly + * into its processing function. + */ + t = r->last->tok; + assert(roffs[t].sub); + return((*roffs[t].sub)(r, bufp, szp, ln, 0)); + } else if ('.' != (*bufp)[0] && NULL == r->last) + /* Return when in free text without a context. */ + return(ROFF_CONT); + + /* There's nothing on the stack: make us anew. */ + + if (ROFF_MAX == (t = roff_parse(*bufp, &ppos))) + return(ROFF_CONT); + + assert(roffs[t].new); + return((*roffs[t].new)(r, bufp, szp, ln, ppos)); +} + + +/* + * 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) +{ + int j; + char mac[5]; + enum rofft t; + + assert('.' == buf[0]); + *pos = 1; + + while (buf[*pos] && (' ' == buf[*pos] || '\t' == buf[*pos])) + (*pos)++; + + if ('\0' == buf[*pos]) + return(ROFF_MAX); + + for (j = 0; j < 4; j++, (*pos)++) + if ('\0' == (mac[j] = buf[*pos])) + break; + else if (' ' == buf[*pos]) + break; + + if (j == 4 || j < 1) + return(ROFF_MAX); + + mac[j] = '\0'; + + if (ROFF_MAX == (t = roff_hash_find(mac))) + return(t); + + while (buf[*pos] && ' ' == buf[*pos]) + (*pos)++; + + return(t); +} + + +/* ARGSUSED */ +static enum rofferr +roff_ignore(ROFF_ARGS) +{ + + return(ROFF_IGN); +} + + +/* ARGSUSED */ +static enum rofferr +roff_sub_ig(ROFF_ARGS) +{ + enum rofft t; + int pos; + + /* Ignore free-text lines. */ + + if ('.' != (*bufp)[ppos]) + return(ROFF_IGN); + + /* Ignore macros unless it's a closing macro. */ + + t = roff_parse(*bufp, &pos); + if (ROFF_close != t) + return(ROFF_IGN); + + roffnode_pop(r); + return(ROFF_IGN); +} + + +/* ARGSUSED */ +static enum rofferr +roff_new_close(ROFF_ARGS) +{ + + if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) + return(ROFF_ERR); + return(ROFF_IGN); +} + + +/* ARGSUSED */ +static enum rofferr +roff_new_ig(ROFF_ARGS) +{ + + return(roffnode_push(r, ROFF_ig, ln, ppos) ? + ROFF_IGN : ROFF_ERR); +} + + +int +roff_endparse(struct roff *r) +{ + + if (NULL == r->last) + return(1); + return((*r->msg)(MANDOCERR_SCOPEEXIT, r->data, + r->last->line, r->last->col, NULL)); +}