Backed out PUNCT changes (again).

[mandoc.git] / mdocml.c

diff --git a/mdocml.c b/mdocml.c
index fe4aa8e2628de68c3cdd54e893a3239538a2db72..1bcff4597b659f76c6a3573fa36cfe5e8f93e6a2 100644 (file)
--- a/mdocml.c
+++ b/mdocml.c
@@ -1,4 +1,4 @@
-/* $Id: mdocml.c,v 1.3 2008/11/22 17:14:32 kristaps Exp $ */
+/* $Id: mdocml.c,v 1.14 2008/11/28 11:21:12 kristaps Exp $ */

 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *


@@ -30,322 +30,185 @@
 
 #include "libmdocml.h"
 
 
 #include "libmdocml.h"
 

-#define        BUFFER_IN_DEF   BUFSIZ
-#define        BUFFER_OUT_DEF  BUFSIZ
-#define        BUFFER_LINE     BUFSIZ
+#define        BUFFER_IN_DEF   BUFSIZ   /* See begin_bufs. */
+#define        BUFFER_OUT_DEF  BUFSIZ   /* See begin_bufs. */

 
 

-struct md_rbuf {
-       int              fd;
-       const char      *name;
-       char            *buf;
-       size_t           bufsz;
-       size_t           line;
-};
-
-struct md_mbuf {
-       int              fd;
-       const char      *name;
-       char            *buf;
-       size_t           bufsz;
-       size_t           pos;
-};
-
-static void             usage(void);
-
-static int              md_begin(const char *, const char *);
-static int              md_begin_io(const char *, const char *);
-static int              md_begin_bufs(struct md_mbuf *, struct md_rbuf *);
-static int              md_run(struct md_mbuf *, struct md_rbuf *);
-static int              md_line(struct md_mbuf *, const struct md_rbuf *,
-                               const char *, size_t);
-
-static ssize_t          md_buf_fill(struct md_rbuf *);
-static int              md_buf_flush(struct md_mbuf *);
-
-static int              md_buf_putchar(struct md_mbuf *, char);
-static int              md_buf_puts(struct md_mbuf *, 
-                               const char *, size_t);
+static void             usage(void);

 
 

+static int              begin_io(const struct md_args *, 
+                               char *, char *);
+static int              leave_io(const struct md_buf *, 
+                               const struct md_buf *, int);
+static int              begin_bufs(const struct md_args *,
+                               struct md_buf *, struct md_buf *);
+static int              leave_bufs(const struct md_buf *, 
+                               const struct md_buf *, int);

 
 int
 main(int argc, char *argv[])
 {
        int              c;
        char            *out, *in;
 
 int
 main(int argc, char *argv[])
 {
        int              c;
        char            *out, *in;

+       struct md_args   args;

 
        extern char     *optarg;
        extern int       optind;
 
 
        extern char     *optarg;
        extern int       optind;
 

-       out = NULL;
+       out = in = NULL;
+
+       (void)memset(&args, 0, sizeof(struct md_args));

        
        

-       while (-1 != (c = getopt(argc, argv, "o:")))
+       while (-1 != (c = getopt(argc, argv, "o:vW")))

                switch (c) {
                case ('o'):
                        out = optarg;
                        break;
                switch (c) {
                case ('o'):
                        out = optarg;
                        break;

+               case ('v'):
+                       args.verbosity++;
+                       break;
+               case ('W'):
+                       args.warnings |= MD_WARN_ALL;
+                       break;

                default:
                        usage();
                        return(1);
                }
 
        argv += optind;
                default:
                        usage();
                        return(1);
                }
 
        argv += optind;

-       if (1 != (argc -= optind)) {
-               usage();
-               return(1);
-       }
+       argc -= optind;

 
 

-       argc--;
-       in = *argv++;
+       if (1 == argc)
+               in = *argv++;

 
 

-       return(md_begin(out, in));
+       return(begin_io(&args, out ? out : "-", in ? in : "-"));

 }
 
 
 }
 
 

+/* 
+ * Close out file descriptors opened in begin_io.  If the descriptor
+ * refers to stdin/stdout, then do nothing.
+ */

 static int
 static int

-md_begin(const char *out, const char *in)
+leave_io(const struct md_buf *out, 
+               const struct md_buf *in, int c)

 {
 {

-       char             buf[MAXPATHLEN];
-
+       assert(out);

        assert(in);
        assert(in);

-       if (out)
-               return(md_begin_io(out, in));

 
 

-       if (strlcpy(buf, in, MAXPATHLEN) >= MAXPATHLEN)
-               warnx("output filename too long");
-       else if (strlcat(buf, ".html", MAXPATHLEN) >= MAXPATHLEN)
-               warnx("output filename too long");
-       else 
-               return(md_begin_io(buf, in));
+       if (-1 != in->fd && -1 == close(in->fd)) {
+               assert(in->name);
+               warn("%s", in->name);
+               c = 1;
+       }
+       if (-1 != out->fd && STDOUT_FILENO != out->fd &&
+                       -1 == close(out->fd)) {
+               assert(out->name);
+               warn("%s", out->name);
+               c = 1;
+       }

 
 

-       return(1);
+       return(c);

 }
 
 
 }
 
 

+/*
+ * Open file descriptors or assign stdin/stdout, if dictated by the "-"
+ * token instead of a filename.
+ */

 static int
 static int

-md_begin_io(const char *out, const char *in)
+begin_io(const struct md_args *args, char *out, char *in)

 {
 {

-       int              c;
-       struct md_rbuf   fin;
-       struct md_mbuf   fout;
+       struct md_buf    fi;
+       struct md_buf    fo;

 
 

+#define        FI_FL   O_RDONLY
+#define        FO_FL   O_WRONLY|O_CREAT|O_TRUNC
+
+       assert(args);

        assert(out);
        assert(in);
 
        assert(out);
        assert(in);
 

-       /* TODO: accept "-" as both input and output. */
+       bzero(&fi, sizeof(struct md_buf));
+       bzero(&fo, sizeof(struct md_buf));

 
 

-       fin.name = in;
+       fi.fd = STDIN_FILENO;
+       fo.fd = STDOUT_FILENO;

 
 

-       if (-1 == (fin.fd = open(fin.name, O_RDONLY, 0))) {
-               warn("%s", fin.name);
-               return(1);
-       }
+       fi.name = in;
+       fo.name = out;

 
 

-       fout.name = out;
+       if (0 != strncmp(fi.name, "-", 1))
+               if (-1 == (fi.fd = open(fi.name, FI_FL, 0))) {
+                       warn("%s", fi.name);
+                       return(leave_io(&fo, &fi, 1));
+               }

 
 

-       fout.fd = open(fout.name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
-       if (-1 == fout.fd) {
-               warn("%s", fout.name);
-               if (-1 == close(fin.fd))
-                       warn("%s", fin.name);
-               return(1);
-       }
+       if (0 != strncmp(fo.name, "-", 1)) 
+               if (-1 == (fo.fd = open(fo.name, FO_FL, 0644))) {
+                       warn("%s", fo.name);
+                       return(leave_io(&fo, &fi, 1));
+               }

 
 

-       c = md_begin_bufs(&fout, &fin);
+       return(leave_io(&fo, &fi, begin_bufs(args, &fo, &fi)));
+}

 
 

-       if (-1 == close(fin.fd)) {
-               warn("%s", in);
-               c = 1;
-       }
-       if (-1 == close(fout.fd)) {
-               warn("%s", out);
-               c = 1;
-       }

 
 

+/*
+ * Free buffers allocated in begin_bufs.
+ */
+static int
+leave_bufs(const struct md_buf *out, 
+               const struct md_buf *in, int c)
+{
+       assert(out);
+       assert(in);
+       if (out->buf)
+               free(out->buf);
+       if (in->buf)
+               free(in->buf);

        return(c);
 }
 
 
        return(c);
 }
 
 

+/*
+ * Allocate buffers to the maximum of either the input file's blocksize
+ * or BUFFER_IN_DEF/BUFFER_OUT_DEF, which should be around BUFSIZE.
+ */

 static int
 static int

-md_begin_bufs(struct md_mbuf *out, struct md_rbuf *in)
+begin_bufs(const struct md_args *args, 
+               struct md_buf *out, struct md_buf *in)

 {
        struct stat      stin, stout;
        int              c;
 
 {
        struct stat      stin, stout;
        int              c;
 

+       assert(args);

        assert(in);
        assert(out);
 
        if (-1 == fstat(in->fd, &stin)) {
                warn("%s", in->name);
                return(1);
        assert(in);
        assert(out);
 
        if (-1 == fstat(in->fd, &stin)) {
                warn("%s", in->name);
                return(1);

+       } else if (STDIN_FILENO != in->fd && 0 == stin.st_size) {
+               warnx("%s: empty file", in->name);
+               return(1);

        } else if (-1 == fstat(out->fd, &stout)) {
                warn("%s", out->name);
                return(1);
        }
 
        in->bufsz = MAX(stin.st_blksize, BUFFER_IN_DEF);
        } else if (-1 == fstat(out->fd, &stout)) {
                warn("%s", out->name);
                return(1);
        }
 
        in->bufsz = MAX(stin.st_blksize, BUFFER_IN_DEF);

-

        out->bufsz = MAX(stout.st_blksize, BUFFER_OUT_DEF);
 
        if (NULL == (in->buf = malloc(in->bufsz))) {
                warn("malloc");
        out->bufsz = MAX(stout.st_blksize, BUFFER_OUT_DEF);
 
        if (NULL == (in->buf = malloc(in->bufsz))) {
                warn("malloc");

-               return(1);
+               return(leave_bufs(out, in, 1));

        } else if (NULL == (out->buf = malloc(out->bufsz))) {
                warn("malloc");
        } else if (NULL == (out->buf = malloc(out->bufsz))) {
                warn("malloc");

-               free(in->buf);
-               return(1);
+               return(leave_bufs(out, in, 1));

        }
 
        }
 

-       c = md_run(out, in);
-
-       free(in->buf);
-       free(out->buf);
-
-       return(c);
-}
-
-
-static ssize_t
-md_buf_fill(struct md_rbuf *in)
-{
-       ssize_t          ssz;
-
-       assert(in);
-       assert(in->buf);
-       assert(in->bufsz > 0);
-       assert(in->name);
-
-       if (-1 == (ssz = read(in->fd, in->buf, in->bufsz))) 
-               warn("%s", in->name);
-
-       return(ssz);
-}
-
-
-static int
-md_run(struct md_mbuf *out, struct md_rbuf *in)
-{
-       ssize_t          sz, i;
-       char             line[BUFFER_LINE];
-       size_t           pos;
-
-       assert(in);
-       assert(out); 
-
-       out->pos = 0;
-       in->line = 1;
-
-       /* LINTED */
-       for (pos = 0; ; ) {
-               if (-1 == (sz = md_buf_fill(in)))
-                       return(1);
-               else if (0 == sz)
-                       break;
-
-               for (i = 0; i < sz; i++) {
-                       if ('\n' == in->buf[i]) {
-                               if (md_line(out, in, line, pos))
-                                       return(1);
-                               in->line++;
-                               pos = 0;
-                               continue;
-                       }
-
-                       if (pos < BUFFER_LINE) {
-                               /* LINTED */
-                               line[pos++] = in->buf[i];
-                               continue;
-                       }
-
-                       warnx("%s: line %zu too long",
-                                       in->name, in->line);
-                       return(1);
-               }
-       }
-
-       if (0 != pos && md_line(out, in, line, pos))
-               return(1);
-
-       return(md_buf_flush(out) ? 0 : 1);
-}
-
-
-static int
-md_buf_flush(struct md_mbuf *buf)
-{
-       ssize_t          sz;
-
-       assert(buf);
-       assert(buf->buf);
-       assert(buf->name);
-
-       if (0 == buf->pos)
-               return(1);
-
-       sz = write(buf->fd, buf->buf, buf->pos);
-
-       if (-1 == sz) {
-               warn("%s", buf->name);
-               return(0);
-       } else if ((size_t)sz != buf->pos) {
-               warnx("%s: short write", buf->name);
-               return(0);
-       }
-
-       buf->pos = 0;
-       return(1);
-}
-
-
-static int
-md_buf_putchar(struct md_mbuf *buf, char c)
-{
-       return(md_buf_puts(buf, &c, 1));
-}
-
-
-static int
-md_buf_puts(struct md_mbuf *buf, const char *p, size_t sz)
-{
-       size_t           ssz;
-
-       assert(p);
-       assert(buf);
-       assert(buf->buf);
-
-       while (buf->pos + sz > buf->bufsz) {
-               ssz = buf->bufsz - buf->pos;
-               (void)memcpy(buf->buf + buf->pos, p, ssz);
-               p += ssz;
-               sz -= ssz;
-               buf->pos += ssz;
-
-               if ( ! md_buf_flush(buf))
-                       return(0);
-       }
-
-       (void)memcpy(buf->buf + buf->pos, p, sz);
-       buf->pos += sz;
-       return(1);
-}
-
-
-static int
-md_line(struct md_mbuf *out, const struct md_rbuf *in,
-               const char *buf, size_t sz)
-{
-
-       /* FIXME: this is just a placeholder function. */
-
-       assert(buf);
-       assert(out);
-       assert(in);
-
-       if ( ! md_buf_puts(out, buf, sz))
-               return(1);
-       if ( ! md_buf_putchar(out, '\n'))
-               return(1);
-
-       return(0);
+       c = md_run(args, out, in);
+       return(leave_bufs(out, in, -1 == c ? 1 : 0));

 }
 
 
 }
 
 


@@ -354,5 +217,5 @@ usage(void)
 {
        extern char     *__progname;
 
 {
        extern char     *__progname;
 

-       (void)printf("usage: %s [-o outfile] infile\n", __progname);
+       (void)printf("usage: %s [-vW] [-o outfile] [infile]\n", __progname);

 }
 }