File: [cvsweb.bsd.lv] / mandoc / Attic / mlg.c (download)
Revision 1.17, Sun Dec 7 14:38:57 2008 UTC (15 years, 5 months ago) by kristaps
Branch: MAIN
Changes since 1.16: +34 -12 lines
*** empty log message ***
|
/* $Id: mlg.c,v 1.17 2008/12/07 14:38:57 kristaps Exp $ */
/*
* Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
*
* 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 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR 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 OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include <assert.h>
#include <ctype.h>
#include <err.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "libmdocml.h"
#include "private.h"
#include "ml.h"
/* TODO: literal tokens. */
#define COLUMNS 72
#define INDENT 4
#define MAXINDENT 10
enum md_tok {
MD_TEXT,
MD_INLINE_IN,
MD_INLINE_OUT,
MD_BLK_IN,
MD_BLK_OUT,
};
struct md_mlg {
const struct md_args *args;
const struct md_rbuf *rbuf;
struct md_mbuf *mbuf;
struct rofftree *tree;
size_t indent;
size_t pos;
enum md_tok last;
void *arg;
struct ml_cbs cbs;
int flags;
#define ML_OVERRIDE_ONE (1 << 0)
#define ML_OVERRIDE_ALL (1 << 1)
void *data;
};
static char *mlg_literal(int);
static char *mlg_At_literal(const char *);
static char *mlg_fmt(int);
static char *mlg_St_literal(int);
static void mlg_roffmsg(void *arg, enum roffmsg,
const char *, const char *, char *);
static int mlg_roffhead(void *, const struct tm *,
const char *, const char *,
const char *, const char *);
static int mlg_rofftail(void *);
static int mlg_roffin(void *, int, int *, char **);
static int mlg_roffdata(void *, int,
const char *, char *);
static int mlg_roffout(void *, int);
static int mlg_roffblkin(void *, int, int *, char **);
static int mlg_roffblkout(void *, int);
static int mlg_roffspecial(void *, int,
const char *, const int *,
const char **, char **);
static int mlg_roffblkheadin(void *, int,
int *, char **);
static int mlg_roffblkheadout(void *, int);
static int mlg_roffblkbodyin(void *, int,
int *, char **);
static int mlg_roffblkbodyout(void *, int);
static int mlg_begintag(struct md_mlg *, enum md_ns,
int, int *, char **);
static int mlg_endtag(struct md_mlg *, enum md_ns, int);
static int mlg_indent(struct md_mlg *);
static int mlg_newline(struct md_mlg *);
static void mlg_mode(struct md_mlg *, enum md_tok);
static int mlg_data(struct md_mlg *, int,
const char *, char *);
static void mlg_err(struct md_mlg *, const char *,
const char *, const char *, ...);
static void mlg_warn(struct md_mlg *, const char *,
const char *, const char *, ...);
static void mlg_msg(struct md_mlg *, enum roffmsg,
const char *, const char *, char *);
static void mlg_vmsg(struct md_mlg *, enum roffmsg,
const char *, const char *,
const char *, va_list);
#ifdef __linux__
extern size_t strlcat(char *, const char *, size_t);
extern size_t strlcpy(char *, const char *, size_t);
#endif
static char *
mlg_St_literal(int argc)
{
switch (argc) {
case(ROFF_p1003_1_88):
return("IEEE Std 1003.1-1988 (“POSIX”)");
case(ROFF_p1003_1_90):
return("IEEE Std 1003.1-1990 (“POSIX”)");
case(ROFF_p1003_1_96):
return("ISO/IEC 9945-1:1996 (“POSIX”)");
case(ROFF_p1003_1_2001):
return("IEEE Std 1003.1-2001 (“POSIX”)");
case(ROFF_p1003_1_2004):
return("IEEE Std 1003.1-2004 (“POSIX”)");
case(ROFF_p1003_1):
return("IEEE Std 1003.1 (“POSIX”)");
case(ROFF_p1003_1b):
return("IEEE Std 1003.1b (“POSIX”)");
case(ROFF_p1003_1b_93):
return("IEEE Std 1003.1b-1993 (“POSIX”)");
case(ROFF_p1003_1c_95):
return("IEEE Std 1003.1c-1995 (“POSIX”)");
case(ROFF_p1003_1g_2000):
return("IEEE Std 1003.1g-2000 (“POSIX”)");
case(ROFF_p1003_2_92):
return("IEEE Std 1003.2-1992 (“POSIX.2”)");
case(ROFF_p1387_2_95):
return("IEEE Std 1387.2-1995 (“POSIX.7.2”)");
case(ROFF_p1003_2):
return("IEEE Std 1003.2 (“POSIX.2”)");
case(ROFF_p1387_2):
return("IEEE Std 1387.2 (“POSIX.7.2”)");
case(ROFF_isoC_90):
return("ISO/IEC 9899:1990 (“ISO C90”)");
case(ROFF_isoC_amd1):
return("ISO/IEC 9899/AMD1:1995 (“ISO C90”)");
case(ROFF_isoC_tcor1):
return("ISO/IEC 9899/TCOR1:1994 (“ISO C90”)");
case(ROFF_isoC_tcor2):
return("ISO/IEC 9899/TCOR2:1995 (“ISO C90”)");
case(ROFF_isoC_99):
return("ISO/IEC 9899:1999 (“ISO C99”)");
case(ROFF_ansiC):
return("ANSI X3.159-1989 (“ANSI C”)");
case(ROFF_ansiC_89):
return("ANSI X3.159-1989 (“ANSI C”)");
case(ROFF_ansiC_99):
return("ANSI/ISO/IEC 9899-1999 (“ANSI C99”)");
case(ROFF_ieee754):
return("IEEE Std 754-1985");
case(ROFF_iso8802_3):
return("ISO 8802-3: 1989");
case(ROFF_xpg3):
return("X/Open Portability Guide Issue 3 (“XPG3”)");
case(ROFF_xpg4):
return("X/Open Portability Guide Issue 4 (“XPG4”)");
case(ROFF_xpg4_2):
return("X/Open Portability Guide Issue 4.2 (“XPG4.2”)");
case(ROFF_xpg4_3):
return("X/Open Portability Guide Issue 4.3 (“XPG4.3”)");
case(ROFF_xbd5):
return("X/Open System Interface Definitions Issue 5 (“XBD5”)");
case(ROFF_xcu5):
return("X/Open Commands and Utilities Issue 5 (“XCU5”)");
case(ROFF_xsh5):
return("X/Open System Interfaces and Headers Issue 5 (“XSH5”)");
case(ROFF_xns5):
return("X/Open Networking Services Issue 5 (“XNS5”)");
case(ROFF_xns5_2d2_0):
return("X/Open Networking Services Issue 5.2 Draft 2.0 (“XNS5.2D2.0”)");
case(ROFF_xcurses4_2):
return("X/Open Curses Issue 4 Version 2 (“XCURSES4.2”)");
case(ROFF_susv2):
return("Version 2 of the Single UNIX Specification");
case(ROFF_susv3):
return("Version 3 of the Single UNIX Specification");
case(ROFF_svid4):
return("System V Interface Definition, Fourth Edition (“SVID4”)");
default:
break;
}
abort();
/* NOTREACHED */
}
static char *
mlg_At_literal(const char *p)
{
if (NULL == p)
return("AT&T UNIX");
if (0 == strcmp(p, "v6"))
return("Version 6 AT&T UNIX");
else if (0 == strcmp(p, "v7"))
return("Version 7 AT&T UNIX");
else if (0 == strcmp(p, "32v"))
return("Version 32v AT&T UNIX");
else if (0 == strcmp(p, "V.1"))
return("AT&T System V.1 UNIX");
else if (0 == strcmp(p, "V.4"))
return("AT&T System V.4 UNIX");
abort();
/* NOTREACHED */
}
static char *
mlg_fmt(int tok)
{
switch (tok) {
case (ROFF_Ex):
return ("The %s utility exits 0 on success, and "
">0 if an error occurs.");
case (ROFF_Rv):
return ("The %s() function returns the value 0 if "
"successful; otherwise the value -1 "
"is returned and the global variable "
"<span class=\"inline-Va\">errno</span> "
"is set to indicate the error.");
default:
break;
}
abort();
/* NOTREACHED */
}
static char *
mlg_literal(int tok)
{
switch (tok) {
case (ROFF_Bt):
return("is currently in beta test.");
case (ROFF_Ud):
return("currently under development.");
case (ROFF_Fx):
return("FreeBSD");
case (ROFF_Nx):
return("NetBSD");
case (ROFF_Ox):
return("OpenBSD");
case (ROFF_Ux):
return("UNIX");
case (ROFF_Bx):
return("BSD");
case (ROFF_Bsx):
return("BSDI BSD/OS");
default:
break;
}
abort();
/* NOTREACHED */
}
static int
mlg_begintag(struct md_mlg *p, enum md_ns ns, int tok,
int *argc, char **argv)
{
ssize_t res;
assert(MD_NS_DEFAULT != ns);
switch (ns) {
case (MD_NS_INLINE):
if ( ! (ML_OVERRIDE_ONE & p->flags) &&
! (ML_OVERRIDE_ALL & p->flags) &&
p->pos + 11 >= COLUMNS)
if ( ! mlg_newline(p))
return(0);
if (0 != p->pos && (MD_TEXT == p->last ||
MD_INLINE_OUT == p->last)
&& ! (ML_OVERRIDE_ONE & p->flags)
&& ! (ML_OVERRIDE_ALL & p->flags))
if ( ! ml_nputs(p->mbuf, " ", 1, &p->pos))
return(0);
if (0 == p->pos && ! mlg_indent(p))
return(0);
mlg_mode(p, MD_INLINE_IN);
break;
default:
if (0 != p->pos) {
if ( ! mlg_newline(p))
return(0);
if ( ! mlg_indent(p))
return(0);
} else if ( ! mlg_indent(p))
return(0);
p->indent++;
mlg_mode(p, MD_BLK_IN);
break;
}
if ( ! ml_nputs(p->mbuf, "<", 1, &p->pos))
return(0);
res = (*p->cbs.ml_begintag)(p->mbuf, p->data, p->args, ns, tok,
argc, (const char **)argv);
if (-1 == res)
return(0);
assert(res >= 0);
p->pos += (size_t)res;
if ( ! ml_nputs(p->mbuf, ">", 1, &p->pos))
return(0);
switch (ns) {
case (MD_NS_INLINE):
break;
default:
if ( ! mlg_newline(p))
return(0);
break;
}
return(1);
}
static int
mlg_endtag(struct md_mlg *p, enum md_ns ns, int tok)
{
ssize_t res;
assert(MD_NS_DEFAULT != ns);
switch (ns) {
case (MD_NS_INLINE):
break;
default:
p->indent--;
if (0 != p->pos) {
if ( ! mlg_newline(p))
return(0);
if ( ! mlg_indent(p))
return(0);
} else if ( ! mlg_indent(p))
return(0);
break;
}
if ( ! ml_nputs(p->mbuf, "</", 2, &p->pos))
return(0);
res = (*p->cbs.ml_endtag)(p->mbuf, p->data, p->args, ns, tok);
if (-1 == res)
return(0);
assert(res >= 0);
p->pos += (size_t)res;
if ( ! ml_nputs(p->mbuf, ">", 1, &p->pos))
return(0);
switch (ns) {
case (MD_NS_INLINE):
mlg_mode(p, MD_INLINE_OUT);
break;
default:
mlg_mode(p, MD_BLK_OUT);
break;
}
return(1);
}
static int
mlg_indent(struct md_mlg *p)
{
size_t count;
count = p->indent > MAXINDENT ?
(size_t)MAXINDENT : p->indent;
count *= INDENT;
assert(0 == p->pos);
return(ml_putchars(p->mbuf, ' ', count, &p->pos));
}
static int
mlg_newline(struct md_mlg *p)
{
p->pos = 0;
return(ml_nputs(p->mbuf, "\n", 1, NULL));
}
static void
mlg_mode(struct md_mlg *p, enum md_tok ns)
{
p->flags &= ~ML_OVERRIDE_ONE;
p->last = ns;
}
static int
mlg_data(struct md_mlg *p, int space, const char *start, char *buf)
{
size_t sz;
int c;
assert(p->mbuf);
assert(0 != p->indent);
if (ML_OVERRIDE_ONE & p->flags ||
ML_OVERRIDE_ALL & p->flags)
space = 0;
sz = strlen(buf);
if (0 == p->pos) {
if ( ! mlg_indent(p))
return(0);
c = ml_nputstring(p->mbuf, buf, sz, &p->pos);
if (0 == c) {
mlg_err(p, start, buf, "bad char sequence");
return(0);
} else if (c > 1) {
mlg_warn(p, start, buf, "bogus char sequence");
return(0);
} else if (-1 == c)
return(0);
if (p->indent * INDENT + sz >= COLUMNS)
if ( ! mlg_newline(p))
return(0);
return(1);
}
if (space && sz + p->pos >= COLUMNS) {
if ( ! mlg_newline(p))
return(0);
if ( ! mlg_indent(p))
return(0);
} else if (space) {
if ( ! ml_nputs(p->mbuf, " ", 1, &p->pos))
return(0);
}
c = ml_nputstring(p->mbuf, buf, sz, &p->pos);
if (0 == c) {
mlg_err(p, start, buf, "bad char sequence");
return(0);
} else if (c > 1) {
mlg_warn(p, start, buf, "bogus char sequence");
return(0);
} else if (-1 == c)
return(0);
return(1);
}
int
mlg_line(struct md_mlg *p, char *buf)
{
return(roff_engine(p->tree, buf));
}
int
mlg_exit(struct md_mlg *p, int flush)
{
int c;
c = roff_free(p->tree, flush);
free(p);
(*p->cbs.ml_free)(p->data);
return(c);
}
struct md_mlg *
mlg_alloc(const struct md_args *args,
const struct md_rbuf *rbuf,
struct md_mbuf *mbuf,
const struct ml_cbs *cbs)
{
struct roffcb cb;
struct md_mlg *p;
cb.roffhead = mlg_roffhead;
cb.rofftail = mlg_rofftail;
cb.roffin = mlg_roffin;
cb.roffout = mlg_roffout;
cb.roffblkin = mlg_roffblkin;
cb.roffblkheadin = mlg_roffblkheadin;
cb.roffblkheadout = mlg_roffblkheadout;
cb.roffblkbodyin = mlg_roffblkbodyin;
cb.roffblkbodyout = mlg_roffblkbodyout;
cb.roffblkout = mlg_roffblkout;
cb.roffspecial = mlg_roffspecial;
cb.roffmsg = mlg_roffmsg;
cb.roffdata = mlg_roffdata;
if (NULL == (p = calloc(1, sizeof(struct md_mlg))))
err(1, "calloc");
p->args = args;
p->mbuf = mbuf;
p->rbuf = rbuf;
(void)memcpy(&p->cbs, cbs, sizeof(struct ml_cbs));
if (NULL == (p->tree = roff_alloc(&cb, p)))
free(p);
else if ( ! (*p->cbs.ml_alloc)(&p->data))
free(p);
else
return(p);
return(NULL);
}
static int
mlg_roffhead(void *arg, const struct tm *tm, const char *os,
const char *title, const char *sec, const char *vol)
{
struct md_mlg *p;
assert(arg);
p = (struct md_mlg *)arg;
mlg_mode(p, MD_BLK_IN);
if ( ! (*p->cbs.ml_begin)(p->mbuf, p->args, tm, os, title, sec, vol))
return(0);
p->indent++;
return(mlg_newline(p));
}
static int
mlg_rofftail(void *arg)
{
struct md_mlg *p;
assert(arg);
p = (struct md_mlg *)arg;
if (0 != p->pos)
if ( ! mlg_newline(p))
return(0);
if ( ! (*p->cbs.ml_end)(p->mbuf, p->args))
return(0);
mlg_mode(p, MD_BLK_OUT);
return(mlg_newline(p));
}
/* ARGSUSED */
static int
mlg_roffspecial(void *arg, int tok, const char *start,
const int *argc, const char **argv, char **more)
{
struct md_mlg *p;
char buf[256];
assert(arg);
p = (struct md_mlg *)arg;
/*
* First handle macros without content.
*/
switch (tok) {
case (ROFF_Ns):
p->flags |= ML_OVERRIDE_ONE;
return(1);
case (ROFF_Sm):
assert(*more);
if (0 == strcmp(*more, "on"))
p->flags |= ML_OVERRIDE_ALL;
else
p->flags &= ~ML_OVERRIDE_ALL;
return(1);
default:
break;
}
if ( ! mlg_begintag(p, MD_NS_INLINE, tok, NULL, more))
return(0);
switch (tok) {
case (ROFF_St):
assert(NULL == *argv);
assert(ROFF_ARGMAX != *argc);
if ( ! ml_puts(p->mbuf, mlg_St_literal(*argc),
&p->pos))
return(0);
while (*more) {
if ( ! ml_nputs(p->mbuf, " ", 1, &p->pos))
return(0);
if ( ! ml_putstring(p->mbuf, *more++, &p->pos))
return(0);
}
break;
case (ROFF_Xr):
if ( ! *more) {
mlg_err(p, start, start, "missing argument");
return(0);
}
if ( ! ml_puts(p->mbuf, *more++, &p->pos))
return(0);
if (*more) {
if ( ! ml_nputs(p->mbuf, "(", 1, &p->pos))
return(0);
if ( ! ml_puts(p->mbuf, *more++, &p->pos))
return(0);
if ( ! ml_nputs(p->mbuf, ")", 1, &p->pos))
return(0);
}
if (*more) {
mlg_err(p, start, start, "too many arguments");
return(0);
}
break;
case (ROFF_Sx):
/* FALLTHROUGH */
case (ROFF_Nm):
assert(*more);
if ( ! ml_puts(p->mbuf, *more++, &p->pos))
return(0);
assert(NULL == *more);
break;
case (ROFF_Ex):
/* NOTREACHED */
case (ROFF_Rv):
assert(*more);
(void)snprintf(buf, sizeof(buf),
mlg_fmt(tok), *more++);
if ( ! ml_puts(p->mbuf, buf, &p->pos))
return(0);
assert(NULL == *more);
break;
case (ROFF_At):
if ( ! ml_puts(p->mbuf, mlg_At_literal(*more), &p->pos))
return(0);
break;
case (ROFF_Bx):
/* FALLTHROUGH */
case (ROFF_Bsx):
/* FALLTHROUGH */
case (ROFF_Fx):
/* FALLTHROUGH */
case (ROFF_Nx):
/* FALLTHROUGH */
case (ROFF_Ox):
if ( ! ml_puts(p->mbuf, mlg_literal(tok), &p->pos))
return(0);
while (*more) {
if ( ! ml_nputs(p->mbuf, " ", 1, &p->pos))
return(0);
if ( ! ml_putstring(p->mbuf, *more++, &p->pos))
return(0);
}
break;
case (ROFF_Bt):
/* FALLTHROUGH */
case (ROFF_Ud):
/* FALLTHROUGH */
case (ROFF_Ux):
assert(NULL == *more);
if ( ! ml_puts(p->mbuf, mlg_literal(tok), &p->pos))
return(0);
break;
default:
mlg_err(p, start, start, "`%s' not yet supported",
toknames[tok]);
return(0);
}
return(mlg_endtag(p, MD_NS_INLINE, tok));
}
static int
mlg_roffblkin(void *arg, int tok, int *argc, char **argv)
{
return(mlg_begintag((struct md_mlg *)arg,
MD_NS_BLOCK, tok, argc, argv));
}
static int
mlg_roffblkout(void *arg, int tok)
{
return(mlg_endtag((struct md_mlg *)arg, MD_NS_BLOCK, tok));
}
static int
mlg_roffblkbodyin(void *arg, int tok, int *argc, char **argv)
{
return(mlg_begintag((struct md_mlg *)arg,
MD_NS_BODY, tok, argc, argv));
}
static int
mlg_roffblkbodyout(void *arg, int tok)
{
return(mlg_endtag((struct md_mlg *)arg, MD_NS_BODY, tok));
}
static int
mlg_roffblkheadin(void *arg, int tok, int *argc, char **argv)
{
return(mlg_begintag((struct md_mlg *)arg,
MD_NS_HEAD, tok, argc, argv));
}
static int
mlg_roffblkheadout(void *arg, int tok)
{
return(mlg_endtag((struct md_mlg *)arg, MD_NS_HEAD, tok));
}
static int
mlg_roffin(void *arg, int tok, int *argc, char **argv)
{
return(mlg_begintag((struct md_mlg *)arg,
MD_NS_INLINE, tok, argc, argv));
}
static int
mlg_roffout(void *arg, int tok)
{
return(mlg_endtag((struct md_mlg *)arg, MD_NS_INLINE, tok));
}
static void
mlg_roffmsg(void *arg, enum roffmsg lvl,
const char *buf, const char *pos, char *msg)
{
mlg_msg((struct md_mlg *)arg, lvl, buf, pos, msg);
}
static int
mlg_roffdata(void *arg, int space, const char *start, char *buf)
{
struct md_mlg *p;
assert(arg);
p = (struct md_mlg *)arg;
if ( ! mlg_data(p, space, start, buf))
return(0);
mlg_mode(p, MD_TEXT);
return(1);
}
static void
mlg_vmsg(struct md_mlg *p, enum roffmsg lvl, const char *start,
const char *pos, const char *fmt, va_list ap)
{
char buf[128];
(void)vsnprintf(buf, sizeof(buf), fmt, ap);
mlg_msg(p, lvl, start, pos, buf);
}
static void
mlg_warn(struct md_mlg *p, const char *start,
const char *pos, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
mlg_vmsg(p, ROFF_WARN, start, pos, fmt, ap);
va_end(ap);
}
static void
mlg_err(struct md_mlg *p, const char *start,
const char *pos, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
mlg_vmsg(p, ROFF_ERROR, start, pos, fmt, ap);
va_end(ap);
}
static void
mlg_msg(struct md_mlg *p, enum roffmsg lvl,
const char *buf, const char *pos, char *msg)
{
char *level;
switch (lvl) {
case (ROFF_WARN):
if ( ! (MD_WARN_ALL & p->args->warnings))
return;
level = "warning";
break;
case (ROFF_ERROR):
level = "error";
break;
default:
abort();
}
if (pos)
(void)fprintf(stderr, "%s:%zu: %s: %s (column %zu)\n",
p->rbuf->name, p->rbuf->line, level,
msg, pos - buf);
else
(void)fprintf(stderr, "%s: %s: %s\n",
p->rbuf->name, level, msg);
}
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mlg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / mandoc