![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / texi2mdoc|
Return to main.c CVS log | Up to [cvsweb.bsd.lv] / texi2mdoc |
1.1 kristaps 1: /* $Id: main.c,v 1.216 2015/01/16 21:15:05 schwarze Exp $ */
2: /*
3: * Copyright (c) 2015 Kristaps Dzonsons <kristaps@bsd.lv>
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 above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
17: #include <sys/mman.h>
18: #include <sys/stat.h>
19:
20: #include <assert.h>
21: #include <ctype.h>
22: #include <fcntl.h>
23: #include <getopt.h>
24: #include <stdarg.h>
25: #include <stdio.h>
26: #include <stdlib.h>
27: #include <string.h>
28:
29: /*
30: * This defines each one of the Texinfo commands that we understand.
31: * Obviously this only refers to native commands; overriden names are a
32: * different story.
33: */
34: enum texicmd {
35: TEXICMD_A4PAPER,
36: TEXICMD_ANCHOR,
37: TEXICMD_AT,
38: TEXICMD_BYE,
39: TEXICMD_CHAPTER,
40: TEXICMD_CINDEX,
41: TEXICMD_CODE,
42: TEXICMD_COMMAND,
43: TEXICMD_COMMENT,
44: TEXICMD_CONTENTS,
45: TEXICMD_COPYING,
46: TEXICMD_COPYRIGHT,
47: TEXICMD_DETAILMENU,
48: TEXICMD_DIRCATEGORY,
49: TEXICMD_DIRENTRY,
50: TEXICMD_EMAIL,
51: TEXICMD_EMPH,
52: TEXICMD_END,
53: TEXICMD_EXAMPLE,
54: TEXICMD_FILE,
55: TEXICMD_I,
56: TEXICMD_IFHTML,
57: TEXICMD_IFNOTTEX,
58: TEXICMD_IFTEX,
59: TEXICMD_IMAGE,
60: TEXICMD_ITEM,
61: TEXICMD_ITEMIZE,
62: TEXICMD_KBD,
63: TEXICMD_LATEX,
64: TEXICMD_MENU,
65: TEXICMD_NODE,
66: TEXICMD_QUOTATION,
67: TEXICMD_PARINDENT,
68: TEXICMD_REF,
69: TEXICMD_SAMP,
70: TEXICMD_SECTION,
71: TEXICMD_SETCHAPNEWPAGE,
72: TEXICMD_SETFILENAME,
73: TEXICMD_SETTITLE,
74: TEXICMD_SUBSECTION,
75: TEXICMD_TABLE,
76: TEXICMD_TEX,
77: TEXICMD_TEXSYM,
78: TEXICMD_TITLEFONT,
79: TEXICMD_TITLEPAGE,
80: TEXICMD_TOP,
81: TEXICMD_UNNUMBERED,
82: TEXICMD_URL,
83: TEXICMD_VAR,
84: TEXICMD__MAX
85: };
86:
87: /*
88: * The file currently being parsed.
89: * This keeps track of our location within that file.
90: */
91: struct texifile {
92: const char *name; /* name of the file */
93: size_t line; /* current line (from zero) */
94: size_t col; /* current column in line (from zero) */
95: char *map; /* mmap'd file */
96: size_t mapsz; /* size of mmap */
97: };
98:
99: struct texi;
100:
101: typedef void (*texicmdfp)(struct texi *,
102: enum texicmd, const char *, size_t, size_t *);
103:
104: /*
105: * Describes Texinfo commands, whether native or overriden.
106: */
107: struct texitok {
108: texicmdfp fp; /* callback (or NULL if none) */
109: const char *tok; /* name of the token */
110: size_t len; /* strlen(tok) */
111: };
112:
113: /*
114: * The main parse structure.
115: * This keeps any necessary information handy.
116: */
117: struct texi {
118: struct texifile files[64];
119: size_t filepos;
120: unsigned flags;
121: #define TEXI_IGN 0x01 /* don't print anything */
122: #define TEXI_HEADER (TEXI_IGN | 0x02) /* haven't seen @top yet */
123: #define TEXI_LITERAL 0x04 /* output all whitespace */
124: size_t outcol; /* column of output */
125: int outmacro; /* whether output is in line macro */
126: int seenws; /* whitespace has been ignored */
127: };
128:
129: #define ismpunct(_x) \
130: ('.' == (_x) || \
131: ',' == (_x) || \
132: ';' == (_x))
133:
134: static void doarg1(struct texi *, enum texicmd, const char *, size_t, size_t *);
135: static void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *);
136: static void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);
137: static void docommand(struct texi *, enum texicmd, const char *, size_t, size_t *);
138: static void doemph(struct texi *, enum texicmd, const char *, size_t, size_t *);
139: static void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);
140: static void dofile(struct texi *, enum texicmd, const char *, size_t, size_t *);
141: static void doifnottex(struct texi *, enum texicmd, const char *, size_t, size_t *);
142: static void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);
143: static void doignbracket(struct texi *, enum texicmd, const char *, size_t, size_t *);
144: static void doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);
145: static void doitalic(struct texi *, enum texicmd, const char *, size_t, size_t *);
146: static void doitem(struct texi *, enum texicmd, const char *, size_t, size_t *);
147: static void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *);
148: static void doliteral(struct texi *, enum texicmd, const char *, size_t, size_t *);
149: static void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);
150: static void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *);
151: static void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *);
152: static void dosection(struct texi *, enum texicmd, const char *, size_t, size_t *);
153: static void dosh(struct texi *, enum texicmd, const char *, size_t, size_t *);
154: static void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);
155: static void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);
156:
157: static const struct texitok texitoks[TEXICMD__MAX] = {
158: { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */
159: { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */
160: { dosymbol, "@", 1 }, /* TEXICMD_AT */
161: { dobye, "bye", 3 }, /* TEXICMD_BYE */
162: { dosh, "chapter", 7 }, /* TEXICMD_CHAPTER */
163: { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */
164: { doliteral, "code", 4 }, /* TEXICMD_CODE */
165: { docommand, "command", 7 }, /* TEXICMD_COMMAND */
166: { doignline, "c", 1 }, /* TEXICMD_COMMENT */
167: { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */
168: { doignblock, "copying", 7 }, /* TEXICMD_COPYING */
169: { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */
170: { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */
171: { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */
172: { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */
173: { doarg1, "email", 5 }, /* TEXICMD_EMAIL */
174: { doemph, "emph", 4 }, /* TEXICMD_EMPH */
175: { NULL, "end", 3 }, /* TEXICMD_END */
176: { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
177: { dofile, "file", 4 }, /* TEXICMD_FILE */
178: { doitalic, "i", 1 }, /* TEXICMD_I */
179: { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */
180: { doifnottex, "ifnottex", 8 }, /* TEXICMD_IFNOTTEX */
181: { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */
182: { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */
183: { doitem, "item", 4 }, /* TEXICMD_ITEM */
184: { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */
185: { doliteral, "kbd", 3 }, /* TEXICMD_KBD */
186: { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
187: { doignblock, "menu", 4 }, /* TEXICMD_MENU */
188: { doignline, "node", 4 }, /* TEXICMD_NODE */
189: { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */
190: { doignline, "paragraphindent", 14 }, /* TEXICMD_PARINDENT */
191: { dobracket, "ref", 3 }, /* TEXICMD_REF */
192: { doliteral, "samp", 4 }, /* TEXICMD_SAMP */
193: { dosection, "section", 7 }, /* TEXICMD_SECTION */
194: { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
195: { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */
196: { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */
197: { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
198: { dotable, "table", 5 }, /* TEXICMD_TABLE */
199: { doignblock, "tex", 3 }, /* TEXICMD_TEX */
200: { dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */
201: { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */
202: { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */
203: { dotop, "top", 3 }, /* TEXICMD_TOP */
204: { dosh, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
205: { doarg1, "url", 3 }, /* TEXICMD_URL */
206: { doliteral, "var", 3 }, /* TEXICMD_VAR */
207: };
208:
209: static void
210: texifilepop(struct texi *p)
211: {
212: struct texifile *f;
213:
214: assert(p->filepos > 0);
215: f = &p->files[--p->filepos];
216: munmap(f->map, f->mapsz);
217: }
218:
219: static void
220: texiexit(struct texi *p)
221: {
222:
223: while (p->filepos > 0)
224: texifilepop(p);
225: }
226:
227: static void
228: texifatal(struct texi *p, const char *errstring)
229: {
230:
231: perror(errstring);
232: texiexit(p);
233: exit(EXIT_FAILURE);
234: }
235:
236: /*
237: * Print a generic warning message (to stderr) tied to our current
238: * location in the parse sequence.
239: */
240: static void
241: texiwarn(const struct texi *p, const char *fmt, ...)
242: {
243: va_list ap;
244:
245: fprintf(stderr, "%s:%zu:%zu: ",
246: p->files[p->filepos - 1].name,
247: p->files[p->filepos - 1].line + 1,
248: p->files[p->filepos - 1].col + 1);
249: va_start(ap, fmt);
250: vfprintf(stderr, fmt, ap);
251: va_end(ap);
252: fputc('\n', stderr);
253: }
254:
255: /*
256: * Put a single data character.
257: * This MUST NOT be a mdoc(7) command: it should be free text that's
258: * outputted to the screen.
259: */
260: static void
261: texiputchar(struct texi *p, char c)
262: {
263:
264: if (TEXI_IGN & p->flags)
265: return;
266:
267: putchar(c);
268: if ('\n' == c) {
269: p->outcol = 0;
270: p->outmacro = 0;
271: p->seenws = 0;
272: } else
273: p->outcol++;
274: }
275:
276: /*
277: * Put multiple characters (see texiputchar()).
278: */
279: static void
280: texiputchars(struct texi *p, const char *s)
281: {
282:
283: while ('\0' != *s)
284: texiputchar(p, *s++);
285: }
286:
287: /*
288: * Put an mdoc(7) command without the trailing newline.
289: * This should ONLY be used for mdoc(7) commands!
290: */
291: static void
292: texifputs(struct texi *p, const char *s)
293: {
294: int rc;
295:
296: if (TEXI_IGN & p->flags)
297: return;
298: if (p->outcol)
299: texiputchar(p, '\n');
300: if (EOF != (rc = fputs(s, stdout)))
301: p->outcol += rc;
302: }
303:
304: /*
305: * Put an mdoc(7) command with the trailing newline.
306: * This should ONLY be used for mdoc(7) commands!
307: */
308: static void
309: teximacro(struct texi *p, const char *s)
310: {
311:
312: if (TEXI_IGN & p->flags)
313: return;
314: if (p->outcol)
315: texiputchar(p, '\n');
316: puts(s);
317: p->outcol = 0;
318: p->seenws = 0;
319: }
320:
321: /*
322: * Advance by a single byte in the input stream.
323: */
324: static void
325: advance(struct texi *p, const char *buf, size_t *pos)
326: {
327:
328: if ('\n' == buf[*pos]) {
329: p->files[p->filepos - 1].line++;
330: p->files[p->filepos - 1].col = 0;
331: } else
332: p->files[p->filepos - 1].col++;
333:
334: (*pos)++;
335: }
336:
337: /*
338: * Advance to the next non-whitespace word in the input stream.
339: * If we're in literal mode, then print all of the whitespace as we're
340: * doing so.
341: */
342: static size_t
343: advancenext(struct texi *p, const char *buf, size_t sz, size_t *pos)
344: {
345:
346: if (TEXI_LITERAL & p->flags) {
347: while (*pos < sz && isspace(buf[*pos])) {
348: texiputchar(p, buf[*pos]);
349: advance(p, buf, pos);
350: }
351: return(*pos);
352: }
353:
354: while (*pos < sz && isspace(buf[*pos])) {
355: p->seenws = 1;
356: /*
357: * If it looks like we've printed a double-line, then
358: * output a paragraph.
359: * FIXME: this is stupid.
360: */
361: if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])
362: teximacro(p, ".Pp");
363: advance(p, buf, pos);
364: }
365: return(*pos);
366: }
367:
368: /*
369: * Advance to the EOLN in the input stream.
370: */
371: static size_t
372: advanceeoln(struct texi *p, const char *buf, size_t sz, size_t *pos)
373: {
374:
375: while (*pos < sz && '\n' != buf[*pos])
376: advance(p, buf, pos);
377: return(*pos);
378: }
379:
380: /*
381: * Advance to position "end", which is an absolute position in the
382: * current buffer greater than or equal to the current position.
383: */
384: static void
385: advanceto(struct texi *p, const char *buf, size_t *pos, size_t end)
386: {
387:
388: assert(*pos <= end);
389: while (*pos < end)
390: advance(p, buf, pos);
391: }
392:
393: /*
394: * Output a free-form word in the input stream, progressing to the next
395: * command or white-space.
396: * This also will advance the input stream.
397: */
398: static void
399: texiword(struct texi *p, const char *buf, size_t sz, size_t *pos)
400: {
401:
402: /*
403: * XXX: if we're in literal mode, then we shouldn't do any
404: * reflowing of text here.
405: */
406: if (p->outcol > 72 && ! (TEXI_LITERAL & p->flags))
407: texiputchar(p, '\n');
408:
409: if (p->seenws && p->outcol && ! (TEXI_LITERAL & p->flags))
410: texiputchar(p, ' ');
411:
412: p->seenws = 0;
413:
414: while (*pos < sz && ! isspace(buf[*pos])) {
415: switch (buf[*pos]) {
416: case ('@'):
417: case ('}'):
418: case ('{'):
419: return;
420: }
421: if (*pos < sz - 1 &&
422: '`' == buf[*pos] &&
423: '`' == buf[*pos + 1]) {
424: texiputchars(p, "\\(lq");
425: advance(p, buf, pos);
426: } else if (*pos < sz - 1 &&
427: '\'' == buf[*pos] &&
428: '\'' == buf[*pos + 1]) {
429: texiputchars(p, "\\(rq");
430: advance(p, buf, pos);
431: } else
432: texiputchar(p, buf[*pos]);
433: advance(p, buf, pos);
434: }
435: }
436:
437: static enum texicmd
438: texicmd(struct texi *p, const char *buf,
439: size_t pos, size_t sz, size_t *end)
440: {
441: size_t i, len;
442:
443: assert('@' == buf[pos]);
444: for (*end = ++pos; *end < sz && ! isspace(buf[*end]); (*end)++)
445: if ('@' == buf[*end] || '{' == buf[*end])
446: break;
447:
448: len = *end - pos;
449: for (i = 0; i < TEXICMD__MAX; i++) {
450: if (len != texitoks[i].len)
451: continue;
452: if (0 == strncmp(texitoks[i].tok, &buf[pos], len))
453: return(i);
454: }
455:
456: texiwarn(p, "bad command: %.*s", (int)len, &buf[pos]);
457: return(TEXICMD__MAX);
458: }
459:
460: static void
461: parseeof(struct texi *p, const char *buf, size_t sz)
462: {
463: size_t pos = 0;
464: enum texicmd cmd;
465: size_t end;
466:
467: while ((pos = advancenext(p, buf, sz, &pos)) < sz) {
468: switch (buf[pos]) {
469: case ('}'):
470: texiwarn(p, "unexpected \"}\"");
471: advance(p, buf, &pos);
472: continue;
473: case ('{'):
474: texiwarn(p, "unexpected \"{\"");
475: advance(p, buf, &pos);
476: continue;
477: case ('@'):
478: break;
479: default:
480: texiword(p, buf, sz, &pos);
481: continue;
482: }
483:
484: cmd = texicmd(p, buf, pos, sz, &end);
485: advanceto(p, buf, &pos, end);
486: if (TEXICMD__MAX == cmd)
487: continue;
488: if (NULL != texitoks[cmd].fp)
489: (*texitoks[cmd].fp)(p, cmd, buf, sz, &pos);
490: }
491: }
492:
493: static void
494: parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)
495: {
496: size_t end;
497: enum texicmd cmd;
498:
499: if (*pos == sz || '{' != buf[*pos])
500: return;
501: advance(p, buf, pos);
502:
503: while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
504: switch (buf[*pos]) {
505: case ('}'):
506: advance(p, buf, pos);
507: return;
508: case ('{'):
509: texiwarn(p, "unexpected \"{\"");
510: advance(p, buf, pos);
511: continue;
512: case ('@'):
513: break;
514: default:
515: texiword(p, buf, sz, pos);
516: continue;
517: }
518:
519: cmd = texicmd(p, buf, *pos, sz, &end);
520: advanceto(p, buf, pos, end);
521: if (TEXICMD__MAX == cmd)
522: continue;
523: if (NULL != texitoks[cmd].fp)
524: (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
525: }
526: }
527:
528: static void
529: parseto(struct texi *p, const char *buf,
530: size_t sz, size_t *pos, const char *endtoken)
531: {
532: size_t end;
533: enum texicmd cmd;
534: size_t endtoksz;
535:
536: endtoksz = strlen(endtoken);
537: assert(endtoksz > 0);
538:
539: while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
540: switch (buf[*pos]) {
541: case ('}'):
542: texiwarn(p, "unexpected \"}\"");
543: advance(p, buf, pos);
544: continue;
545: case ('{'):
546: texiwarn(p, "unexpected \"{\"");
547: advance(p, buf, pos);
548: continue;
549: case ('@'):
550: break;
551: default:
552: texiword(p, buf, sz, pos);
553: continue;
554: }
555:
556: cmd = texicmd(p, buf, *pos, sz, &end);
557: advanceto(p, buf, pos, end);
558: if (TEXICMD_END == cmd) {
559: while (*pos < sz && ' ' == buf[*pos])
560: advance(p, buf, pos);
561: /*
562: * FIXME: skip tabs and also check the full
563: * word, not just its initial substring!
564: */
565: if (sz - *pos >= endtoksz && 0 == strncmp
566: (&buf[*pos], endtoken, endtoksz)) {
567: advanceeoln(p, buf, sz, pos);
568: break;
569: }
570: texiwarn(p, "unexpected \"end\"");
571: advanceeoln(p, buf, sz, pos);
572: continue;
573: } else if (TEXICMD__MAX != cmd)
574: if (NULL != texitoks[cmd].fp)
575: (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
576: }
577: }
578:
579: static void
580: doignblock(struct texi *p, enum texicmd cmd,
581: const char *buf, size_t sz, size_t *pos)
582: {
583: unsigned int sv = p->flags;
584: const char *blockname;
585:
586: p->flags |= TEXI_IGN;
587: switch (cmd) {
588: case (TEXICMD_COPYING):
589: blockname = "copying";
590: break;
591: case (TEXICMD_DETAILMENU):
592: blockname = "detailmenu";
593: break;
594: case (TEXICMD_DIRENTRY):
595: blockname = "direntry";
596: break;
597: case (TEXICMD_IFHTML):
598: blockname = "ifhtml";
599: break;
600: case (TEXICMD_IFTEX):
601: blockname = "iftex";
602: break;
603: case (TEXICMD_MENU):
604: blockname = "menu";
605: break;
606: case (TEXICMD_TEX):
607: blockname = "tex";
608: break;
609: case (TEXICMD_TITLEPAGE):
610: blockname = "titlepage";
611: break;
612: default:
613: abort();
614: }
615: parseto(p, buf, sz, pos, blockname);
616: p->flags = sv;
617: }
618:
619: static void
620: doifnottex(struct texi *p, enum texicmd cmd,
621: const char *buf, size_t sz, size_t *pos)
622: {
623:
624: parseto(p, buf, sz, pos, "ifnottex");
625: }
626:
627: static void
628: doinline(struct texi *p, const char *buf,
629: size_t sz, size_t *pos, const char *macro)
630: {
631:
632: if ( ! p->outmacro)
633: texifputs(p, ".");
634: texiputchars(p, macro);
635: texiputchar(p, ' ');
636: p->seenws = 0;
637: p->outmacro++;
638: parsebracket(p, buf, sz, pos);
639: p->outmacro--;
640: if (*pos < sz - 1 &&
641: ismpunct(buf[*pos]) &&
642: isspace(buf[*pos + 1])) {
643: texiputchar(p, ' ');
644: texiputchar(p, buf[*pos]);
645: advance(p, buf, pos);
646: }
647: if ( ! p->outmacro)
648: texiputchar(p, '\n');
649: }
650:
651: static void
652: doitalic(struct texi *p, enum texicmd cmd,
653: const char *buf, size_t sz, size_t *pos)
654: {
655:
656: texiputchars(p, "\\fI");
657: parsebracket(p, buf, sz, pos);
658: texiputchars(p, "\\fP");
659: }
660:
661: static void
662: doliteral(struct texi *p, enum texicmd cmd,
663: const char *buf, size_t sz, size_t *pos)
664: {
665:
666: if (TEXI_LITERAL & p->flags)
667: parsebracket(p, buf, sz, pos);
668: else
669: doinline(p, buf, sz, pos, "Li");
670: }
671:
672: static void
673: doemph(struct texi *p, enum texicmd cmd,
674: const char *buf, size_t sz, size_t *pos)
675: {
676:
677: if (TEXI_LITERAL & p->flags)
678: doitalic(p, cmd, buf, sz, pos);
679: else
680: doinline(p, buf, sz, pos, "Em");
681: }
682:
683: static void
684: docommand(struct texi *p, enum texicmd cmd,
685: const char *buf, size_t sz, size_t *pos)
686: {
687:
688: doinline(p, buf, sz, pos, "Xr");
689: }
690:
691: static void
692: dobracket(struct texi *p, enum texicmd cmd,
693: const char *buf, size_t sz, size_t *pos)
694: {
695:
696: parsebracket(p, buf, sz, pos);
697: }
698:
699: static void
700: dofile(struct texi *p, enum texicmd cmd,
701: const char *buf, size_t sz, size_t *pos)
702: {
703:
704: if (TEXI_LITERAL & p->flags)
705: parsebracket(p, buf, sz, pos);
706: else
707: doinline(p, buf, sz, pos, "Pa");
708: }
709:
710: static void
711: doexample(struct texi *p, enum texicmd cmd,
712: const char *buf, size_t sz, size_t *pos)
713: {
714: unsigned int sv;
715:
716: teximacro(p, ".Bd -literal");
717: advanceeoln(p, buf, sz, pos);
718: if ('\n' == buf[*pos])
719: advance(p, buf, pos);
720: sv = p->flags;
721: p->flags |= TEXI_LITERAL;
722: parseto(p, buf, sz, pos, "example");
723: p->flags = sv;
724: teximacro(p, ".Ed");
725: }
726:
727: static void
728: dobye(struct texi *p, enum texicmd cmd,
729: const char *buf, size_t sz, size_t *pos)
730: {
731:
732: texiexit(p);
733: exit(EXIT_SUCCESS);
734: }
735:
736: static void
737: dosymbol(struct texi *p, enum texicmd cmd,
738: const char *buf, size_t sz, size_t *pos)
739: {
740:
741: switch (cmd) {
742: case (TEXICMD_AT):
743: texiputchars(p, "@");
744: break;
745: case (TEXICMD_COPYRIGHT):
746: texiputchars(p, "\\(co");
747: break;
748: case (TEXICMD_LATEX):
749: texiputchars(p, "LaTeX");
750: break;
751: case (TEXICMD_TEXSYM):
752: texiputchars(p, "TeX");
753: break;
754: default:
755: abort();
756: }
757:
758: doignbracket(p, cmd, buf, sz, pos);
759: }
760:
761: static void
762: doquotation(struct texi *p, enum texicmd cmd,
763: const char *buf, size_t sz, size_t *pos)
764: {
765:
766: teximacro(p, ".Qo");
767: parseto(p, buf, sz, pos, "quotation");
768: teximacro(p, ".Qc");
769: }
770:
771: static void
772: doarg1(struct texi *p, enum texicmd cmd,
773: const char *buf, size_t sz, size_t *pos)
774: {
775:
776: if (*pos == sz || '{' != buf[*pos])
777: return;
778: advance(p, buf, pos);
779: if ( ! p->outmacro)
780: texifputs(p, ".");
781: switch (cmd) {
782: case (TEXICMD_EMAIL):
783: texiputchars(p, "Lk ");
784: break;
785: case (TEXICMD_URL):
786: texiputchars(p, "Mt ");
787: break;
788: default:
789: abort();
790: }
791: while (*pos < sz && '}' != buf[*pos] && ',' != buf[*pos]) {
792: texiputchar(p, buf[*pos]);
793: advance(p, buf, pos);
794: }
795: while (*pos < sz && '}' != buf[*pos])
796: advance(p, buf, pos);
797: if (*pos < sz)
798: advance(p, buf, pos);
799: if (*pos < sz - 1 &&
800: ismpunct(buf[*pos]) &&
801: isspace(buf[*pos + 1])) {
802: texiputchar(p, ' ');
803: texiputchar(p, buf[*pos]);
804: advance(p, buf, pos);
805: }
806: if ( ! p->outmacro)
807: texiputchar(p, '\n');
808: }
809:
810: static void
811: dosubsection(struct texi *p, enum texicmd cmd,
812: const char *buf, size_t sz, size_t *pos)
813: {
814:
815: if (TEXI_IGN & p->flags) {
816: advanceeoln(p, buf, sz, pos);
817: return;
818: }
819: while (*pos < sz && ' ' == buf[*pos])
820: advance(p, buf, pos);
821: texifputs(p, ".Pp");
822: while (*pos < sz && '\n' != buf[*pos]) {
823: texiputchar(p, buf[*pos]);
824: advance(p, buf, pos);
825: }
826: texifputs(p, ".Pp");
827: }
828:
829: static void
830: dosection(struct texi *p, enum texicmd cmd,
831: const char *buf, size_t sz, size_t *pos)
832: {
833:
834: if (TEXI_IGN & p->flags) {
835: advanceeoln(p, buf, sz, pos);
836: return;
837: }
838: while (*pos < sz && ' ' == buf[*pos])
839: advance(p, buf, pos);
840: texifputs(p, ".Ss ");
841: while (*pos < sz && '\n' != buf[*pos]) {
842: texiputchar(p, buf[*pos]);
843: advance(p, buf, pos);
844: }
845: texiputchar(p, '\n');
846: }
847:
848: static void
849: dosh(struct texi *p, enum texicmd cmd,
850: const char *buf, size_t sz, size_t *pos)
851: {
852:
853: if (TEXI_IGN & p->flags) {
854: advanceeoln(p, buf, sz, pos);
855: return;
856: }
857: while (*pos < sz && ' ' == buf[*pos])
858: advance(p, buf, pos);
859: texifputs(p, ".Sh ");
860: while (*pos < sz && '\n' != buf[*pos]) {
861: texiputchar(p, toupper(buf[*pos]));
862: advance(p, buf, pos);
863: }
864: texiputchar(p, '\n');
865: }
866:
867: static void
868: dotop(struct texi *p, enum texicmd cmd,
869: const char *buf, size_t sz, size_t *pos)
870: {
871:
872: p->flags &= ~TEXI_HEADER;
873: advanceeoln(p, buf, sz, pos);
874: teximacro(p, ".Dd $Mdocdate$");
875: teximacro(p, ".Dt SOMETHING 7");
876: teximacro(p, ".Os");
877: teximacro(p, ".Sh NAME");
878: teximacro(p, ".Nm Something");
879: teximacro(p, ".Nd Something");
880: }
881:
882: static void
883: doitem(struct texi *p, enum texicmd cmd,
884: const char *buf, size_t sz, size_t *pos)
885: {
886: size_t end;
887:
888: /* See if we have arguments... */
889: for (end = *pos; end < sz; end++)
890: if (' ' != buf[end] && '\t' != buf[end])
891: break;
892:
893: /* If we have arguments, print them too. */
894: if ('\n' != buf[end]) {
895: texifputs(p, ".It");
896: /* FIXME: process commands. */
897: while (*pos < sz && '\n' != buf[*pos]) {
898: texiputchar(p, buf[*pos]);
899: advance(p, buf, pos);
900: }
901: texiputchar(p, '\n');
902: } else
903: teximacro(p, ".It");
904: }
905:
906: static void
907: dotable(struct texi *p, enum texicmd cmd,
908: const char *buf, size_t sz, size_t *pos)
909: {
910:
911: teximacro(p, ".Bl -tag -width Ds");
912: parseto(p, buf, sz, pos, "table");
913: teximacro(p, ".El");
914: }
915:
916: static void
917: doitemize(struct texi *p, enum texicmd cmd,
918: const char *buf, size_t sz, size_t *pos)
919: {
920:
921: teximacro(p, ".Bl -bullet");
922: parseto(p, buf, sz, pos, "itemize");
923: teximacro(p, ".El");
924: }
925:
926: static void
927: doignbracket(struct texi *p, enum texicmd cmd,
928: const char *buf, size_t sz, size_t *pos)
929: {
930: unsigned int sv = p->flags;
931:
932: p->flags |= TEXI_IGN;
933: parsebracket(p, buf, sz, pos);
934: p->flags = sv;
935: }
936:
937: static void
938: doignline(struct texi *p, enum texicmd cmd,
939: const char *buf, size_t sz, size_t *pos)
940: {
941:
942: advanceeoln(p, buf, sz, pos);
943: if (*pos < sz)
944: advance(p, buf, pos);
945: }
946:
947: static int
948: parsefile(struct texi *p, const char *fname)
949: {
950: struct texifile *f;
951: int fd;
952: struct stat st;
953:
954: assert(p->filepos < 64);
955: f = &p->files[p->filepos];
956: memset(f, 0, sizeof(struct texifile));
957:
958: f->name = fname;
959: if (-1 == (fd = open(fname, O_RDONLY, 0))) {
960: texifatal(p, fname);
961: } else if (-1 == fstat(fd, &st)) {
962: close(fd);
963: texifatal(p, fname);
964: }
965:
966: f->mapsz = st.st_size;
967: f->map = mmap(NULL, f->mapsz,
968: PROT_READ, MAP_SHARED, fd, 0);
969: close(fd);
970:
971: if (MAP_FAILED == f->map) {
972: texifatal(p, fname);
973: return(0);
974: }
975:
976: p->filepos++;
977: parseeof(p, f->map, f->mapsz);
978: texifilepop(p);
979: return(1);
980: }
981:
982: int
983: main(int argc, char *argv[])
984: {
985: struct texi texi;
986: int c, rc;
987: const char *progname;
988:
989: progname = strrchr(argv[0], '/');
990: if (progname == NULL)
991: progname = argv[0];
992: else
993: ++progname;
994:
995: while (-1 != (c = getopt(argc, argv, "")))
996: switch (c) {
997: default:
998: goto usage;
999: }
1000:
1001: argv += optind;
1002: if (0 == (argc -= optind))
1003: goto usage;
1004:
1005: memset(&texi, 0, sizeof(struct texi));
1006: texi.flags = TEXI_HEADER;
1007: rc = parsefile(&texi, argv[0]);
1008: return(rc ? EXIT_SUCCESS : EXIT_FAILURE);
1009:
1010: usage:
1011: fprintf(stderr, "usage: %s file\n", progname);
1012: return(EXIT_FAILURE);
1013: }