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