Annotation of texi2mdoc/main.c, Revision 1.60
1.60 ! kristaps 1: /* $Id: main.c,v 1.59 2015/03/03 15:04:24 kristaps Exp $ */
1.1 kristaps 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: */
1.37 kristaps 17: #if defined(__linux__) || defined(__MINT__)
18: # define _GNU_SOURCE /* memmem */
19: #endif
1.1 kristaps 20: #include <assert.h>
21: #include <ctype.h>
22: #include <getopt.h>
1.2 kristaps 23: #include <libgen.h>
24: #include <limits.h>
1.1 kristaps 25: #include <stdarg.h>
26: #include <stdio.h>
27: #include <stdlib.h>
28: #include <string.h>
1.47 kristaps 29: #include <unistd.h>
1.1 kristaps 30:
1.24 kristaps 31: #include "extern.h"
1.1 kristaps 32:
1.23 kristaps 33: #define SECTSZ 4
34: static const char *const sects[SECTSZ] = {
35: "Sh",
36: "Ss",
37: "Em",
38: "No",
39: };
40:
1.46 kristaps 41: static void doaccent(struct texi *, enum texicmd, size_t *);
42: static void doblock(struct texi *, enum texicmd, size_t *);
43: static void dobracket(struct texi *, enum texicmd, size_t *);
44: static void dobye(struct texi *, enum texicmd, size_t *);
45: static void dodefindex(struct texi *, enum texicmd, size_t *);
46: static void dodefn(struct texi *, enum texicmd, size_t *);
47: static void dodisplay(struct texi *, enum texicmd, size_t *);
48: static void doend(struct texi *, enum texicmd, size_t *);
49: static void doenumerate(struct texi *, enum texicmd, size_t *);
50: static void doexample(struct texi *, enum texicmd, size_t *);
51: static void doignargn(struct texi *, enum texicmd, size_t *);
52: static void doignblock(struct texi *, enum texicmd, size_t *);
53: static void doignbracket(struct texi *, enum texicmd, size_t *);
54: static void doignline(struct texi *, enum texicmd, size_t *);
55: static void doinline(struct texi *, enum texicmd, size_t *);
56: static void doinclude(struct texi *, enum texicmd, size_t *);
57: static void doitem(struct texi *, enum texicmd, size_t *);
58: static void doitemize(struct texi *, enum texicmd, size_t *);
59: static void dolink(struct texi *, enum texicmd, size_t *);
60: static void domacro(struct texi *, enum texicmd, size_t *);
61: static void domath(struct texi *, enum texicmd, size_t *);
62: static void domultitable(struct texi *, enum texicmd, size_t *);
63: static void doquotation(struct texi *, enum texicmd, size_t *);
64: static void dotable(struct texi *, enum texicmd, size_t *);
65: static void dotop(struct texi *, enum texicmd, size_t *);
66: static void dosecoffs(struct texi *, enum texicmd, size_t *);
67: static void dosection(struct texi *, enum texicmd, size_t *);
68: static void dosp(struct texi *, enum texicmd, size_t *);
69: static void dosubsection(struct texi *, enum texicmd, size_t *);
70: static void dosubsubsection(struct texi *, enum texicmd, size_t *);
71: static void dosymbol(struct texi *, enum texicmd, size_t *);
72: static void dotab(struct texi *, enum texicmd, size_t *);
73: static void dotitle(struct texi *, enum texicmd, size_t *);
74: static void dovalue(struct texi *, enum texicmd, size_t *);
75: static void doverb(struct texi *, enum texicmd, size_t *);
76: static void doverbatim(struct texi *, enum texicmd, size_t *);
77: static void doverbinclude(struct texi *, enum texicmd, size_t *);
1.1 kristaps 78:
1.24 kristaps 79: static const struct texitok __texitoks[TEXICMD__MAX] = {
1.20 kristaps 80: /* TEXICMD__BEGIN */
1.42 kristaps 81: { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */
82: { dosymbol, "AA", 2 }, /* TEXICMD_AA */
83: { dosymbol, "aa", 2 }, /* TEXICMD_AASMALL */
1.8 kristaps 84: { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */
1.16 kristaps 85: { doaccent, "'", 1 }, /* TEXICMD_ACUTE */
1.42 kristaps 86: { dosymbol, "AE", 2 }, /* TEXICMD_AE */
87: { dosymbol, "ae", 2 }, /* TEXICMD_AESMALL */
1.1 kristaps 88: { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */
1.12 kristaps 89: { dosection, "appendix", 8 }, /* TEXICMD_APPENDIX */
90: { dosection, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */
1.20 kristaps 91: { dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */
1.23 kristaps 92: { dosubsubsection, "appendixsubsubsec", 17 }, /* TEXICMD_APPENDIXSUBSUBSEC */
1.25 kristaps 93: { doinline, "asis", 4 }, /* TEXICMD_ASIS */
1.3 kristaps 94: { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */
1.1 kristaps 95: { dosymbol, "@", 1 }, /* TEXICMD_AT */
1.3 kristaps 96: { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
1.59 kristaps 97: { doinline, "b", 1 }, /* TEXICMD_B */
98: { dosymbol, "\\", 1 }, /* TEXICMD_BACKSLASH */
1.3 kristaps 99: { dosymbol, "!", 1 }, /* TEXICMD_BANG */
1.7 kristaps 100: { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */
1.1 kristaps 101: { dobye, "bye", 3 }, /* TEXICMD_BYE */
1.34 kristaps 102: { doblock, "cartouche", 9 }, /* TEXICMD_CARTOUCHE */
103: { doaccent, ",", 1 }, /* TEXICMD_CEDILLA */
1.12 kristaps 104: { doignline, "center", 6 }, /* TEXICMD_CENTER */
105: { dosection, "chapter", 7 }, /* TEXICMD_CHAPTER */
1.1 kristaps 106: { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */
1.16 kristaps 107: { doaccent, "^", 1 }, /* TEXICMD_CIRCUMFLEX */
1.24 kristaps 108: { doinline, "cite", 4 }, /* TEXICMD_CITE */
109: { dovalue, "clear", 5 }, /* TEXICMD_CLEAR */
1.21 kristaps 110: { doinline, "code", 4 }, /* TEXICMD_CODE */
1.3 kristaps 111: { dosymbol, ":", 1 }, /* TEXICMD_COLON */
1.18 kristaps 112: { NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */
1.35 kristaps 113: { dosymbol, "comma", 5 }, /* TEXICMD_COMMA */
1.12 kristaps 114: { doinline, "command", 7 }, /* TEXICMD_COMMAND */
1.1 kristaps 115: { doignline, "c", 1 }, /* TEXICMD_COMMENT */
1.2 kristaps 116: { doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */
1.1 kristaps 117: { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */
118: { doignblock, "copying", 7 }, /* TEXICMD_COPYING */
119: { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */
1.27 kristaps 120: { dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */
1.15 kristaps 121: { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */
122: { dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */
1.27 kristaps 123: { dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */
1.15 kristaps 124: { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */
125: { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */
126: { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */
127: { dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */
128: { dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */
129: { dodefn, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */
130: { dodefn, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */
131: { dodefn, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */
1.34 kristaps 132: { dodefn, "deftypemethod", 13 }, /* TEXICMD_DEFTYPEMETHOD */
133: { dodefn, "deftypemethodx", 14 }, /* TEXICMD_DEFTYPEMETHODX */
1.15 kristaps 134: { dodefn, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */
135: { dodefn, "deftypevarx", 11 }, /* TEXICMD_DEFTYPEVARX */
136: { dodefn, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */
137: { dodefn, "deftypevrx", 10 }, /* TEXICMD_DEFTYPEVRX */
138: { dodefn, "defun", 5 }, /* TEXICMD_DEFUN */
139: { dodefn, "defunx", 6 }, /* TEXICMD_DEFUNX */
140: { dodefn, "defvar", 6 }, /* TEXICMD_DEFVAR */
141: { dodefn, "defvarx", 7 }, /* TEXICMD_DEFVARX */
142: { dodefn, "defvr", 5 }, /* TEXICMD_DEFVR */
143: { dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */
1.1 kristaps 144: { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */
1.21 kristaps 145: { doinline, "dfn", 3 }, /* TEXICMD_DFN */
1.42 kristaps 146: { dosymbol, "DH", 2 }, /* TEXICMD_DH */
147: { dosymbol, "dh", 2 }, /* TEXICMD_DHSMALL */
1.1 kristaps 148: { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */
149: { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */
1.3 kristaps 150: { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */
1.28 kristaps 151: { doignbracket, "dmn", 3 }, /* TEXICMD_DMN */
1.40 kristaps 152: { doignblock, "documentdescription", 19 }, /* TEXICMD_DOCUMENTDESCRIPTION */
153: { doignline, "documentencoding", 16 }, /* TEXICMD_DOCUMENTENCODING */
1.44 kristaps 154: { doignline, "documentlanguage", 16 }, /* TEXICMD_DOCUMENTLANGUAGE */
1.42 kristaps 155: { doaccent, "dotaccent", 9 }, /* TEXICMD_DOTACCENT */
156: { doaccent, "dotless", 7 }, /* TEXICMD_DOTLESS */
1.2 kristaps 157: { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */
1.8 kristaps 158: { dolink, "email", 5 }, /* TEXICMD_EMAIL */
1.21 kristaps 159: { doinline, "emph", 4 }, /* TEXICMD_EMPH */
1.44 kristaps 160: { doend, "end", 3 }, /* TEXICMD_END */
1.34 kristaps 161: { dosymbol, "enddots", 7 }, /* TEXICMD_ENDDOTS */
1.2 kristaps 162: { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */
1.12 kristaps 163: { doinline, "env", 3 }, /* TEXICMD_ENV */
1.28 kristaps 164: { dosymbol, "equiv", 5 }, /* TEXICMD_EQUIV */
1.15 kristaps 165: { dosymbol, "error", 5 }, /* TEXICMD_ERROR */
1.43 kristaps 166: { dosymbol, "euro", 4 }, /* TEXICMD_EURO */
1.1 kristaps 167: { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
1.42 kristaps 168: { dosymbol, "exclamdown", 10 }, /* TEXICMD_EXCLAMDOWN */
1.25 kristaps 169: { doignline, "exdent", 6 }, /* TEXICMD_EXDENT */
1.17 kristaps 170: { dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */
1.12 kristaps 171: { doinline, "file", 4 }, /* TEXICMD_FILE */
1.17 kristaps 172: { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */
1.20 kristaps 173: { doignline, "findex", 6 }, /* TEXICMD_FINDEX */
1.44 kristaps 174: { doblock, "flushleft", 9 }, /* TEXICMD_FLUSHLEFT */
175: { doblock, "flushright", 10 }, /* TEXICMD_FLUSHRIGHT */
176: { doignline, "firstparagraphindent", 20 }, /* TEXICMD_FIRSTPARAGRAPHINDENT */
1.32 kristaps 177: { doignbracket, "footnote", 8 }, /* TEXICMD_FOOTNOTE */
1.44 kristaps 178: { doignline, "footnotestyle", 13 }, /* TEXICMD_FOOTNOTESTYLE */
1.20 kristaps 179: { dotable, "ftable", 6 }, /* TEXICMD_FTABLE */
180: { dodisplay, "format", 6 }, /* TEXICMD_FORMAT */
1.43 kristaps 181: { dosymbol, "geq", 3 }, /* TEXICMD_GEQ */
1.16 kristaps 182: { doaccent, "`", 1 }, /* TEXICMD_GRAVE */
1.3 kristaps 183: { doblock, "group", 5 }, /* TEXICMD_GROUP */
1.43 kristaps 184: { dosymbol, "guillemetleft", 13 }, /* TEXICMD_GUILLEMETLEFT */
185: { dosymbol, "guillemetright", 14 }, /* TEXICMD_GUILLEMETRIGHT */
186: { dosymbol, "guillemotleft", 13 }, /* TEXICMD_GUILLEMOTLEFT */
187: { dosymbol, "guillemotright", 14 }, /* TEXICMD_GUILLEMOTRIGHT */
188: { dosymbol, "guilsinglleft", 13 }, /* TEXICMD_GUILSINGLLEFT */
189: { dosymbol, "guilsinglright", 14 }, /* TEXICMD_GUILSINGLRIGHT */
1.42 kristaps 190: { doaccent, "H", 1 }, /* TEXICMD_H */
1.2 kristaps 191: { dosection, "heading", 7 }, /* TEXICMD_HEADING */
1.3 kristaps 192: { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */
1.18 kristaps 193: { doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */
1.25 kristaps 194: { doignblock, "html", 4 }, /* TEXICMD_HTML */
1.3 kristaps 195: { dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */
1.21 kristaps 196: { doinline, "i", 1 }, /* TEXICMD_I */
1.24 kristaps 197: { dovalue, "ifclear", 7 }, /* TEXICMD_IFCLEAR */
1.14 kristaps 198: { doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */
1.1 kristaps 199: { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */
1.26 kristaps 200: { doblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */
1.14 kristaps 201: { doblock, "ifnotdocbook", 12 }, /* TEXICMD_IFNOTDOCBOOK */
202: { doblock, "ifnothtml", 9 }, /* TEXICMD_IFNOTHTML */
203: { doblock, "ifnotinfo", 9 }, /* TEXICMD_IFNOTINFO */
204: { doignblock, "ifnotplaintext", 14 }, /* TEXICMD_IFNOTPLAINTEXT */
1.3 kristaps 205: { doblock, "ifnottex", 8 }, /* TEXICMD_IFNOTTEX */
1.14 kristaps 206: { doblock, "ifnotxml", 8 }, /* TEXICMD_IFNOTXML */
207: { doblock, "ifplaintext", 11 }, /* TEXICMD_IFPLAINTEXT */
1.1 kristaps 208: { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */
1.30 kristaps 209: { dovalue, "ifset", 5 }, /* TEXICMD_IFSET */
1.14 kristaps 210: { doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */
1.17 kristaps 211: { doignblock, "ignore", 6 }, /* TEXICMD_IGNORE */
1.1 kristaps 212: { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */
1.2 kristaps 213: { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */
1.13 kristaps 214: { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */
1.44 kristaps 215: { dolink, "indicateurl", 11 }, /* TEXICMD_INDICATEURL */
216: { dolink, "inforef", 7 }, /* TEXICMD_INFOREF */
1.5 kristaps 217: { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */
1.1 kristaps 218: { doitem, "item", 4 }, /* TEXICMD_ITEM */
219: { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */
1.20 kristaps 220: { doitem, "itemx", 5 }, /* TEXICMD_ITEMX */
1.21 kristaps 221: { doinline, "kbd", 3 }, /* TEXICMD_KBD */
1.18 kristaps 222: { dobracket, "key", 3 }, /* TEXICMD_KEY */
1.20 kristaps 223: { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */
1.42 kristaps 224: { dosymbol, "L", 1 }, /* TEXICMD_L */
1.1 kristaps 225: { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
1.43 kristaps 226: { dosymbol, "leq", 3 }, /* TEXICMD_LEQ */
1.23 kristaps 227: { dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */
1.42 kristaps 228: { dosymbol, "l", 1 }, /* TEXICMD_LSMALL */
1.30 kristaps 229: { domacro, "macro", 5 }, /* TEXICMD_MACRO */
1.42 kristaps 230: { doaccent, "=", 1 }, /* TEXICMD_MACRON */
1.3 kristaps 231: { domath, "math", 4 }, /* TEXICMD_MATH */
1.1 kristaps 232: { doignblock, "menu", 4 }, /* TEXICMD_MENU */
1.25 kristaps 233: { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */
1.18 kristaps 234: { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */
1.15 kristaps 235: { doignline, "need", 4 }, /* TEXICMD_NEED */
1.3 kristaps 236: { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
1.1 kristaps 237: { doignline, "node", 4 }, /* TEXICMD_NODE */
1.3 kristaps 238: { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */
1.42 kristaps 239: { dosymbol, "O", 1 }, /* TEXICMD_O */
240: { dosymbol, "OE", 2 }, /* TEXICMD_OE */
241: { dosymbol, "oe", 2 }, /* TEXICMD_OESMALL */
242: { doaccent, "ogonek", 6 }, /* TEXICMD_OGONEK */
1.16 kristaps 243: { doinline, "option", 6 }, /* TEXICMD_OPTION */
1.42 kristaps 244: { dosymbol, "ordf", 4 }, /* TEXICMD_ORDF */
245: { dosymbol, "ordm", 4 }, /* TEXICMD_ORDM */
246: { dosymbol, "o", 1 }, /* TEXICMD_OSMALL */
1.3 kristaps 247: { doignline, "page", 4 }, /* TEXICMD_PAGE */
1.25 kristaps 248: { doignline, "paragraphindent", 15 }, /* TEXICMD_PARINDENT */
249: { dosymbol, ".", 1 }, /* TEXICMD_PERIOD */
1.28 kristaps 250: { doignline, "pindex", 6 }, /* TEXICMD_PINDEX */
1.43 kristaps 251: { dosymbol, "pounds", 6 }, /* TEXICMD_POUNDS */
1.2 kristaps 252: { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */
1.42 kristaps 253: { dolink, "pxref", 5 }, /* TEXICMD_PXREF */
254: { dosymbol, "questiondown", 12 }, /* TEXICMD_QUESTIONDOWN */
255: { dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */
256: { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */
1.43 kristaps 257: { dosymbol, "quotedblbase", 12 }, /* TEXICMD_QUOTEDBLBASE */
258: { dosymbol, "quotedblleft", 12 }, /* TEXICMD_QUOTEDBLLEFT */
259: { dosymbol, "quotedblright", 13 }, /* TEXICMD_QUOTEDBLRIGHT */
260: { dosymbol, "quotesinglbase", 14 }, /* TEXICMD_QUOTESINGLBASE */
261: { dosymbol, "quoteleft", 9 }, /* TEXICMD_QUOTELEFT */
262: { dosymbol, "quoteright", 10 }, /* TEXICMD_QUOTERIGHT */
1.21 kristaps 263: { doinline, "r", 1 }, /* TEXICMD_R */
1.23 kristaps 264: { dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */
1.1 kristaps 265: { dobracket, "ref", 3 }, /* TEXICMD_REF */
1.28 kristaps 266: { doignline, "refill", 6 }, /* TEXICMD_REFILL */
1.43 kristaps 267: { dosymbol, "registeredsymbol", 16 }, /* TEXICMD_REGISTEREDSYMBOL */
1.15 kristaps 268: { dosymbol, "result", 6 }, /* TEXICMD_RESULT */
1.42 kristaps 269: { doaccent, "ringaccent", 10 }, /* TEXICMD_RINGACCENT */
1.21 kristaps 270: { doinline, "samp", 4 }, /* TEXICMD_SAMP */
271: { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
1.58 kristaps 272: { doinline, "sc", 2 }, /* TEXICMD_SC */
1.1 kristaps 273: { dosection, "section", 7 }, /* TEXICMD_SECTION */
1.24 kristaps 274: { dovalue, "set", 3 }, /* TEXICMD_SET */
1.1 kristaps 275: { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
1.35 kristaps 276: { doignline, "setcontentsaftertitlepage", 25 }, /* TEXICMD_SETCONTENTSAFTER */
1.1 kristaps 277: { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */
1.10 kristaps 278: { dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */
1.25 kristaps 279: { doignline, "shortcontents", 13 }, /* TEXICMD_SHORTCONTENTS */
1.21 kristaps 280: { doinline, "slanted", 7 }, /* TEXICMD_SLANTED */
1.34 kristaps 281: { dosymbol, "/", 1 }, /* TEXICMD_SLASH */
1.3 kristaps 282: { dosp, "sp", 2 }, /* TEXICMD_SP */
283: { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
1.17 kristaps 284: { doignline, "smallbook", 9 }, /* TEXICMD_SMALLBOOK */
1.12 kristaps 285: { dodisplay, "smalldisplay", 12 }, /* TEXICMD_SMALLDISPLAY */
1.3 kristaps 286: { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */
1.20 kristaps 287: { dodisplay, "smallformat", 11 }, /* TEXICMD_SMALLFORMAT */
1.13 kristaps 288: { dodisplay, "smallindentblock", 16 }, /* TEXICMD_SMALLINDENTBLOCK */
1.3 kristaps 289: { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */
290: { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */
1.35 kristaps 291: { dosymbol, "ss", 2 }, /* TEXICMD_SS */
1.21 kristaps 292: { doinline, "strong", 6 }, /* TEXICMD_STRONG */
1.20 kristaps 293: { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */
1.1 kristaps 294: { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
1.28 kristaps 295: { dosubsubsection, "subsubheading", 13 }, /* TEXICMD_SUBSUBHEADING */
1.23 kristaps 296: { dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */
1.3 kristaps 297: { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
1.25 kristaps 298: { doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */
1.50 kristaps 299: { dodefindex, "synindex", 8 }, /* TEXICMD_SYNINDEX */
300: { dodefindex, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
1.21 kristaps 301: { doinline, "t", 1 }, /* TEXICMD_T */
1.18 kristaps 302: { dotab, "tab", 3 }, /* TEXICMD_TAB */
303: { dosymbol, "\t", 1 }, /* TEXICMD_TABSYM */
1.1 kristaps 304: { dotable, "table", 5 }, /* TEXICMD_TABLE */
305: { doignblock, "tex", 3 }, /* TEXICMD_TEX */
306: { dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */
1.43 kristaps 307: { dosymbol, "textdegree", 10 }, /* TEXICMD_TEXTDEGREE */
1.42 kristaps 308: { dosymbol, "TH", 2 }, /* TEXICMD_TH */
309: { dosymbol, "th", 2 }, /* TEXICMD_THSMALL */
1.35 kristaps 310: { dosymbol, "tie", 3 }, /* TEXICMD_TIE */
1.42 kristaps 311: { doaccent, "tieaccent", 9 }, /* TEXICMD_TIEACCENT */
1.16 kristaps 312: { doaccent, "~", 1 }, /* TEXICMD_TILDE */
1.25 kristaps 313: { doignline, "tindex", 6 }, /* TEXICMD_TINDEX */
1.3 kristaps 314: { doignline, "title", 5 }, /* TEXICMD_TITLE */
1.1 kristaps 315: { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */
316: { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */
317: { dotop, "top", 3 }, /* TEXICMD_TOP */
1.42 kristaps 318: { doaccent, "u", 1 }, /* TEXICMD_U */
319: { doaccent, "ubaraccent", 10 }, /* TEXICMD_UBARACCENT */
320: { doaccent, "udotaccent", 10 }, /* TEXICMD_UDOTACCENT */
1.16 kristaps 321: { doaccent, "\"", 1 }, /* TEXICMD_UMLAUT */
1.12 kristaps 322: { dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
1.2 kristaps 323: { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */
1.20 kristaps 324: { dosubsection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */
1.23 kristaps 325: { dosubsubsection, "unnumberedsubsubsec", 19 }, /* TEXICMD_UNNUMBEREDSUBSUBSEC */
1.8 kristaps 326: { dolink, "uref", 4 }, /* TEXICMD_UREF */
327: { dolink, "url", 3 }, /* TEXICMD_URL */
1.34 kristaps 328: { doignline, "", 0 }, /* TEXICMD_USER_INDEX */
1.42 kristaps 329: { doaccent, "v", 1 }, /* TEXICMD_V */
1.24 kristaps 330: { dovalue, "value", 5 }, /* TEXICMD_VALUE */
1.12 kristaps 331: { doinline, "var", 3 }, /* TEXICMD_VAR */
1.33 kristaps 332: { doverb, "verb", 4 }, /* TEXICMD_VERB */
333: { doverbatim, "verbatim", 8 }, /* TEXICMD_VERBATIM */
1.16 kristaps 334: { doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */
1.18 kristaps 335: { doignline, "vindex", 6 }, /* TEXICMD_VINDEX */
1.9 kristaps 336: { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */
1.20 kristaps 337: { dotable, "vtable", 6 }, /* TEXICMD_VTABLE */
1.3 kristaps 338: { dobracket, "w", 1 }, /* TEXICMD_W */
1.8 kristaps 339: { dolink, "xref", 4 }, /* TEXICMD_XREF */
1.20 kristaps 340: /* TEXICMD__END */
1.1 kristaps 341: };
342:
1.24 kristaps 343: const struct texitok *const texitoks = __texitoks;
1.18 kristaps 344:
1.60 ! kristaps 345: /*
! 346: * Texinfo has lots of indexes.
! 347: * You can add new ones in a variety of ways.
! 348: * We maintain an array of all of these index names (usually a few
! 349: * letters) and pass unknown commands through the array list.
! 350: */
1.2 kristaps 351: static void
1.46 kristaps 352: dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)
1.27 kristaps 353: {
354: size_t start, end;
355: char *cp;
356:
1.46 kristaps 357: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
358: advance(p, pos);
1.27 kristaps 359: start = end = *pos;
1.46 kristaps 360: while (end < BUFSZ(p) && ! ismspace(BUF(p)[end]))
1.27 kristaps 361: end++;
362:
363: if (start == end) {
1.46 kristaps 364: advanceeoln(p, pos, 1);
1.27 kristaps 365: return;
1.60 ! kristaps 366: }
! 367:
! 368: if (NULL == (cp = malloc(end - start + 1)))
1.27 kristaps 369: texiabort(p, NULL);
1.46 kristaps 370: memcpy(cp, &BUF(p)[start], end - start);
1.27 kristaps 371: cp[end - start] = '\0';
372:
1.60 ! kristaps 373: /* FIXME: use reallocarray(). */
1.27 kristaps 374: p->indexs = realloc(p->indexs,
375: sizeof(char *) * (p->indexsz + 1));
376: if (NULL == p->indexs)
377: texiabort(p, NULL);
378: p->indexs[p->indexsz++] = cp;
1.60 ! kristaps 379:
! 380: advanceeoln(p, pos, 1);
1.27 kristaps 381: }
382:
383: static void
1.46 kristaps 384: dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
1.3 kristaps 385: {
386: const char *blk;
387:
1.5 kristaps 388: blk = NULL;
1.3 kristaps 389: switch (cmd) {
1.15 kristaps 390: case (TEXICMD_DEFFN):
1.35 kristaps 391: case (TEXICMD_DEFMAC):
1.15 kristaps 392: case (TEXICMD_DEFTP):
1.3 kristaps 393: case (TEXICMD_DEFTYPEFN):
394: case (TEXICMD_DEFTYPEFUN):
1.34 kristaps 395: case (TEXICMD_DEFTYPEMETHOD):
1.15 kristaps 396: case (TEXICMD_DEFTYPEVAR):
397: case (TEXICMD_DEFTYPEVR):
398: case (TEXICMD_DEFUN):
399: case (TEXICMD_DEFVAR):
400: case (TEXICMD_DEFVR):
1.5 kristaps 401: blk = texitoks[cmd].tok;
1.3 kristaps 402: break;
1.5 kristaps 403: default:
1.3 kristaps 404: break;
405: }
406:
407: if (p->ign) {
1.15 kristaps 408: NULL != blk ?
1.46 kristaps 409: parseto(p, pos, blk) :
410: parseeoln(p, pos);
1.3 kristaps 411: return;
412: }
413:
1.15 kristaps 414: if (NULL != blk)
415: texivspace(p);
416:
1.3 kristaps 417: switch (cmd) {
1.34 kristaps 418: case (TEXICMD_DEFTYPEMETHOD):
419: case (TEXICMD_DEFTYPEMETHODX):
420: texiputchars(p, "Method");
421: break;
1.15 kristaps 422: case (TEXICMD_DEFMAC):
423: case (TEXICMD_DEFMACX):
424: texiputchars(p, "Macro");
425: break;
426: case (TEXICMD_DEFTYPEVAR):
427: case (TEXICMD_DEFTYPEVARX):
428: case (TEXICMD_DEFVAR):
429: case (TEXICMD_DEFVARX):
430: texiputchars(p, "Variable");
431: break;
1.3 kristaps 432: case (TEXICMD_DEFTYPEFUN):
1.15 kristaps 433: case (TEXICMD_DEFTYPEFUNX):
434: case (TEXICMD_DEFUN):
435: case (TEXICMD_DEFUNX):
436: texiputchars(p, "Function");
1.3 kristaps 437: break;
438: default:
1.46 kristaps 439: parselinearg(p, pos);
1.3 kristaps 440: break;
441: }
1.15 kristaps 442:
1.48 kristaps 443: texiputchar(p, ':');
444: texiputchar(p, '\n');
1.15 kristaps 445:
446: switch (cmd) {
447: case (TEXICMD_DEFMAC):
448: case (TEXICMD_DEFMACX):
449: teximacroopen(p, "Dv");
1.46 kristaps 450: while (parselinearg(p, pos))
1.15 kristaps 451: /* Spin. */ ;
452: teximacroclose(p);
453: break;
454: case (TEXICMD_DEFFN):
455: case (TEXICMD_DEFFNX):
456: case (TEXICMD_DEFUN):
457: case (TEXICMD_DEFUNX):
458: teximacroopen(p, "Fo");
1.46 kristaps 459: parselinearg(p, pos);
1.15 kristaps 460: teximacroclose(p);
461: teximacroopen(p, "Fa");
1.46 kristaps 462: while (parselinearg(p, pos))
1.15 kristaps 463: /* Spin. */ ;
464: teximacroclose(p);
465: teximacro(p, "Fc");
466: break;
467: case (TEXICMD_DEFTYPEFUN):
468: case (TEXICMD_DEFTYPEFUNX):
469: case (TEXICMD_DEFTYPEFN):
470: case (TEXICMD_DEFTYPEFNX):
1.34 kristaps 471: case (TEXICMD_DEFTYPEMETHOD):
472: case (TEXICMD_DEFTYPEMETHODX):
1.15 kristaps 473: teximacroopen(p, "Ft");
1.46 kristaps 474: parselinearg(p, pos);
1.15 kristaps 475: teximacroclose(p);
476: teximacroopen(p, "Fo");
1.46 kristaps 477: parselinearg(p, pos);
1.15 kristaps 478: teximacroclose(p);
479: teximacroopen(p, "Fa");
1.46 kristaps 480: while (parselinearg(p, pos))
1.15 kristaps 481: /* Spin. */ ;
482: teximacroclose(p);
483: teximacro(p, "Fc");
484: break;
485: case (TEXICMD_DEFTP):
486: case (TEXICMD_DEFTPX):
487: case (TEXICMD_DEFTYPEVAR):
488: case (TEXICMD_DEFTYPEVARX):
489: case (TEXICMD_DEFTYPEVR):
490: case (TEXICMD_DEFTYPEVRX):
491: teximacroopen(p, "Vt");
1.46 kristaps 492: while (parselinearg(p, pos))
1.15 kristaps 493: /* Spin. */ ;
494: teximacroclose(p);
495: break;
496: case (TEXICMD_DEFVAR):
497: case (TEXICMD_DEFVARX):
498: case (TEXICMD_DEFVR):
499: case (TEXICMD_DEFVRX):
500: teximacroopen(p, "Va");
1.46 kristaps 501: while (parselinearg(p, pos))
1.15 kristaps 502: /* Spin. */ ;
503: teximacroclose(p);
504: break;
505: default:
506: abort();
1.3 kristaps 507: }
1.15 kristaps 508:
1.54 kristaps 509: if (NULL == blk)
510: return;
511:
512: /*
513: * All "block" definitions have their block bodies indented
514: * unless they have the "x" form of the command following.
515: * E.g.,
516: * @deffn some function
517: * @deffnx another
518: * An explanation.
519: * @end deffn
520: * With this loop, we delay opening the indented block until we
521: * skipped past conformant macros.
522: */
523: for (;;) {
524: switch (peekcmd(p, *pos)) {
525: case (TEXICMD_DEFFNX):
526: case (TEXICMD_DEFMACX):
527: case (TEXICMD_DEFTPX):
528: case (TEXICMD_DEFTYPEFNX):
529: case (TEXICMD_DEFTYPEFUNX):
530: case (TEXICMD_DEFTYPEMETHODX):
531: case (TEXICMD_DEFTYPEVARX):
532: case (TEXICMD_DEFTYPEVRX):
533: case (TEXICMD_DEFUNX):
534: case (TEXICMD_DEFVARX):
535: case (TEXICMD_DEFVRX):
536: texivspace(p);
537: parseeoln(p, pos);
538: continue;
539: default:
540: break;
541: }
542: break;
543: }
544: teximacro(p, "Bd -filled -offset indent");
545: p->seenvs = 1;
546: parseto(p, pos, blk);
547: teximacro(p, "Ed");
1.3 kristaps 548: }
549:
550: static void
1.46 kristaps 551: domacro(struct texi *p, enum texicmd cmd, size_t *pos)
1.30 kristaps 552: {
553: size_t start, end, endtoksz, len;
554: struct teximacro m;
555: const char *endtok, *blk;
556:
557: memset(&m, 0, sizeof(struct teximacro));
558:
1.46 kristaps 559: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
560: advance(p, pos);
1.30 kristaps 561:
1.46 kristaps 562: for (start = end = *pos; end < BUFSZ(p); end++)
563: if (ismspace(BUF(p)[end]) || '{' == BUF(p)[end])
1.30 kristaps 564: break;
565:
566: if (start == end)
567: texierr(p, "zero-length macro name");
568:
1.46 kristaps 569: advanceto(p, pos, end);
1.30 kristaps 570:
571: m.key = malloc(end - start + 1);
572: if (NULL == m.key)
573: texiabort(p, NULL);
1.46 kristaps 574: memcpy(m.key, &BUF(p)[start], end - start);
1.30 kristaps 575: m.key[end - start] = '\0';
576:
1.46 kristaps 577: m.args = argparse(p, pos, &m.argsz, 0);
1.30 kristaps 578:
1.46 kristaps 579: /* Note: we advance to the beginning of the macro. */
580: advanceeoln(p, pos, 1);
581:
582: /*
583: * According to the Texinfo manual, the macro ends on the
584: * newline subsequent the @end macro.
585: * That's COMPLETELY FUCKING WRONG.
586: * It ends inclusive the newline, which is why so many macros
587: * say things like @r{hello}@c, where the subsequent @c swallows
588: * the newline.
589: * However, it does swallow the leading newline, so look for the
590: * @end macro without the leading newline else we might look
591: * past empty macros.
592: */
1.30 kristaps 593: start = *pos;
1.46 kristaps 594: endtok = "@end macro\n";
1.30 kristaps 595: endtoksz = strlen(endtok);
1.46 kristaps 596: blk = memmem(&BUF(p)[start], BUFSZ(p) - start, endtok, endtoksz);
1.30 kristaps 597: if (NULL == blk)
598: texierr(p, "unterminated macro body");
1.46 kristaps 599: /* Roll us back one character. */
600: while (&BUF(p)[*pos] != blk)
601: advance(p, pos);
602: assert('@' == BUF(p)[*pos]);
603: if ('\n' != BUF(p)[*pos - 1])
604: texierr(p, "cannot handle @end macro in-line");
605:
606: len = blk - &BUF(p)[start];
1.30 kristaps 607: m.value = malloc(len + 1);
608: if (NULL == m.value)
609: texiabort(p, NULL);
1.46 kristaps 610: memcpy(m.value, &BUF(p)[start], len);
1.30 kristaps 611: m.value[len] = '\0';
612:
613: p->macros = realloc
614: (p->macros,
615: (p->macrosz + 1) *
616: sizeof(struct teximacro));
617: if (NULL == p->macros)
618: texiabort(p, NULL);
619:
620: p->macros[p->macrosz++] = m;
1.46 kristaps 621: advanceeoln(p, pos, 1);
1.30 kristaps 622: }
623:
624: static void
1.46 kristaps 625: doignblock(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 626: {
1.45 kristaps 627: char end[32], start[32];
628: const char *endt, *startt;
629: size_t esz, ssz, newpos, stack;
1.26 kristaps 630:
631: /*
1.45 kristaps 632: * FIXME: this is cheating.
633: * These tokens are supposed to begin on a newline.
634: * However, if we do that, then we would need to check within
635: * the loop for trailer (or leading, as the case may be)
636: * newline, and that's just a bit too complicated right now.
637: * This is becasue
638: * @ifset BAR
639: * @ifset FOO
640: * @end ifset
641: * @end ifset
642: * won't work right now: we'd read after the first "@end ifset"
643: * to the next line, then look for the next line after that.
1.26 kristaps 644: */
1.45 kristaps 645: ssz = snprintf(start, sizeof(start),
646: "@%s", texitoks[cmd].tok);
647: assert(ssz < sizeof(start));
648: esz = snprintf(end, sizeof(end),
649: "@end %s\n", texitoks[cmd].tok);
650: assert(esz < sizeof(end));
651: stack = 1;
652:
653: /*
654: * Here we look for the end token "end" somewhere in the file in
655: * front of us.
656: * It's not that easy, of course: if we have a nested block,
657: * then there'll be an "end" token of the same kind between us.
658: * Thus, we keep track of scopes for matching "end" blocks.
1.26 kristaps 659: */
1.46 kristaps 660: while (stack > 0 && *pos < BUFSZ(p)) {
1.52 kristaps 661: if (stack > 64)
662: texierr(p, "run-away nested stack?");
1.46 kristaps 663: endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);
664: startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);
1.45 kristaps 665: if (NULL == endt) {
666: texiwarn(p, "unterminated \"%s\" "
667: "block", texitoks[cmd].tok);
1.46 kristaps 668: *pos = BUFSZ(p);
1.45 kristaps 669: break;
670: }
1.26 kristaps 671:
1.45 kristaps 672: newpos = *pos;
673: if (NULL == startt || startt > endt) {
1.46 kristaps 674: newpos += esz + (size_t)(endt - &BUF(p)[*pos]);
1.45 kristaps 675: stack--;
676: } else {
1.46 kristaps 677: newpos += ssz + (size_t)(startt - &BUF(p)[*pos]);
1.45 kristaps 678: stack++;
679: }
680:
1.46 kristaps 681: assert(newpos <= BUFSZ(p));
1.45 kristaps 682: while (*pos < newpos)
1.46 kristaps 683: advance(p, pos);
1.45 kristaps 684: }
1.1 kristaps 685: }
686:
687: static void
1.46 kristaps 688: doblock(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 689: {
690:
1.46 kristaps 691: parseto(p, pos, texitoks[cmd].tok);
1.1 kristaps 692: }
693:
694: static void
1.46 kristaps 695: doinline(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 696: {
1.21 kristaps 697: const char *macro = NULL;
1.12 kristaps 698:
699: switch (cmd) {
1.21 kristaps 700: case (TEXICMD_CODE):
701: case (TEXICMD_KBD):
702: case (TEXICMD_SAMP):
703: case (TEXICMD_T):
704: macro = "Li";
705: break;
706: case (TEXICMD_CITE):
707: case (TEXICMD_DFN):
708: case (TEXICMD_EMPH):
709: case (TEXICMD_I):
710: case (TEXICMD_SLANTED):
711: macro = "Em";
712: break;
713: case (TEXICMD_B):
714: case (TEXICMD_STRONG):
715: macro = "Sy";
716: break;
1.12 kristaps 717: case (TEXICMD_COMMAND):
718: macro = "Xr";
719: break;
720: case (TEXICMD_ENV):
721: macro = "Ev";
722: break;
723: case (TEXICMD_FILE):
724: macro = "Pa";
725: break;
1.16 kristaps 726: case (TEXICMD_OPTION):
727: macro = "Op";
728: break;
1.12 kristaps 729: case (TEXICMD_VAR):
730: macro = "Va";
731: break;
732: default:
1.22 kristaps 733: break;
1.12 kristaps 734: }
735:
1.25 kristaps 736: if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {
1.58 kristaps 737: if (TEXICMD_SC == cmd)
738: p->uppercase++;
1.53 kristaps 739: parsebracket(p, pos, 0);
1.58 kristaps 740: if (TEXICMD_SC == cmd)
741: p->uppercase--;
1.12 kristaps 742: return;
743: }
1.1 kristaps 744:
1.59 kristaps 745: /*
746: * If we haven't seen any whitespace, then we don't want the
747: * subsequent macro to insert any whitespace.
748: */
749: if (p->outmacro && 0 == p->seenws) {
750: teximacroopen(p, "Ns");
751: teximacroclose(p);
752: }
753:
1.5 kristaps 754: teximacroopen(p, macro);
1.1 kristaps 755: p->seenws = 0;
1.58 kristaps 756: if (TEXICMD_SC == cmd)
757: p->uppercase++;
1.53 kristaps 758: parsebracket(p, pos, 0);
1.58 kristaps 759: if (TEXICMD_SC == cmd)
760: p->uppercase--;
1.46 kristaps 761: texipunctuate(p, pos);
1.5 kristaps 762: teximacroclose(p);
1.1 kristaps 763: }
764:
765: static void
1.46 kristaps 766: doverb(struct texi *p, enum texicmd cmd, size_t *pos)
1.33 kristaps 767: {
768: char delim;
1.34 kristaps 769: size_t start;
1.33 kristaps 770:
1.46 kristaps 771: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
772: advance(p, pos);
773: if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])
1.33 kristaps 774: return;
1.46 kristaps 775: advance(p, pos);
776: if (*pos == BUFSZ(p))
1.33 kristaps 777: return;
778:
1.46 kristaps 779: delim = BUF(p)[*pos];
780: advance(p, pos);
1.33 kristaps 781: /* Make sure we flush out our initial whitespace... */
782: if (p->seenws && p->outcol && 0 == p->literal)
783: texiputchar(p, ' ');
784: p->seenws = 0;
1.34 kristaps 785: start = *pos;
1.33 kristaps 786: /* Read until we see the delimiter then end-brace. */
1.46 kristaps 787: while (*pos < BUFSZ(p) - 1) {
788: if (BUF(p)[*pos] == delim && BUF(p)[*pos + 1] == '}')
1.33 kristaps 789: break;
1.46 kristaps 790: advance(p, pos);
1.33 kristaps 791: }
1.51 kristaps 792: if (*pos >= BUFSZ(p) - 1)
1.33 kristaps 793: return;
1.46 kristaps 794: texiputbuf(p, start, *pos);
1.34 kristaps 795:
1.33 kristaps 796: /* Make sure we read after the end-brace. */
1.46 kristaps 797: assert(delim == BUF(p)[*pos]);
798: advance(p, pos);
799: assert('}' == BUF(p)[*pos]);
800: advance(p, pos);
1.33 kristaps 801: }
802:
803: static void
1.46 kristaps 804: doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)
1.25 kristaps 805: {
806: const char *end, *term;
807: size_t endsz, endpos;
808:
1.45 kristaps 809: /* We read from the @verbatim\n newline inclusive! */
1.25 kristaps 810: end = "\n@end verbatim\n";
811: endsz = strlen(end);
1.46 kristaps 812: advanceeoln(p, pos, 0);
813: if (*pos == BUFSZ(p)) {
1.45 kristaps 814: texiwarn(p, "unexpected end of file");
815: return;
816: }
1.25 kristaps 817:
1.46 kristaps 818: term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
1.45 kristaps 819: if (NULL == term) {
820: texiwarn(p, "unterminated verbatim block");
1.46 kristaps 821: endpos = BUFSZ(p);
1.45 kristaps 822: } else
1.46 kristaps 823: endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
1.25 kristaps 824:
1.46 kristaps 825: assert(endpos <= BUFSZ(p));
826: assert('\n' == BUF(p)[*pos]);
827: advance(p, pos);
1.25 kristaps 828: teximacro(p, "Bd -literal -offset indent");
1.26 kristaps 829: while (*pos < endpos) {
1.46 kristaps 830: texiputchar(p, BUF(p)[*pos]);
831: advance(p, pos);
1.25 kristaps 832: }
833: teximacro(p, "Ed");
1.46 kristaps 834: if (*pos < BUFSZ(p))
835: advanceto(p, pos, endpos + endsz);
1.25 kristaps 836: }
837:
838: static void
1.46 kristaps 839: doverbinclude(struct texi *p, enum texicmd cmd, size_t *pos)
1.16 kristaps 840: {
1.25 kristaps 841: char fname[PATH_MAX], path[PATH_MAX];
842: int rc;
843: size_t i, end;
844: const char *v;
845: enum texicmd type;
1.16 kristaps 846:
1.46 kristaps 847: while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
848: advance(p, pos);
1.16 kristaps 849:
1.46 kristaps 850: for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
1.16 kristaps 851: if (i == sizeof(fname) - 1)
852: break;
1.46 kristaps 853: if ('@' != BUF(p)[*pos]) {
854: fname[i++] = BUF(p)[*pos];
855: advance(p, pos);
1.25 kristaps 856: continue;
857: }
1.46 kristaps 858: type = texicmd(p, *pos, &end, NULL);
859: advanceto(p, pos, end);
1.25 kristaps 860: if (TEXICMD_VALUE != type)
861: texierr(p, "unknown verbatiminclude command");
1.46 kristaps 862: v = valueblookup(p, pos);
1.25 kristaps 863: if (NULL == v)
864: continue;
865: while ('\0' != *v) {
866: if (i == sizeof(fname) - 1)
867: break;
868: fname[i++] = *v++;
869: }
870: if ('\0' != *v)
871: break;
1.16 kristaps 872: }
873:
874: if (i == 0)
875: texierr(p, "path too short");
1.46 kristaps 876: else if ('\n' != BUF(p)[*pos])
1.16 kristaps 877: texierr(p, "path too long");
878: else if ('/' == fname[0])
879: texierr(p, "no absolute paths");
880: fname[i] = '\0';
881:
882: if (strstr(fname, "../") || strstr(fname, "/.."))
883: texierr(p, "insecure path");
884:
885: rc = snprintf(path, sizeof(path),
886: "%s/%s", p->dirs[0], fname);
887: if (rc < 0)
888: texierr(p, "couldn't format path");
889: else if ((size_t)rc >= sizeof(path))
890: texierr(p, "path too long");
891:
892: parsefile(p, path, 0);
893: }
894:
895: static void
1.46 kristaps 896: doinclude(struct texi *p, enum texicmd cmd, size_t *pos)
1.2 kristaps 897: {
1.25 kristaps 898: char fname[PATH_MAX], path[PATH_MAX];
899: size_t i, end;
900: int rc;
901: const char *v;
902: enum texicmd type;
1.2 kristaps 903:
1.46 kristaps 904: while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
905: advance(p, pos);
1.2 kristaps 906:
907: /* Read in the filename. */
1.46 kristaps 908: for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
1.2 kristaps 909: if (i == sizeof(fname) - 1)
910: break;
1.46 kristaps 911: if ('@' != BUF(p)[*pos]) {
912: fname[i++] = BUF(p)[*pos];
913: advance(p, pos);
1.25 kristaps 914: continue;
915: }
1.46 kristaps 916: type = texicmd(p, *pos, &end, NULL);
917: advanceto(p, pos, end);
1.25 kristaps 918: if (TEXICMD_VALUE != type)
919: texierr(p, "unknown include command");
1.46 kristaps 920: v = valueblookup(p, pos);
1.25 kristaps 921: if (NULL == v)
922: continue;
923: while ('\0' != *v) {
924: if (i == sizeof(fname) - 1)
925: break;
926: fname[i++] = *v++;
927: }
928: if ('\0' != *v)
929: break;
1.2 kristaps 930: }
931:
932: if (i == 0)
933: texierr(p, "path too short");
1.46 kristaps 934: else if ('\n' != BUF(p)[*pos])
1.2 kristaps 935: texierr(p, "path too long");
936: else if ('/' == fname[0])
937: texierr(p, "no absolute paths");
938: fname[i] = '\0';
939:
940: if (strstr(fname, "../") || strstr(fname, "/.."))
941: texierr(p, "insecure path");
942:
1.5 kristaps 943: for (i = 0; i < p->dirsz; i++) {
944: rc = snprintf(path, sizeof(path),
945: "%s/%s", p->dirs[i], fname);
946: if (rc < 0)
947: texierr(p, "couldn't format path");
948: else if ((size_t)rc >= sizeof(path))
949: texierr(p, "path too long");
950: else if (-1 == access(path, R_OK))
951: continue;
952:
1.16 kristaps 953: parsefile(p, path, 1);
1.5 kristaps 954: return;
955: }
1.2 kristaps 956:
1.5 kristaps 957: texierr(p, "couldn't find %s in includes", fname);
1.2 kristaps 958: }
959:
960: static void
1.46 kristaps 961: dobracket(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 962: {
963:
1.53 kristaps 964: parsebracket(p, pos, 0);
1.1 kristaps 965: }
966:
967: static void
1.46 kristaps 968: dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)
1.3 kristaps 969: {
970:
1.57 kristaps 971: advanceeoln(p, pos, 1);
972:
1.20 kristaps 973: switch (cmd) {
974: case (TEXICMD_FORMAT):
975: case (TEXICMD_SMALLFORMAT):
976: teximacro(p, "Bd -filled");
977: break;
978: default:
979: teximacro(p, "Bd -filled -offset indent");
980: break;
981: }
982:
1.11 kristaps 983: p->seenvs = 1;
1.46 kristaps 984: parseto(p, pos, texitoks[cmd].tok);
1.5 kristaps 985: teximacro(p, "Ed");
1.3 kristaps 986: }
987:
988: static void
1.46 kristaps 989: doexample(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 990: {
991:
1.57 kristaps 992: advanceeoln(p, pos, 1);
993:
1.5 kristaps 994: teximacro(p, "Bd -literal -offset indent");
1.3 kristaps 995: p->literal++;
1.46 kristaps 996: parseto(p, pos, texitoks[cmd].tok);
1.3 kristaps 997: p->literal--;
1.5 kristaps 998: teximacro(p, "Ed");
1.1 kristaps 999: }
1000:
1001: static void
1.46 kristaps 1002: dobye(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1003: {
1004:
1005: texiexit(p);
1006: exit(EXIT_SUCCESS);
1007: }
1008:
1009: static void
1.46 kristaps 1010: dotitle(struct texi *p, enum texicmd cmd, size_t *pos)
1.10 kristaps 1011: {
1.57 kristaps 1012: size_t start;
1.10 kristaps 1013:
1.46 kristaps 1014: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
1015: advance(p, pos);
1.57 kristaps 1016:
1017: /* We want to suck down the entire line, inclusive \n. */
1018: start = *pos;
1019: while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
1020: if ('@' == BUF(p)[*pos])
1021: advance(p, pos);
1022: advance(p, pos);
1023: }
1024: if (*pos < BUFSZ(p))
1025: advance(p, pos);
1026:
1027: /* Copy this into a buffer. */
1.10 kristaps 1028: free(p->subtitle);
1.57 kristaps 1029: if (NULL == (p->subtitle = malloc(*pos - start + 1)))
1.27 kristaps 1030: texiabort(p, NULL);
1.57 kristaps 1031: memcpy(p->subtitle, &BUF(p)[start], *pos - start);
1032: p->subtitle[*pos - start] = '\0';
1.10 kristaps 1033: }
1034:
1035: static void
1.46 kristaps 1036: doaccent(struct texi *p, enum texicmd cmd, size_t *pos)
1.16 kristaps 1037: {
1.42 kristaps 1038: int brace = 0;
1.16 kristaps 1039:
1.46 kristaps 1040: if (*pos == BUFSZ(p)) {
1.42 kristaps 1041: texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
1.16 kristaps 1042: return;
1.42 kristaps 1043: }
1044:
1045: /* Pad us with space, if necessary. */
1046: if (p->seenws && p->outcol && 0 == p->literal) {
1.34 kristaps 1047: texiputchar(p, ' ');
1.42 kristaps 1048: p->seenws = 0;
1049: }
1050:
1051: /*
1052: * If we're braced, then that's that.
1053: * Otherwise, in a special Texinfo case: if we're a non
1054: * alphabetic command of one letter, then the next character is
1055: * the critical one.
1056: * Otherwise, space can sit between us and our argument.
1057: */
1.46 kristaps 1058: if ('{' == BUF(p)[*pos]) {
1.42 kristaps 1059: brace = 1;
1.46 kristaps 1060: advance(p, pos);
1.49 kristaps 1061: } else if (isalpha((unsigned char)texitoks[cmd].tok[0]))
1.46 kristaps 1062: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
1063: advance(p, pos);
1.42 kristaps 1064:
1.46 kristaps 1065: if (*pos == BUFSZ(p)) {
1.42 kristaps 1066: texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
1067: return;
1068: }
1069:
1070: switch (cmd) {
1.16 kristaps 1071: case (TEXICMD_ACUTE):
1.46 kristaps 1072: switch (BUF(p)[*pos]) {
1.16 kristaps 1073: case ('a'): case ('A'):
1074: case ('e'): case ('E'):
1075: case ('i'): case ('I'):
1076: case ('o'): case ('O'):
1077: case ('u'): case ('U'):
1078: texiputchars(p, "\\(\'");
1079: break;
1080: default:
1.42 kristaps 1081: texiwarn(p, "ignoring accent");
1082: break;
1.16 kristaps 1083: }
1.46 kristaps 1084: texiputchar(p, BUF(p)[*pos]);
1085: advance(p, pos);
1.42 kristaps 1086: break;
1087: case (TEXICMD_CEDILLA):
1.46 kristaps 1088: if ('c' == BUF(p)[*pos] || 'C' == BUF(p)[*pos])
1.42 kristaps 1089: texiputchars(p, "\\(,");
1090: else
1091: texiwarn(p, "ignoring accent");
1.46 kristaps 1092: texiputchar(p, BUF(p)[*pos]);
1093: advance(p, pos);
1.16 kristaps 1094: break;
1095: case (TEXICMD_CIRCUMFLEX):
1.46 kristaps 1096: switch (BUF(p)[*pos]) {
1.16 kristaps 1097: case ('a'): case ('A'):
1098: case ('e'): case ('E'):
1099: case ('i'): case ('I'):
1100: case ('o'): case ('O'):
1101: case ('u'): case ('U'):
1102: texiputchars(p, "\\(^");
1103: break;
1104: default:
1.42 kristaps 1105: texiwarn(p, "ignoring accent");
1.34 kristaps 1106: break;
1.16 kristaps 1107: }
1.46 kristaps 1108: texiputchar(p, BUF(p)[*pos]);
1109: advance(p, pos);
1.42 kristaps 1110: break;
1111: case (TEXICMD_DOTLESS):
1.46 kristaps 1112: if ('i' == BUF(p)[*pos] || 'j' == BUF(p)[*pos])
1.42 kristaps 1113: texiputchars(p, "\\(.");
1114: else
1115: texiwarn(p, "ignoring accent");
1.46 kristaps 1116: texiputchar(p, BUF(p)[*pos]);
1117: advance(p, pos);
1.16 kristaps 1118: break;
1119: case (TEXICMD_GRAVE):
1.46 kristaps 1120: switch (BUF(p)[*pos]) {
1.16 kristaps 1121: case ('a'): case ('A'):
1122: case ('e'): case ('E'):
1123: case ('i'): case ('I'):
1124: case ('o'): case ('O'):
1125: case ('u'): case ('U'):
1126: texiputchars(p, "\\(`");
1127: break;
1128: default:
1.42 kristaps 1129: texiwarn(p, "ignoring accent");
1130: break;
1.16 kristaps 1131: }
1.46 kristaps 1132: texiputchar(p, BUF(p)[*pos]);
1133: advance(p, pos);
1.16 kristaps 1134: break;
1135: case (TEXICMD_TILDE):
1.46 kristaps 1136: switch (BUF(p)[*pos]) {
1.16 kristaps 1137: case ('a'): case ('A'):
1138: case ('n'): case ('N'):
1139: case ('o'): case ('O'):
1140: texiputchars(p, "\\(~");
1141: break;
1142: default:
1.42 kristaps 1143: texiwarn(p, "ignoring accent");
1.34 kristaps 1144: break;
1.16 kristaps 1145: }
1.46 kristaps 1146: texiputchar(p, BUF(p)[*pos]);
1147: advance(p, pos);
1.16 kristaps 1148: break;
1149: case (TEXICMD_UMLAUT):
1.46 kristaps 1150: switch (BUF(p)[*pos]) {
1.16 kristaps 1151: case ('a'): case ('A'):
1152: case ('e'): case ('E'):
1153: case ('i'): case ('I'):
1154: case ('o'): case ('O'):
1155: case ('u'): case ('U'):
1156: case ('y'):
1157: texiputchars(p, "\\(:");
1158: break;
1159: default:
1.42 kristaps 1160: texiwarn(p, "ignoring accent");
1.34 kristaps 1161: break;
1.16 kristaps 1162: }
1.46 kristaps 1163: texiputchar(p, BUF(p)[*pos]);
1164: advance(p, pos);
1.16 kristaps 1165: break;
1166: default:
1.46 kristaps 1167: texiputchar(p, BUF(p)[*pos]);
1168: advance(p, pos);
1.42 kristaps 1169: break;
1170: }
1171:
1172: if (brace) {
1.46 kristaps 1173: while (*pos < BUFSZ(p) && '}' != BUF(p)[*pos]) {
1174: texiputchar(p, BUF(p)[*pos]);
1175: advance(p, pos);
1.42 kristaps 1176: }
1.46 kristaps 1177: if (*pos < BUFSZ(p))
1178: advance(p, pos);
1.42 kristaps 1179: }
1180:
1181: switch (cmd) {
1182: case (TEXICMD_TIEACCENT):
1183: texiputchar(p, ']');
1184: break;
1185: case (TEXICMD_DOTACCENT):
1186: texiputchar(p, '*');
1187: break;
1188: default:
1189: break;
1.16 kristaps 1190: }
1191: }
1192:
1193: static void
1.46 kristaps 1194: dosymbol(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1195: {
1196:
1.42 kristaps 1197: /* Remember to pad us. */
1.43 kristaps 1198: if (p->seenws && p->outcol && 0 == p->literal)
1.3 kristaps 1199: texiputchar(p, ' ');
1.43 kristaps 1200:
1201: p->seenws = 0;
1.3 kristaps 1202:
1.1 kristaps 1203: switch (cmd) {
1.42 kristaps 1204: case (TEXICMD_AA):
1205: texiputchars(p, "\\(oA");
1206: break;
1207: case (TEXICMD_AASMALL):
1208: texiputchars(p, "\\(oa");
1209: break;
1210: case (TEXICMD_AE):
1211: texiputchars(p, "\\(AE");
1212: break;
1213: case (TEXICMD_AESMALL):
1214: texiputchars(p, "\\(ae");
1215: break;
1.3 kristaps 1216: case (TEXICMD_ASTERISK):
1217: case (TEXICMD_NEWLINE):
1218: case (TEXICMD_SPACE):
1.18 kristaps 1219: case (TEXICMD_TABSYM):
1.3 kristaps 1220: texiputchar(p, ' ');
1221: break;
1.1 kristaps 1222: case (TEXICMD_AT):
1.3 kristaps 1223: texiputchar(p, '@');
1.59 kristaps 1224: break;
1225: case (TEXICMD_BACKSLASH):
1226: texiputchar(p, '\\');
1.3 kristaps 1227: break;
1228: case (TEXICMD_BANG):
1229: texiputchar(p, '!');
1.7 kristaps 1230: break;
1231: case (TEXICMD_BULLET):
1232: texiputchars(p, "\\(bu");
1.1 kristaps 1233: break;
1.35 kristaps 1234: case (TEXICMD_COMMA):
1235: texiputchar(p, ',');
1236: break;
1.1 kristaps 1237: case (TEXICMD_COPYRIGHT):
1238: texiputchars(p, "\\(co");
1239: break;
1.42 kristaps 1240: case (TEXICMD_DH):
1241: texiputchars(p, "\\(-D");
1242: break;
1243: case (TEXICMD_DHSMALL):
1244: texiputchars(p, "\\(Sd");
1245: break;
1.2 kristaps 1246: case (TEXICMD_DOTS):
1.34 kristaps 1247: case (TEXICMD_ENDDOTS):
1.2 kristaps 1248: texiputchars(p, "...");
1249: break;
1.28 kristaps 1250: case (TEXICMD_EQUIV):
1251: texiputchars(p, "\\(==");
1252: break;
1.15 kristaps 1253: case (TEXICMD_ERROR):
1254: texiputchars(p, "error\\(->");
1.17 kristaps 1255: break;
1.43 kristaps 1256: case (TEXICMD_EURO):
1257: texiputchars(p, "\\(Eu");
1258: break;
1.42 kristaps 1259: case (TEXICMD_EXCLAMDOWN):
1260: texiputchars(p, "\\(r!");
1261: break;
1.17 kristaps 1262: case (TEXICMD_EXPANSION):
1263: texiputchars(p, "\\(->");
1.15 kristaps 1264: break;
1.43 kristaps 1265: case (TEXICMD_GEQ):
1266: texiputchars(p, "\\(>=");
1267: break;
1268: case (TEXICMD_GUILLEMETLEFT):
1269: case (TEXICMD_GUILLEMOTLEFT):
1270: texiputchars(p, "\\(Fo");
1271: break;
1272: case (TEXICMD_GUILLEMETRIGHT):
1273: case (TEXICMD_GUILLEMOTRIGHT):
1274: texiputchars(p, "\\(Fc");
1275: break;
1276: case (TEXICMD_GUILSINGLLEFT):
1277: texiputchars(p, "\\(fo");
1278: break;
1279: case (TEXICMD_GUILSINGLRIGHT):
1280: texiputchars(p, "\\(fc");
1281: break;
1.42 kristaps 1282: case (TEXICMD_L):
1283: texiputchars(p, "\\(/L");
1284: break;
1.1 kristaps 1285: case (TEXICMD_LATEX):
1286: texiputchars(p, "LaTeX");
1287: break;
1.43 kristaps 1288: case (TEXICMD_LEQ):
1289: texiputchars(p, "\\(<=");
1290: break;
1.42 kristaps 1291: case (TEXICMD_LSMALL):
1292: texiputchars(p, "\\(/l");
1293: break;
1.25 kristaps 1294: case (TEXICMD_MINUS):
1295: texiputchars(p, "\\-");
1296: break;
1.42 kristaps 1297: case (TEXICMD_O):
1298: texiputchars(p, "\\(/O");
1299: break;
1300: case (TEXICMD_OE):
1301: texiputchars(p, "\\(OE");
1302: break;
1303: case (TEXICMD_OESMALL):
1304: texiputchars(p, "\\(oe");
1305: break;
1306: case (TEXICMD_ORDF):
1307: texiputchars(p, "a");
1308: break;
1309: case (TEXICMD_ORDM):
1310: texiputchars(p, "o");
1311: break;
1312: case (TEXICMD_OSMALL):
1313: texiputchars(p, "\\(/o");
1314: break;
1.25 kristaps 1315: case (TEXICMD_PERIOD):
1316: texiputchar(p, '.');
1317: break;
1.43 kristaps 1318: case (TEXICMD_POUNDS):
1319: texiputchars(p, "\\(Po");
1320: break;
1.42 kristaps 1321: case (TEXICMD_QUESTIONDOWN):
1322: texiputchars(p, "\\(r?");
1323: break;
1.3 kristaps 1324: case (TEXICMD_QUESTIONMARK):
1325: texiputchar(p, '?');
1.15 kristaps 1326: break;
1.43 kristaps 1327: case (TEXICMD_QUOTEDBLBASE):
1328: texiputchars(p, "\\(Bq");
1329: break;
1330: case (TEXICMD_QUOTEDBLLEFT):
1331: texiputchars(p, "\\(lq");
1332: break;
1333: case (TEXICMD_QUOTEDBLRIGHT):
1334: texiputchars(p, "\\(rq");
1335: break;
1336: case (TEXICMD_QUOTESINGLBASE):
1337: texiputchars(p, "\\(bq");
1338: break;
1339: case (TEXICMD_QUOTELEFT):
1340: texiputchars(p, "\\(oq");
1341: break;
1342: case (TEXICMD_QUOTERIGHT):
1343: texiputchars(p, "\\(cq");
1344: break;
1345: case (TEXICMD_REGISTEREDSYMBOL):
1346: texiputchars(p, "\\(rg");
1347: break;
1.15 kristaps 1348: case (TEXICMD_RESULT):
1349: texiputchars(p, "\\(rA");
1.3 kristaps 1350: break;
1.34 kristaps 1351: case (TEXICMD_SLASH):
1352: texiputchar(p, '/');
1353: break;
1.35 kristaps 1354: case (TEXICMD_SS):
1355: texiputchars(p, "\\(ss");
1356: break;
1.3 kristaps 1357: case (TEXICMD_SQUIGGLE_LEFT):
1358: texiputchars(p, "{");
1359: break;
1360: case (TEXICMD_SQUIGGLE_RIGHT):
1361: texiputchars(p, "}");
1362: break;
1.38 kristaps 1363: case (TEXICMD_TEXSYM):
1.35 kristaps 1364: texiputchars(p, "TeX");
1.43 kristaps 1365: break;
1366: case (TEXICMD_TEXTDEGREE):
1367: texiputchars(p, "\\(de");
1.35 kristaps 1368: break;
1.42 kristaps 1369: case (TEXICMD_TH):
1370: texiputchars(p, "\\(TP");
1371: break;
1372: case (TEXICMD_THSMALL):
1373: texiputchars(p, "\\(Tp");
1374: break;
1.38 kristaps 1375: case (TEXICMD_TIE):
1.35 kristaps 1376: texiputchars(p, "\\ ");
1.1 kristaps 1377: break;
1.3 kristaps 1378: case (TEXICMD_COLON):
1379: case (TEXICMD_HYPHEN):
1380: break;
1.1 kristaps 1381: default:
1382: abort();
1383: }
1384:
1.42 kristaps 1385: /* Alphabetic commands have braces we ignore. */
1.49 kristaps 1386: if (isalpha((unsigned char)texitoks[cmd].tok[0]))
1.46 kristaps 1387: doignbracket(p, cmd, pos);
1.1 kristaps 1388: }
1389:
1390: static void
1.46 kristaps 1391: doquotation(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1392: {
1393:
1.5 kristaps 1394: teximacro(p, "Qo");
1.46 kristaps 1395: parseto(p, pos, "quotation");
1.5 kristaps 1396: teximacro(p, "Qc");
1.1 kristaps 1397: }
1398:
1.3 kristaps 1399: static void
1.46 kristaps 1400: domath(struct texi *p, enum texicmd cmd, size_t *pos)
1.3 kristaps 1401: {
1402:
1.53 kristaps 1403: parsebracket(p, pos, 1);
1.24 kristaps 1404: }
1405:
1406: static void
1.46 kristaps 1407: dovalue(struct texi *p, enum texicmd cmd, size_t *pos)
1.24 kristaps 1408: {
1.46 kristaps 1409: size_t start, end;
1.25 kristaps 1410: char *key, *val;
1411: const char *cp;
1.24 kristaps 1412:
1413: if (TEXICMD_SET == cmd) {
1.46 kristaps 1414: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
1415: advance(p, pos);
1416: for (start = end = *pos; end < BUFSZ(p); end++)
1417: if (ismspace(BUF(p)[end]))
1.24 kristaps 1418: break;
1.25 kristaps 1419: /* We don't allow empty keys. */
1.24 kristaps 1420: if (start == end)
1421: return;
1.46 kristaps 1422: advanceto(p, pos, end);
1.24 kristaps 1423:
1424: key = malloc(end - start + 1);
1.27 kristaps 1425: if (NULL == key)
1426: texiabort(p, NULL);
1.46 kristaps 1427: memcpy(key, &BUF(p)[start], end - start);
1.24 kristaps 1428: key[end - start] = '\0';
1429:
1.46 kristaps 1430: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
1431: advance(p, pos);
1432: for (start = end = *pos; end < BUFSZ(p); end++)
1433: if ('\n' == BUF(p)[end])
1.24 kristaps 1434: break;
1.25 kristaps 1435: /* We do allow empty values. */
1.46 kristaps 1436: advanceeoln(p, pos, 1);
1.24 kristaps 1437:
1438: val = malloc(end - start + 1);
1.27 kristaps 1439: if (NULL == val)
1440: texiabort(p, NULL);
1.46 kristaps 1441: memcpy(val, &BUF(p)[start], end - start);
1.24 kristaps 1442: val[end - start] = '\0';
1.25 kristaps 1443: valueadd(p, key, val);
1.24 kristaps 1444: } else if (TEXICMD_VALUE == cmd) {
1445: if (p->seenws)
1446: texiputchar(p, ' ');
1447: p->seenws = 0;
1.46 kristaps 1448: if (NULL != (cp = valueblookup(p, pos)))
1.56 kristaps 1449: texisplice(p, cp, strlen(cp), *pos);
1.46 kristaps 1450: else
1.25 kristaps 1451: texiputchars(p, "{No value}");
1.24 kristaps 1452: } else if (TEXICMD_IFCLEAR == cmd) {
1.46 kristaps 1453: if (NULL != valuellookup(p, pos))
1454: doignblock(p, cmd, pos);
1.26 kristaps 1455: else
1.46 kristaps 1456: parseto(p, pos, texitoks[cmd].tok);
1.30 kristaps 1457: } else if (TEXICMD_IFSET == cmd) {
1.46 kristaps 1458: if (NULL == valuellookup(p, pos))
1459: doignblock(p, cmd, pos);
1.30 kristaps 1460: else
1.46 kristaps 1461: parseto(p, pos, texitoks[cmd].tok);
1.25 kristaps 1462: } else if (TEXICMD_CLEAR == cmd)
1.46 kristaps 1463: valuelclear(p, pos);
1.3 kristaps 1464: }
1465:
1.1 kristaps 1466: static void
1.46 kristaps 1467: dolink(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1468: {
1.8 kristaps 1469: int c;
1.1 kristaps 1470:
1471: switch (cmd) {
1472: case (TEXICMD_EMAIL):
1.5 kristaps 1473: teximacroopen(p, "Mt");
1.1 kristaps 1474: break;
1.3 kristaps 1475: case (TEXICMD_UREF):
1.1 kristaps 1476: case (TEXICMD_URL):
1.44 kristaps 1477: case (TEXICMD_INDICATEURL):
1.5 kristaps 1478: teximacroopen(p, "Lk");
1.1 kristaps 1479: break;
1.8 kristaps 1480: case (TEXICMD_XREF):
1481: texiputchars(p, "See Section");
1.39 kristaps 1482: teximacroopen(p, "Dq");
1.8 kristaps 1483: break;
1484: case (TEXICMD_PXREF):
1485: texiputchars(p, "see Section");
1.39 kristaps 1486: teximacroopen(p, "Dq");
1.8 kristaps 1487: break;
1.34 kristaps 1488: case (TEXICMD_INFOREF):
1489: texiputchars(p, "See Info file node");
1.39 kristaps 1490: teximacroopen(p, "Dq");
1.34 kristaps 1491: break;
1.1 kristaps 1492: default:
1.8 kristaps 1493: abort();
1.1 kristaps 1494: }
1.8 kristaps 1495:
1.46 kristaps 1496: c = parsearg(p, pos, 0);
1.8 kristaps 1497: p->ign++;
1498: while (c > 0)
1.46 kristaps 1499: c = parsearg(p, pos, 1);
1.8 kristaps 1500: p->ign--;
1501:
1.46 kristaps 1502: texipunctuate(p, pos);
1.8 kristaps 1503: teximacroclose(p);
1504: }
1505:
1506: static void
1.46 kristaps 1507: doignargn(struct texi *p, enum texicmd cmd, size_t *pos)
1.8 kristaps 1508: {
1509: int c;
1510:
1.46 kristaps 1511: c = parsearg(p, pos, 0);
1.8 kristaps 1512: p->ign++;
1513: while (c > 0)
1.46 kristaps 1514: c = parsearg(p, pos, 1);
1.8 kristaps 1515: p->ign--;
1.1 kristaps 1516: }
1517:
1.23 kristaps 1518: /*
1519: * Sections can be made subsections and so on by way of the
1520: * @raiseections and @lowersections commands.
1521: * Perform this check here and return the actual section number adjusted
1522: * to the raise level.
1523: */
1524: static int
1525: sectioner(struct texi *p, int sec)
1526: {
1527:
1528: if ((sec -= p->secoffs) < 0) {
1529: texiwarn(p, "section below minimum, clamping");
1530: return(0);
1531: } else if (sec >= SECTSZ) {
1532: texiwarn(p, "section above maximum, clamping");
1533: return(SECTSZ - 1);
1534: }
1535: return(sec);
1536: }
1537:
1538: static void
1.46 kristaps 1539: dosubsubsection(struct texi *p, enum texicmd cmd, size_t *pos)
1.23 kristaps 1540: {
1541: int sec;
1542:
1543: sec = sectioner(p, 3);
1544:
1545: /* We don't have a subsubsubsection, so make one up. */
1546: texivspace(p);
1547: teximacroopen(p, sects[sec]);
1.46 kristaps 1548: parseeoln(p, pos);
1.23 kristaps 1549: teximacroclose(p);
1550: texivspace(p);
1551: }
1552:
1.1 kristaps 1553: static void
1.46 kristaps 1554: dosubsection(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1555: {
1.23 kristaps 1556: int sec;
1557:
1558: sec = sectioner(p, 2);
1.13 kristaps 1559:
1560: if (p->outmacro)
1.23 kristaps 1561: texierr(p, "\"%s\" in open line scope!?", sects[sec]);
1.13 kristaps 1562: else if (p->literal)
1.23 kristaps 1563: texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
1.1 kristaps 1564:
1.21 kristaps 1565: /* We don't have a subsubsection, so make one up. */
1.34 kristaps 1566: if (sec > 1)
1567: texivspace(p);
1.23 kristaps 1568: teximacroopen(p, sects[sec]);
1.46 kristaps 1569: parseeoln(p, pos);
1.5 kristaps 1570: teximacroclose(p);
1.34 kristaps 1571: if (sec > 1)
1572: texivspace(p);
1.1 kristaps 1573: }
1574:
1575: static void
1.46 kristaps 1576: dosecoffs(struct texi *p, enum texicmd cmd, size_t *pos)
1.23 kristaps 1577: {
1578:
1579: if (TEXICMD_RAISESECTIONS == cmd)
1580: p->secoffs++;
1581: else
1582: p->secoffs--;
1583: }
1584:
1585: static void
1.46 kristaps 1586: dosection(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1587: {
1.23 kristaps 1588: int sec;
1.12 kristaps 1589:
1590: switch (cmd) {
1.55 kristaps 1591: case (TEXICMD_TOP):
1592: sec = 0;
1593: break;
1.12 kristaps 1594: case (TEXICMD_APPENDIX):
1595: case (TEXICMD_CHAPTER):
1596: case (TEXICMD_UNNUMBERED):
1.23 kristaps 1597: sec = sectioner(p, 0);
1.12 kristaps 1598: break;
1599: case (TEXICMD_APPENDIXSEC):
1600: case (TEXICMD_HEADING):
1601: case (TEXICMD_SECTION):
1602: case (TEXICMD_UNNUMBEREDSEC):
1.23 kristaps 1603: sec = sectioner(p, 1);
1.12 kristaps 1604: break;
1605: default:
1606: abort();
1607: }
1.1 kristaps 1608:
1.3 kristaps 1609: if (p->outmacro)
1.23 kristaps 1610: texierr(p, "\"%s\" in open line scope!?", sects[sec]);
1.3 kristaps 1611: else if (p->literal)
1.23 kristaps 1612: texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
1.3 kristaps 1613:
1.55 kristaps 1614: if (0 == sec && NULL != p->chapters) {
1615: teximdocclose(p, 0);
1.56 kristaps 1616: teximdocopen(p, pos);
1.55 kristaps 1617: }
1618:
1.23 kristaps 1619: teximacroopen(p, sects[sec]);
1.46 kristaps 1620: parseeoln(p, pos);
1.3 kristaps 1621: teximacroclose(p);
1.11 kristaps 1622: p->seenvs = 1;
1.3 kristaps 1623: }
1624:
1625: static void
1.55 kristaps 1626: dotop(struct texi *p, enum texicmd cmd, size_t *pos)
1627: {
1628:
1629: if (--p->ign)
1630: texierr(p, "@top command while ignoring");
1631:
1632: if (NULL == p->chapters)
1.56 kristaps 1633: teximdocopen(p, pos);
1.55 kristaps 1634: dosection(p, cmd, pos);
1635: }
1636:
1637: static void
1.46 kristaps 1638: dosp(struct texi *p, enum texicmd cmd, size_t *pos)
1.3 kristaps 1639: {
1640:
1.57 kristaps 1641: advanceeoln(p, pos, 1);
1.37 kristaps 1642: if (p->literal)
1643: texiputchar(p, '\n');
1644: else
1645: texivspace(p);
1.1 kristaps 1646: }
1647:
1648: static void
1.46 kristaps 1649: doitem(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1650: {
1651:
1.18 kristaps 1652: /* Multitable is using raw tbl(7). */
1653: if (TEXILIST_TABLE == p->list) {
1654: texiputchar(p, '\n');
1655: return;
1656: }
1657:
1.3 kristaps 1658: if (p->outmacro)
1659: texierr(p, "item in open line scope!?");
1660: else if (p->literal)
1661: texierr(p, "item in a literal scope!?");
1662:
1663: switch (p->list) {
1664: case (TEXILIST_ITEM):
1.5 kristaps 1665: teximacroopen(p, "It");
1.3 kristaps 1666: break;
1667: case (TEXILIST_NOITEM):
1.5 kristaps 1668: teximacro(p, "It");
1.3 kristaps 1669: break;
1670: default:
1.11 kristaps 1671: texivspace(p);
1.3 kristaps 1672: break;
1673: }
1.18 kristaps 1674:
1675: /* Trick so we don't start with Pp. */
1.11 kristaps 1676: p->seenvs = 1;
1.46 kristaps 1677: parseeoln(p, pos);
1.1 kristaps 1678:
1.3 kristaps 1679: if (TEXILIST_ITEM == p->list)
1680: teximacroclose(p);
1.9 kristaps 1681: else if (p->outcol > 0)
1.1 kristaps 1682: texiputchar(p, '\n');
1.18 kristaps 1683: }
1684:
1685: static void
1.46 kristaps 1686: dotab(struct texi *p, enum texicmd cmd, size_t *pos)
1.18 kristaps 1687: {
1688:
1689: /* This command is only useful in @multitable. */
1690: if (TEXILIST_TABLE == p->list)
1691: texiputchar(p, '\t');
1692: }
1693:
1694: static void
1.46 kristaps 1695: domultitable(struct texi *p, enum texicmd cmd, size_t *pos)
1.18 kristaps 1696: {
1697: enum texilist sv = p->list;
1.32 kristaps 1698: int svliteral = p->literal;
1.18 kristaps 1699: enum texicmd type;
1700: size_t i, end, columns;
1701:
1702: p->list = TEXILIST_TABLE;
1.32 kristaps 1703: /*
1704: * TS/TE blocks aren't "in mdoc(7)", so we can disregard the
1705: * fact that we're in literal mode right now.
1706: */
1707: p->literal = 0;
1.18 kristaps 1708: teximacro(p, "TS");
1709: columns = 0;
1710:
1711: /* Advance to the first argument... */
1.46 kristaps 1712: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
1713: advance(p, pos);
1.18 kristaps 1714:
1715: /* Make sure we don't print anything when scanning. */
1716: p->ign++;
1.57 kristaps 1717: if (*pos < BUFSZ(p) && '@' == BUF(p)[*pos]) {
1.18 kristaps 1718: /*
1719: * Look for @columnfractions.
1720: * We ignore these, but we do use the number of
1721: * arguments to set the number of columns that we'll
1722: * have.
1723: */
1.46 kristaps 1724: type = texicmd(p, *pos, &end, NULL);
1725: advanceto(p, pos, end);
1.18 kristaps 1726: if (TEXICMD_COLUMNFRACTIONS != type)
1.25 kristaps 1727: texierr(p, "unknown multitable command");
1.46 kristaps 1728: while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
1729: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
1730: advance(p, pos);
1731: while (*pos < BUFSZ(p) && ! isws(BUF(p)[*pos])) {
1732: if ('\n' == BUF(p)[*pos])
1.18 kristaps 1733: break;
1.46 kristaps 1734: advance(p, pos);
1.18 kristaps 1735: }
1736: columns++;
1737: }
1738: } else
1739: /*
1740: * We have arguments.
1741: * We could parse these, but it's easier to just let
1742: * tbl(7) figure it out.
1743: * So use this only to count arguments.
1744: */
1.46 kristaps 1745: while (parselinearg(p, pos) > 0)
1.18 kristaps 1746: columns++;
1747: p->ign--;
1748:
1749: /* Left-justify each table entry. */
1750: for (i = 0; i < columns; i++) {
1751: if (i > 0)
1752: texiputchar(p, ' ');
1753: texiputchar(p, 'l');
1754: }
1755: texiputchars(p, ".\n");
1756: p->outmacro++;
1.46 kristaps 1757: parseto(p, pos, texitoks[cmd].tok);
1.18 kristaps 1758: p->outmacro--;
1759: teximacro(p, "TE");
1.32 kristaps 1760: p->literal = svliteral;
1.18 kristaps 1761: p->list = sv;
1.1 kristaps 1762: }
1763:
1764: static void
1.46 kristaps 1765: dotable(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1766: {
1.3 kristaps 1767: enum texilist sv = p->list;
1768:
1.57 kristaps 1769: advanceeoln(p, pos, 1);
1770:
1.3 kristaps 1771: p->list = TEXILIST_ITEM;
1.5 kristaps 1772: teximacro(p, "Bl -tag -width Ds");
1.11 kristaps 1773: p->seenvs = 1;
1.46 kristaps 1774: parseto(p, pos, texitoks[cmd].tok);
1.5 kristaps 1775: teximacro(p, "El");
1.3 kristaps 1776: p->list = sv;
1.44 kristaps 1777: }
1778:
1779: static void
1.46 kristaps 1780: doend(struct texi *p, enum texicmd cmd, size_t *pos)
1.44 kristaps 1781: {
1782: size_t start;
1783:
1.46 kristaps 1784: while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
1785: advance(p, pos);
1.44 kristaps 1786: start = *pos;
1.46 kristaps 1787: while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
1788: advance(p, pos);
1.44 kristaps 1789:
1.56 kristaps 1790: texiwarn(p, "unexpected \"end\": %.*s",
1791: (int)(*pos - start), &BUF(p)[start]);
1.46 kristaps 1792: advanceeoln(p, pos, 1);
1.1 kristaps 1793: }
1794:
1795: static void
1.46 kristaps 1796: doenumerate(struct texi *p, enum texicmd cmd, size_t *pos)
1.2 kristaps 1797: {
1.3 kristaps 1798: enum texilist sv = p->list;
1.2 kristaps 1799:
1.57 kristaps 1800: advanceeoln(p, pos, 1);
1801:
1.3 kristaps 1802: p->list = TEXILIST_NOITEM;
1.5 kristaps 1803: teximacro(p, "Bl -enum");
1.11 kristaps 1804: p->seenvs = 1;
1.57 kristaps 1805: parseto(p, pos, texitoks[cmd].tok);
1.5 kristaps 1806: teximacro(p, "El");
1.3 kristaps 1807: p->list = sv;
1.2 kristaps 1808: }
1809:
1810: static void
1.46 kristaps 1811: doitemize(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1812: {
1.3 kristaps 1813: enum texilist sv = p->list;
1.1 kristaps 1814:
1.57 kristaps 1815: advanceeoln(p, pos, 1);
1816:
1.21 kristaps 1817: p->list = TEXILIST_NOITEM;
1.5 kristaps 1818: teximacro(p, "Bl -bullet");
1.11 kristaps 1819: p->seenvs = 1;
1.57 kristaps 1820: parseto(p, pos, texitoks[cmd].tok);
1.5 kristaps 1821: teximacro(p, "El");
1.3 kristaps 1822: p->list = sv;
1.1 kristaps 1823: }
1824:
1825: static void
1.46 kristaps 1826: doignbracket(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1827: {
1828:
1.3 kristaps 1829: p->ign++;
1.53 kristaps 1830: parsebracket(p, pos, 0);
1.3 kristaps 1831: p->ign--;
1.1 kristaps 1832: }
1833:
1834: static void
1.46 kristaps 1835: doignline(struct texi *p, enum texicmd cmd, size_t *pos)
1.1 kristaps 1836: {
1837:
1.57 kristaps 1838: advanceeoln(p, pos, 1);
1.1 kristaps 1839: }
1840:
1.8 kristaps 1841: /*
1842: * Parse colon-separated directories from "cp" (if not NULL) and returns
1843: * the array of pointers.
1.40 kristaps 1844: * Prepends "base" to the array, if found.
1.8 kristaps 1845: * This does NOT sanitise the directories!
1846: */
1.5 kristaps 1847: static char **
1.27 kristaps 1848: parsedirs(struct texi *p, const char *base, const char *cp, size_t *sz)
1.5 kristaps 1849: {
1850: char *tok, *str, *tofree;
1851: const char *cpp;
1.40 kristaps 1852: size_t i = 0;
1.5 kristaps 1853: char **dirs;
1854:
1.40 kristaps 1855: /* Count up our expected arguments. */
1856: *sz = NULL != base;
1857: if (NULL != (cpp = cp))
1858: for ((*sz)++; NULL != (cpp = strchr(cpp, ':')); (*sz)++)
1.5 kristaps 1859: cpp++;
1860:
1.40 kristaps 1861: if (0 == *sz)
1862: return(NULL);
1.27 kristaps 1863: if (NULL == (dirs = calloc(*sz, sizeof(char *))))
1864: texiabort(p, NULL);
1.40 kristaps 1865: if (NULL != base && NULL == (dirs[i++] = strdup(base)))
1.27 kristaps 1866: texiabort(p, NULL);
1.5 kristaps 1867: if (NULL == cp)
1868: return(dirs);
1.27 kristaps 1869: if (NULL == (tofree = tok = str = strdup(cp)))
1870: texiabort(p, NULL);
1.5 kristaps 1871:
1.40 kristaps 1872: for ( ; NULL != (tok = strsep(&str, ":")); i++)
1.27 kristaps 1873: if (NULL == (dirs[i] = strdup(tok)))
1874: texiabort(p, NULL);
1.5 kristaps 1875:
1876: free(tofree);
1877: return(dirs);
1878: }
1879:
1.1 kristaps 1880: int
1881: main(int argc, char *argv[])
1882: {
1883: struct texi texi;
1.2 kristaps 1884: int c;
1.37 kristaps 1885: char *dirpath, *dir, *ccp;
1.10 kristaps 1886: const char *progname, *Idir, *cp;
1.1 kristaps 1887:
1888: progname = strrchr(argv[0], '/');
1889: if (progname == NULL)
1890: progname = argv[0];
1891: else
1892: ++progname;
1893:
1.10 kristaps 1894: memset(&texi, 0, sizeof(struct texi));
1.40 kristaps 1895: texi.ign = 1;
1.55 kristaps 1896: texi.outfile = stdout;
1.5 kristaps 1897: Idir = NULL;
1.10 kristaps 1898:
1.55 kristaps 1899: while (-1 != (c = getopt(argc, argv, "C:I:")))
1.1 kristaps 1900: switch (c) {
1.55 kristaps 1901: case ('C'):
1902: texi.chapters = optarg;
1903: break;
1.5 kristaps 1904: case ('I'):
1905: Idir = optarg;
1906: break;
1.1 kristaps 1907: default:
1908: goto usage;
1909: }
1910:
1911: argv += optind;
1.40 kristaps 1912: argc -= optind;
1.1 kristaps 1913:
1.40 kristaps 1914: if (argc > 0) {
1915: if (NULL == (dirpath = strdup(argv[0])))
1916: texiabort(&texi, NULL);
1917: if (NULL == (dir = dirname(dirpath)))
1918: texiabort(&texi, NULL);
1919: if (NULL != (cp = strrchr(argv[0], '/')))
1920: texi.title = strdup(cp + 1);
1921: else
1922: texi.title = strdup(argv[0]);
1923: if (NULL == texi.title)
1924: texiabort(&texi, NULL);
1925: else if (NULL != (ccp = strchr(texi.title, '.')))
1926: *ccp = '\0';
1927: texi.dirs = parsedirs(&texi, dir, Idir, &texi.dirsz);
1928: free(dirpath);
1929: parsefile(&texi, argv[0], 1);
1930: } else {
1931: texi.title = strdup("Unknown Manual");
1932: texi.dirs = parsedirs(&texi, NULL, Idir, &texi.dirsz);
1933: parsestdin(&texi);
1934: }
1.27 kristaps 1935:
1.2 kristaps 1936: texiexit(&texi);
1.56 kristaps 1937: exit(EXIT_SUCCESS);
1.1 kristaps 1938: usage:
1.55 kristaps 1939: fprintf(stderr, "usage: %s [-Cdir] [-Idirs] [file]\n", progname);
1.1 kristaps 1940: return(EXIT_FAILURE);
1941: }
CVSweb
![[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