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