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