![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mdocml.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / mandoc|
Return to mdocml.c CVS log | Up to [cvsweb.bsd.lv] / mandoc |
1.1 kristaps 1: /* $Id$ */
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:
33: struct md_file {
34: int fd;
35: const char *name;
36: };
37:
38: struct md_buf {
39: struct md_file *file;
40: char *buf;
41: size_t bufsz;
42: size_t line;
43: };
44:
45: static void usage(void);
46:
47: static int md_begin(const char *, const char *);
48: static int md_begin_io(const char *, const char *);
49: static int md_begin_bufs(struct md_file *, struct md_file *);
50: static int md_run(struct md_buf *, struct md_buf *);
51: static int md_line(struct md_buf *, const struct md_buf *,
52: const char *, size_t);
53:
54: static ssize_t md_buf_fill(struct md_buf *);
55:
56:
57: int
58: main(int argc, char *argv[])
59: {
60: int c;
61: char *out, *in;
62:
63: extern char *optarg;
64: extern int optind;
65:
66: out = NULL;
67:
68: while (-1 != (c = getopt(argc, argv, "o:")))
69: switch (c) {
70: case ('o'):
71: out = optarg;
72: break;
73: default:
74: usage();
75: return(1);
76: }
77:
78: argv += optind;
79: if (1 != (argc -= optind)) {
80: usage();
81: return(1);
82: }
83:
84: argc--;
85: in = *argv++;
86:
87: return(md_begin(out, in));
88: }
89:
90:
91: static int
92: md_begin(const char *out, const char *in)
93: {
94: char buf[MAXPATHLEN];
95:
96: assert(in);
97: if (out)
98: return(md_begin_io(out, in));
99:
100: if (strlcpy(buf, in, MAXPATHLEN) >= MAXPATHLEN)
101: warnx("output filename too long");
102: else if (strlcat(buf, ".html", MAXPATHLEN) >= MAXPATHLEN)
103: warnx("output filename too long");
104: else
105: return(md_begin_io(buf, in));
106:
107: return(1);
108: }
109:
110:
111: static int
112: md_begin_io(const char *out, const char *in)
113: {
114: int c;
115: struct md_file fin, fout;
116:
117: assert(out);
118: assert(in);
119:
120: /* XXX: put an output file in TMPDIR and switch it out when the
121: * true file is ready to be written.
122: */
123:
124: fin.name = in;
125:
126: if (-1 == (fin.fd = open(fin.name, O_RDONLY, 0))) {
127: warn("%s", fin.name);
128: return(1);
129: }
130:
131: fout.name = out;
132:
133: fout.fd = open(fout.name, O_WRONLY | O_CREAT | O_EXCL, 0644);
134: if (-1 == fout.fd) {
135: warn("%s", fout.name);
136: if (-1 == close(fin.fd))
137: warn("%s", fin.name);
138: return(1);
139: }
140:
141: c = md_begin_bufs(&fout, &fin);
142:
143: if (-1 == close(fin.fd)) {
144: warn("%s", in);
145: c = 1;
146: }
147: if (-1 == close(fout.fd)) {
148: warn("%s", out);
149: c = 1;
150: }
151:
152: return(c);
153: }
154:
155:
156: static int
157: md_begin_bufs(struct md_file *out, struct md_file *in)
158: {
159: struct stat stin, stout;
160: struct md_buf inbuf, outbuf;
161: int c;
162:
163: assert(in);
164: assert(out);
165:
166: if (-1 == fstat(in->fd, &stin)) {
167: warn("fstat: %s", in->name);
168: return(1);
169: } else if (-1 == fstat(out->fd, &stout)) {
170: warn("fstat: %s", out->name);
171: return(1);
172: }
173:
174: inbuf.file = in;
175: inbuf.line = 1;
176: inbuf.bufsz = MAX(stin.st_blksize, BUFSIZ);
177:
178: outbuf.file = out;
179: outbuf.line = 1;
180: outbuf.bufsz = MAX(stout.st_blksize, BUFSIZ);
181:
182: if (NULL == (inbuf.buf = malloc(inbuf.bufsz))) {
183: warn("malloc");
184: return(1);
185: } else if (NULL == (outbuf.buf = malloc(outbuf.bufsz))) {
186: warn("malloc");
187: free(inbuf.buf);
188: return(1);
189: }
190:
191: c = md_run(&outbuf, &inbuf);
192:
193: free(inbuf.buf);
194: free(outbuf.buf);
195:
196: return(c);
197: }
198:
199:
200: static ssize_t
201: md_buf_fill(struct md_buf *in)
202: {
203: ssize_t ssz;
204:
205: assert(in);
206: assert(in->file);
207: assert(in->buf);
208: assert(in->bufsz > 0);
209: assert(in->file->name);
210:
211: if (-1 == (ssz = read(in->file->fd, in->buf, in->bufsz)))
212: warn("%s", in->file->name);
213:
214: return(ssz);
215: }
216:
217:
218: static int
219: md_run(struct md_buf *out, struct md_buf *in)
220: {
221: ssize_t sz, i;
222: char line[BUFSIZ];
223: size_t pos;
224:
225: assert(in);
226: assert(out);
227:
228: /* LINTED */
229: for (pos = 0; ; ) {
230: if (-1 == (sz = md_buf_fill(in)))
231: return(1);
232: else if (0 == sz)
233: break;
234:
235: for (i = 0; i < sz; i++) {
236: if ('\n' == in->buf[i]) {
237: if (md_line(out, in, line, pos))
238: return(1);
239: in->line++;
240: pos = 0;
241: continue;
242: }
243:
244: if (pos < BUFSIZ) {
245: /* LINTED */
246: line[pos++] = in->buf[i];
247: continue;
248: }
249:
250: warnx("%s: line %zu too long",
251: in->file->name, in->line);
252: return(1);
253: }
254: }
255:
256: if (0 != pos)
257: return(md_line(out, in, line, pos));
258:
259: return(0);
260: }
261:
262:
263: static int
264: md_line(struct md_buf *out, const struct md_buf *in,
265: const char *buf, size_t sz)
266: {
267: size_t i;
268:
269: assert(buf);
270: assert(out);
271: assert(in);
272:
273: for (i = 0; i < sz; i++)
274: (void)putchar(buf[i]);
275:
276: (void)putchar('\n');
277: return(0);
278: }
279:
280:
281: static void
282: usage(void)
283: {
284: extern char *__progname;
285:
286: (void)printf("usage: %s [-o outfile] infile\n", __progname);
287: }