[BACK]Return to mdocml.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/mdocml.c, Revision 1.5

1.5     ! kristaps    1: /* $Id: mdocml.c,v 1.4 2008/11/22 18:34:06 kristaps Exp $ */
1.1       kristaps    2: /*
                      3:  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
                      4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the
                      7:  * above copyright notice and this permission notice appear in all
                      8:  * copies.
                      9:  *
                     10:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
                     11:  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
                     12:  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
                     13:  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
                     14:  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
                     15:  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
                     16:  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
                     17:  * PERFORMANCE OF THIS SOFTWARE.
                     18:  */
                     19: #include <sys/param.h>
                     20: #include <sys/stat.h>
                     21:
                     22: #include <assert.h>
                     23: #include <err.h>
                     24: #include <fcntl.h>
                     25: #include <getopt.h>
                     26: #include <stdio.h>
                     27: #include <stdlib.h>
                     28: #include <string.h>
                     29: #include <unistd.h>
                     30:
                     31: #include "libmdocml.h"
                     32:
1.3       kristaps   33: #define        BUFFER_IN_DEF   BUFSIZ
                     34: #define        BUFFER_OUT_DEF  BUFSIZ
1.2       kristaps   35:
1.1       kristaps   36: static void             usage(void);
1.5     ! kristaps   37: static int              begin_io(const struct md_args *,
        !            38:                                char *, char *);
        !            39: static int              leave_io(const struct md_buf *,
        !            40:                                const struct md_buf *, int);
        !            41: static int              begin_bufs(const struct md_args *,
        !            42:                                struct md_buf *, struct md_buf *);
        !            43: static int              leave_bufs(const struct md_buf *,
        !            44:                                const struct md_buf *, int);
1.1       kristaps   45:
                     46: int
                     47: main(int argc, char *argv[])
                     48: {
                     49:        int              c;
                     50:        char            *out, *in;
1.5     ! kristaps   51:        struct md_args   args;
1.1       kristaps   52:
                     53:        extern char     *optarg;
                     54:        extern int       optind;
                     55:
1.4       kristaps   56:        out = in = NULL;
1.1       kristaps   57:
                     58:        while (-1 != (c = getopt(argc, argv, "o:")))
                     59:                switch (c) {
                     60:                case ('o'):
                     61:                        out = optarg;
                     62:                        break;
                     63:                default:
                     64:                        usage();
                     65:                        return(1);
                     66:                }
                     67:
                     68:        argv += optind;
1.4       kristaps   69:        argc -= optind;
1.1       kristaps   70:
1.4       kristaps   71:        if (1 == argc)
                     72:                in = *argv++;
1.1       kristaps   73:
1.5     ! kristaps   74:        args.type = MD_DUMMY;
        !            75:
        !            76:        return(begin_io(&args, out ? out : "-", in ? in : "-"));
1.1       kristaps   77: }
                     78:
                     79:
                     80: static int
1.5     ! kristaps   81: leave_io(const struct md_buf *out,
        !            82:                const struct md_buf *in, int c)
1.1       kristaps   83: {
1.4       kristaps   84:        assert(out);
1.1       kristaps   85:        assert(in);
                     86:
1.4       kristaps   87:        if (-1 != in->fd && -1 == close(in->fd)) {
                     88:                assert(in->name);
                     89:                warn("%s", in->name);
                     90:                c = 1;
                     91:        }
                     92:        if (-1 != out->fd && STDOUT_FILENO != out->fd &&
                     93:                        -1 == close(out->fd)) {
                     94:                assert(out->name);
                     95:                warn("%s", out->name);
                     96:                c = 1;
                     97:        }
1.1       kristaps   98:
1.4       kristaps   99:        return(c);
1.1       kristaps  100: }
                    101:
                    102:
                    103: static int
1.5     ! kristaps  104: begin_io(const struct md_args *args, char *out, char *in)
1.1       kristaps  105: {
1.5     ! kristaps  106:        struct md_buf    fi;
        !           107:        struct md_buf    fo;
1.4       kristaps  108:
                    109: #define        FI_FL   O_RDONLY
                    110: #define        FO_FL   O_WRONLY|O_CREAT|O_TRUNC
1.1       kristaps  111:
1.5     ! kristaps  112:        assert(args);
1.1       kristaps  113:        assert(out);
                    114:        assert(in);
                    115:
1.5     ! kristaps  116:        bzero(&fi, sizeof(struct md_buf));
        !           117:        bzero(&fo, sizeof(struct md_buf));
1.1       kristaps  118:
1.4       kristaps  119:        fi.fd = STDIN_FILENO;
                    120:        fo.fd = STDOUT_FILENO;
1.1       kristaps  121:
1.4       kristaps  122:        fi.name = in;
                    123:        fo.name = out;
1.1       kristaps  124:
1.4       kristaps  125:        if (0 != strncmp(fi.name, "-", 1))
                    126:                if (-1 == (fi.fd = open(fi.name, FI_FL, 0))) {
                    127:                        warn("%s", fi.name);
                    128:                        return(leave_io(&fo, &fi, 1));
                    129:                }
1.1       kristaps  130:
1.4       kristaps  131:        if (0 != strncmp(fo.name, "-", 1))
                    132:                if (-1 == (fo.fd = open(fo.name, FO_FL, 0644))) {
                    133:                        warn("%s", fo.name);
                    134:                        return(leave_io(&fo, &fi, 1));
                    135:                }
1.1       kristaps  136:
1.5     ! kristaps  137:        return(leave_io(&fo, &fi, begin_bufs(args, &fo, &fi)));
1.4       kristaps  138: }
1.1       kristaps  139:
                    140:
1.4       kristaps  141: static int
1.5     ! kristaps  142: leave_bufs(const struct md_buf *out,
        !           143:                const struct md_buf *in, int c)
1.4       kristaps  144: {
                    145:        assert(out);
                    146:        assert(in);
                    147:        if (out->buf)
                    148:                free(out->buf);
                    149:        if (in->buf)
                    150:                free(in->buf);
1.1       kristaps  151:        return(c);
                    152: }
                    153:
                    154:
                    155: static int
1.5     ! kristaps  156: begin_bufs(const struct md_args *args,
        !           157:                struct md_buf *out, struct md_buf *in)
1.1       kristaps  158: {
                    159:        struct stat      stin, stout;
1.5     ! kristaps  160:        int              c;
1.1       kristaps  161:
1.5     ! kristaps  162:        assert(args);
1.1       kristaps  163:        assert(in);
                    164:        assert(out);
                    165:
                    166:        if (-1 == fstat(in->fd, &stin)) {
1.3       kristaps  167:                warn("%s", in->name);
1.1       kristaps  168:                return(1);
                    169:        } else if (-1 == fstat(out->fd, &stout)) {
1.3       kristaps  170:                warn("%s", out->name);
1.1       kristaps  171:                return(1);
                    172:        }
                    173:
1.3       kristaps  174:        in->bufsz = MAX(stin.st_blksize, BUFFER_IN_DEF);
                    175:        out->bufsz = MAX(stout.st_blksize, BUFFER_OUT_DEF);
1.1       kristaps  176:
1.3       kristaps  177:        if (NULL == (in->buf = malloc(in->bufsz))) {
1.1       kristaps  178:                warn("malloc");
1.4       kristaps  179:                return(leave_bufs(out, in, 1));
1.3       kristaps  180:        } else if (NULL == (out->buf = malloc(out->bufsz))) {
1.1       kristaps  181:                warn("malloc");
1.4       kristaps  182:                return(leave_bufs(out, in, 1));
1.1       kristaps  183:        }
                    184:
1.5     ! kristaps  185:        c = md_run(args, out, in);
        !           186:        return(leave_bufs(out, in, -1 == c ? 1 : 0));
1.1       kristaps  187: }
                    188:
                    189:
                    190: static void
                    191: usage(void)
                    192: {
                    193:        extern char     *__progname;
                    194:
1.4       kristaps  195:        (void)printf("usage: %s [-o outfile] [infile]\n", __progname);
1.1       kristaps  196: }

CVSweb