mdocml.c

   1 /* $Id: mdocml.c,v 1.41 2009/01/12 16:39:57 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
   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
   7  * above copyright notice and this permission notice appear in all
   8  * copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include <sys/stat.h>
  20 #include <sys/param.h>
  21
  22 #include <assert.h>
  23 #include <fcntl.h>
  24 #include <err.h>
  25 #include <getopt.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30
  31 #include "mdoc.h"
  32
  33 #define MD_LINE_SZ      (256)
  34
  35 struct  md_parse {
  36         int              warn;
  37 #define MD_WARN_ALL     (1 << 0)
  38 #define MD_WARN_ERR     (1 << 1)
  39         int              dbg;
  40         struct mdoc     *mdoc;
  41         char            *buf;
  42         u_long           bufsz;
  43         char            *name;
  44         int              fd;
  45         int              lnn;
  46         char            *line;
  47 };
  48
  49 static  void             usage(void);
  50
  51 static  int              parse_begin(struct md_parse *);
  52 static  int              parse_leave(struct md_parse *, int);
  53 static  int              io_begin(struct md_parse *);
  54 static  int              io_leave(struct md_parse *, int);
  55 static  int              buf_begin(struct md_parse *);
  56 static  int              buf_leave(struct md_parse *, int);
  57
  58 static  int              msg_err(void *, int, int, enum mdoc_err);
  59 static  int              msg_warn(void *, int, int, enum mdoc_warn);
  60 static  void             msg_msg(void *, int, int, const char *);
  61
  62 #ifdef __linux__
  63 extern  int              getsubopt(char **, char *const *, char **);
  64 #endif
  65
  66 int
  67 main(int argc, char *argv[])
  68 {
  69         int              c;
  70         struct md_parse  parser;
  71         char            *opts, *v;
  72 #define ALL              0
  73 #define ERROR            1
  74         char            *toks[] = { "all", "error", NULL };
  75
  76         extern char     *optarg;
  77         extern int       optind;
  78
  79         (void)memset(&parser, 0, sizeof(struct md_parse));
  80
  81         while (-1 != (c = getopt(argc, argv, "vW:")))
  82                 switch (c) {
  83                 case ('v'):
  84                         parser.dbg++;
  85                         break;
  86                 case ('W'):
  87                         opts = optarg;
  88                         while (*opts)
  89                                 switch (getsubopt(&opts, toks, &v)) {
  90                                 case (ALL):
  91                                         parser.warn |= MD_WARN_ALL;
  92                                         break;
  93                                 case (ERROR):
  94                                         parser.warn |= MD_WARN_ERR;
  95                                         break;
  96                                 default:
  97                                         usage();
  98                                         return(1);
  99                                 }
 100                         break;
 101                 default:
 102                         usage();
 103                         return(1);
 104                 }
 105
 106         argv += optind;
 107         argc -= optind;
 108
 109         parser.name = "-";
 110         if (1 == argc)
 111                 parser.name = *argv++;
 112
 113         if ( ! io_begin(&parser))
 114                 return(EXIT_FAILURE);
 115
 116         return(EXIT_SUCCESS);
 117 }
 118
 119
 120 static int
 121 io_leave(struct md_parse *p, int code)
 122 {
 123
 124         if (-1 == p->fd || STDIN_FILENO == p->fd)
 125                 return(code);
 126
 127         if (-1 == close(p->fd)) {
 128                 warn("%s", p->name);
 129                 code = 0;
 130         }
 131         return(code);
 132 }
 133
 134
 135 static int
 136 io_begin(struct md_parse *p)
 137 {
 138
 139         p->fd = STDIN_FILENO;
 140         if (0 != strncmp(p->name, "-", 1))
 141                 if (-1 == (p->fd = open(p->name, O_RDONLY, 0))) {
 142                         warn("%s", p->name);
 143                         return(io_leave(p, 0));
 144                 }
 145
 146         return(io_leave(p, buf_begin(p)));
 147 }
 148
 149
 150 static int
 151 buf_leave(struct md_parse *p, int code)
 152 {
 153
 154         if (p->buf)
 155                 free(p->buf);
 156         return(code);
 157 }
 158
 159
 160 static int
 161 buf_begin(struct md_parse *p)
 162 {
 163         struct stat      st;
 164
 165         if (-1 == fstat(p->fd, &st)) {
 166                 warn("%s", p->name);
 167                 return(1);
 168         }
 169
 170         p->bufsz = MAX(st.st_blksize, BUFSIZ);
 171
 172         if (NULL == (p->buf = malloc(p->bufsz))) {
 173                 warn("malloc");
 174                 return(buf_leave(p, 0));
 175         }
 176
 177         return(buf_leave(p, parse_begin(p)));
 178 }
 179
 180
 181 static void
 182 print_node(const struct mdoc_node *n, int indent)
 183 {
 184         const char       *p, *t;
 185         int               i, j;
 186         size_t            argc, sz;
 187         char            **params;
 188         struct mdoc_arg  *argv;
 189
 190         argv = NULL;
 191         argc = 0;
 192         params = NULL;
 193         sz = 0;
 194
 195         /* FIXME: put parts of this in util.c. */
 196         switch (n->type) {
 197         case (MDOC_TEXT):
 198                 assert(NULL == n->child);
 199                 p = n->data.text.string;
 200                 t = "text";
 201                 break;
 202         case (MDOC_BODY):
 203                 p = mdoc_macronames[n->tok];
 204                 t = "block-body";
 205                 break;
 206         case (MDOC_HEAD):
 207                 p = mdoc_macronames[n->tok];
 208                 t = "block-head";
 209                 break;
 210         case (MDOC_TAIL):
 211                 p = mdoc_macronames[n->tok];
 212                 t = "block-tail";
 213                 break;
 214         case (MDOC_ELEM):
 215                 p = mdoc_macronames[n->tok];
 216                 t = "element";
 217                 argv = n->data.elem.argv;
 218                 argc = n->data.elem.argc;
 219                 break;
 220         case (MDOC_BLOCK):
 221                 p = mdoc_macronames[n->tok];
 222                 t = "block";
 223                 argv = n->data.block.argv;
 224                 argc = n->data.block.argc;
 225                 break;
 226         case (MDOC_ROOT):
 227                 p = "root";
 228                 t = "root";
 229                 break;
 230         default:
 231                 abort();
 232                 /* NOTREACHED */
 233         }
 234
 235         for (i = 0; i < indent; i++)
 236                 (void)printf("    ");
 237         (void)printf("%s (%s)", p, t);
 238
 239         for (i = 0; i < (int)argc; i++) {
 240                 (void)printf(" -%s", mdoc_argnames[argv[i].arg]);
 241                 if (j > 0)
 242                         (void)printf(" [");
 243                 for (j = 0; j < (int)argv[i].sz; j++)
 244                         (void)printf(" [%s]", argv[i].value[j]);
 245                 if (j > 0)
 246                         (void)printf(" ]");
 247         }
 248
 249         for (i = 0; i < (int)sz; i++)
 250                 (void)printf(" [%s]", params[i]);
 251
 252         (void)printf(" %d:%d\n", n->line, n->pos);
 253
 254         if (n->child)
 255                 print_node(n->child, indent + 1);
 256         if (n->next)
 257                 print_node(n->next, indent);
 258 }
 259
 260
 261 static int
 262 parse_leave(struct md_parse *p, int code)
 263 {
 264         const struct mdoc_node *n;
 265
 266         if (NULL == p->mdoc)
 267                 return(code);
 268
 269         if ( ! mdoc_endparse(p->mdoc))
 270                 code = 0;
 271         if ((n = mdoc_result(p->mdoc)))
 272                 print_node(n, 0);
 273
 274         mdoc_free(p->mdoc);
 275
 276         return(code);
 277 }
 278
 279
 280 static int
 281 parse_begin(struct md_parse *p)
 282 {
 283         ssize_t          sz, i;
 284         size_t           pos;
 285         char             line[256], sv[256];
 286         struct mdoc_cb   cb;
 287
 288         cb.mdoc_err = msg_err;
 289         cb.mdoc_warn = msg_warn;
 290         cb.mdoc_msg = msg_msg;
 291
 292         if (NULL == (p->mdoc = mdoc_alloc(p, &cb)))
 293                 return(parse_leave(p, 0));
 294
 295         p->lnn = 1;
 296         p->line = sv;
 297
 298         for (pos = 0; ; ) {
 299                 if (-1 == (sz = read(p->fd, p->buf, p->bufsz))) {
 300                         warn("%s", p->name);
 301                         return(parse_leave(p, 0));
 302                 } else if (0 == sz)
 303                         break;
 304
 305                 for (i = 0; i < sz; i++) {
 306                         if ('\n' != p->buf[i]) {
 307                                 if (pos < sizeof(line)) {
 308                                         sv[(int)pos] = p->buf[(int)i];
 309                                         line[(int)pos++] =
 310                                                 p->buf[(int)i];
 311                                         continue;
 312                                 }
 313                                 warnx("%s: line %d too long",
 314                                                 p->name, p->lnn);
 315                                 return(parse_leave(p, 0));
 316                         }
 317
 318                         line[(int)pos] = sv[(int)pos] = 0;
 319                         if ( ! mdoc_parseln(p->mdoc, p->lnn, line))
 320                                 return(parse_leave(p, 0));
 321
 322                         p->lnn++;
 323                         pos = 0;
 324                 }
 325         }
 326
 327         return(parse_leave(p, 1));
 328 }
 329
 330
 331 static int
 332 msg_err(void *arg, int line, int col, enum mdoc_err type)
 333 {
 334         char             *lit;
 335         struct md_parse  *p;
 336
 337         p = (struct md_parse *)arg;
 338
 339         lit = NULL;
 340
 341         switch (type) {
 342         case (ERR_SYNTAX_NOTEXT):
 343                 lit = "syntax: context-free text disallowed";
 344                 break;
 345         case (ERR_SYNTAX_QUOTE):
 346                 lit = "syntax: disallowed argument quotation";
 347                 break;
 348         case (ERR_SYNTAX_UNQUOTE):
 349                 lit = "syntax: unterminated quotation";
 350                 break;
 351         case (ERR_SYNTAX_WS):
 352                 lit = "syntax: whitespace in argument";
 353                 break;
 354         case (ERR_SYNTAX_ARGFORM):
 355                 lit = "syntax: macro arguments malformed";
 356                 break;
 357         case (ERR_SYNTAX_NOPUNCT):
 358                 lit = "syntax: macro doesn't understand punctuation";
 359                 break;
 360         case (ERR_SYNTAX_ARG):
 361                 lit = "syntax: unknown argument for macro";
 362                 break;
 363         case (ERR_SCOPE_BREAK):
 364                 /* Which scope is broken? */
 365                 lit = "scope: macro breaks prior explicit scope";
 366                 break;
 367         case (ERR_SCOPE_NOCTX):
 368                 lit = "scope: closure macro has no context";
 369                 break;
 370         case (ERR_SCOPE_NONEST):
 371                 lit = "scope: macro may not be nested in the current context";
 372                 break;
 373         case (ERR_MACRO_NOTSUP):
 374                 lit = "macro not supported";
 375                 break;
 376         case (ERR_MACRO_NOTCALL):
 377                 lit = "macro not callable";
 378                 break;
 379         case (ERR_SEC_PROLOGUE):
 380                 lit = "macro cannot be called in the prologue";
 381                 break;
 382         case (ERR_SEC_NPROLOGUE):
 383                 lit = "macro called outside of prologue";
 384                 break;
 385         case (ERR_ARGS_EQ0):
 386                 lit = "macro expects zero arguments";
 387                 break;
 388         case (ERR_ARGS_EQ1):
 389                 lit = "macro expects one argument";
 390                 break;
 391         case (ERR_ARGS_GE1):
 392                 lit = "macro expects one or more arguments";
 393                 break;
 394         case (ERR_ARGS_LE2):
 395                 lit = "macro expects two or fewer arguments";
 396                 break;
 397         case (ERR_ARGS_LE8):
 398                 lit = "macro expects eight or fewer arguments";
 399                 break;
 400         case (ERR_ARGS_MANY):
 401                 lit = "macro has too many arguments";
 402                 break;
 403         case (ERR_SEC_PROLOGUE_OO):
 404                 lit = "prologue macro is out-of-order";
 405                 break;
 406         case (ERR_SEC_PROLOGUE_REP):
 407                 lit = "prologue macro repeated";
 408                 break;
 409         case (ERR_SEC_NAME):
 410                 lit = "`NAME' section must be first";
 411                 break;
 412         case (ERR_SYNTAX_ARGVAL):
 413                 lit = "syntax: expected value for macro argument";
 414                 break;
 415         case (ERR_SYNTAX_ARGBAD):
 416                 lit = "syntax: invalid value(s) for macro argument";
 417                 break;
 418         case (ERR_SYNTAX_ARGMISS):
 419                 lit = "syntax: missing required argument(s) for macro";
 420                 break;
 421         case (ERR_SYNTAX_ARGMANY):
 422                 lit = "syntax: too many values for macro argument";
 423                 break;
 424         case (ERR_SYNTAX_CHILDBAD):
 425                 lit = "syntax: invalid child for parent macro";
 426                 break;
 427         case (ERR_SYNTAX_PARENTBAD):
 428                 lit = "syntax: invalid parent for macro";
 429                 break;
 430         case (ERR_SYNTAX_CHILDHEAD):
 431                 lit = "syntax: expected only block-header section";
 432                 break;
 433         case (ERR_SYNTAX_CHILDBODY):
 434                 lit = "syntax: expected only a block-body section";
 435                 break;
 436         case (ERR_SYNTAX_EMPTYHEAD):
 437                 lit = "syntax: block-header section may not be empty";
 438                 break;
 439         case (ERR_SYNTAX_EMPTYBODY):
 440                 lit = "syntax: block-body section may not be empty";
 441                 break;
 442         default:
 443                 abort();
 444                 /* NOTREACHED */
 445         }
 446
 447         (void)fprintf(stderr, "%s:%d: error: %s (column %d)\n",
 448                         p->name, line, lit, col);
 449         return(0);
 450 }
 451
 452
 453 static void
 454 msg_msg(void *arg, int line, int col, const char *msg)
 455 {
 456         struct md_parse  *p;
 457
 458         p = (struct md_parse *)arg;
 459
 460         if (p->dbg < 2)
 461                 return;
 462
 463         (void)printf("%s:%d: %s (column %d)\n",
 464                         p->name, line, msg, col);
 465 }
 466
 467
 468 static int
 469 msg_warn(void *arg, int line, int col, enum mdoc_warn type)
 470 {
 471         char             *lit;
 472         struct md_parse  *p;
 473         extern char      *__progname;
 474
 475         p = (struct md_parse *)arg;
 476
 477         if ( ! (p->warn & MD_WARN_ALL))
 478                 return(1);
 479
 480         lit = NULL;
 481
 482         switch (type) {
 483         case (WARN_SYNTAX_WS_EOLN):
 484                 lit = "syntax: whitespace at end-of-line";
 485                 break;
 486         case (WARN_SYNTAX_QUOTED):
 487                 lit = "syntax: quotation mark starting string";
 488                 break;
 489         case (WARN_SYNTAX_MACLIKE):
 490                 lit = "syntax: macro-like argument";
 491                 break;
 492         case (WARN_SYNTAX_ARGLIKE):
 493                 lit = "syntax: argument-like value";
 494                 break;
 495         case (WARN_SYNTAX_EMPTYBODY):
 496                 lit = "syntax: macro suggests non-empty block-body section";
 497                 break;
 498         case (WARN_SYNTAX_EMPTYHEAD):
 499                 lit = "syntax: macro suggests non-empty block-head section";
 500                 break;
 501         case (WARN_SYNTAX_NOBODY):
 502                 lit = "syntax: macro suggests empty block-body section";
 503                 break;
 504         case (WARN_SEC_OO):
 505                 lit = "section is out of conventional order";
 506                 break;
 507         case (WARN_SEC_REP):
 508                 lit = "section repeated";
 509                 break;
 510         case (WARN_ARGS_GE1):
 511                 lit = "macro suggests one or more arguments";
 512                 break;
 513         case (WARN_ARGS_EQ0):
 514                 lit = "macro suggests zero arguments";
 515                 break;
 516         case (WARN_IGN_AFTER_BLK):
 517                 lit = "ignore: macro ignored after block macro";
 518                 break;
 519         case (WARN_IGN_OBSOLETE):
 520                 lit = "ignore: macro is obsolete";
 521                 break;
 522         case (WARN_IGN_BEFORE_BLK):
 523                 lit = "ignore: macro before block macro ignored";
 524                 break;
 525         case (WARN_COMPAT_TROFF):
 526                 lit = "compat: macro behaves differently in troff and nroff";
 527                 break;
 528         default:
 529                 abort();
 530                 /* NOTREACHED */
 531         }
 532
 533
 534         (void)fprintf(stderr, "%s:%d: warning: %s (column %d)\n",
 535                         p->name, line, lit, col);
 536
 537         if (p->warn & MD_WARN_ERR) {
 538                 (void)fprintf(stderr, "%s: considering warnings as "
 539                                 "errors\n", __progname);
 540                 return(0);
 541         }
 542
 543         return(1);
 544 }
 545
 546
 547 static void
 548 usage(void)
 549 {
 550         extern char     *__progname;
 551
 552         (void)fprintf(stderr, "usage: %s [-v] [-Wwarn...] [infile]\n",
 553                         __progname);
 554 }
 555