/* $Id$ */
/*
* 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 <sys/param.h>
#include <assert.h>
#include <ctype.h>
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libmdocml.h"
#include "private.h"
#ifdef __linux__ /* FIXME */
#define strlcat strncat
#endif
struct md_valid {
const struct md_args *args;
const struct md_rbuf *rbuf;
struct md_mbuf *mbuf;
struct rofftree *tree;
size_t indent;
size_t pos;
int flags;
#define MD_LITERAL (1 << 0)
};
static void roffmsg(void *arg, enum roffmsg,
const char *, const char *, char *);
static int roffhead(void *);
static int rofftail(void *);
static int roffin(void *, int, int *, char **);
static int roffdata(void *, char *);
static int roffout(void *, int);
static int roffblkin(void *, int);
static int roffblkout(void *, int);
static int roffspecial(void *, int);
static int mbuf_newline(struct md_valid *);
static int mbuf_indent(struct md_valid *);
static int mbuf_data(struct md_valid *, char *);
static int
mbuf_indent(struct md_valid *p)
{
size_t i;
assert(0 == p->pos);
for (i = 0; i < MIN(p->indent, 4); i++)
if ( ! md_buf_putstring(p->mbuf, " "))
return(0);
p->pos = i * 4;
return(1);
}
static int
mbuf_atnewline(struct md_valid *p)
{
return(p->pos == MIN(4, p->indent));
}
static int
mbuf_newline(struct md_valid *p)
{
if (mbuf_atnewline(p))
return(1);
if ( ! md_buf_putchar(p->mbuf, '\n'))
return(0);
p->pos = 0;
return(mbuf_indent(p));
}
static int
mbuf_data(struct md_valid *p, char *buf)
{
size_t sz;
char *bufp;
assert(p->mbuf);
assert(0 != p->indent);
if (MD_LITERAL & p->flags)
return(md_buf_putstring(p->mbuf, buf));
if (0 == p->pos)
mbuf_indent(p);
/*
* Indent if we're at the beginning of a line. Don't indent
* more than 16 or so characters.
*/
while (*buf) {
while (*buf && isspace(*buf))
buf++;
if (0 == *buf)
break;
bufp = buf;
while (*buf && ! isspace(*buf))
buf++;
if (0 != *buf)
*buf++ = 0;
/* Process word. */
sz = strlen(bufp);
if (sz + p->pos < 72) {
if ( ! md_buf_putstring(p->mbuf, bufp))
return(0);
/* FIXME: check punctuation. */
if ( ! md_buf_putchar(p->mbuf, ' '))
return(0);
p->pos += sz + 1;
continue;
}
if ( ! mbuf_newline(p))
return(0);
if ( ! md_buf_putstring(p->mbuf, bufp))
return(0);
/* FIXME: check punctuation. */
if ( ! md_buf_putchar(p->mbuf, ' '))
return(0);
p->pos += sz + 1;
}
return(1);
}
int
md_line_valid(void *arg, char *buf)
{
struct md_valid *p;
p = (struct md_valid *)arg;
return(roff_engine(p->tree, buf));
}
int
md_exit_valid(void *data, int flush)
{
int c;
struct md_valid *p;
p = (struct md_valid *)data;
c = roff_free(p->tree, flush);
free(p);
return(c);
}
void *
md_init_valid(const struct md_args *args,
struct md_mbuf *mbuf, const struct md_rbuf *rbuf)
{
struct roffcb cb;
struct md_valid *p;
cb.roffhead = roffhead;
cb.rofftail = rofftail;
cb.roffin = roffin;
cb.roffout = roffout;
cb.roffblkin = roffblkin;
cb.roffblkout = roffblkout;
cb.roffspecial = roffspecial;
cb.roffmsg = roffmsg;
cb.roffdata = roffdata;
if (NULL == (p = calloc(1, sizeof(struct md_valid))))
err(1, "malloc");
p->args = args;
p->mbuf = mbuf;
p->rbuf = rbuf;
assert(mbuf);
if (NULL == (p->tree = roff_alloc(&cb, p))) {
free(p);
return(NULL);
}
return(p);
}
/* ARGSUSED */
static int
roffhead(void *arg)
{
return(1);
}
static int
rofftail(void *arg)
{
struct md_valid *p;
assert(arg);
p = (struct md_valid *)arg;
if (mbuf_atnewline(p))
return(1);
return(md_buf_putchar(p->mbuf, '\n'));
}
static int
roffspecial(void *arg, int tok)
{
return(1);
}
static int
roffblkin(void *arg, int tok)
{
struct md_valid *p;
assert(arg);
p = (struct md_valid *)arg;
if ( ! mbuf_atnewline(p)) {
if ( ! md_buf_putchar(p->mbuf, '\n'))
return(0);
p->pos = 0;
if ( ! mbuf_indent(p))
return(0);
}
if ( ! md_buf_putstring(p->mbuf, toknames[tok]))
return(0);
if ( ! md_buf_putchar(p->mbuf, '\n'))
return(0);
p->pos = 0;
p->indent++;
return(mbuf_indent(p));
}
static int
roffblkout(void *arg, int tok)
{
struct md_valid *p;
assert(arg);
p = (struct md_valid *)arg;
if ( ! md_buf_putchar(p->mbuf, '\n'))
return(0);
p->pos = 0;
p->indent--;
return(mbuf_indent(p));
}
static int
roffin(void *arg, int tok, int *argcp, char **argvp)
{
return(1);
}
static int
roffout(void *arg, int tok)
{
return(1);
}
static void
roffmsg(void *arg, enum roffmsg lvl,
const char *buf, const char *pos, char *msg)
{
char *level;
struct md_valid *p;
assert(arg);
p = (struct md_valid *)arg;
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\n",
p->rbuf->name, p->rbuf->line, level, msg);
else
(void)fprintf(stderr, "%s: %s: %s\n",
p->rbuf->name, level, msg);
}
static int
roffdata(void *arg, char *buf)
{
struct md_valid *p;
assert(arg);
p = (struct md_valid *)arg;
return(mbuf_data(p, buf));
}
