man_macro.c

   1 /*      $Id: man_macro.c,v 1.74 2012/06/12 12:47:14 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2012 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "man.h"
  28 #include "mandoc.h"
  29 #include "libmandoc.h"
  30 #include "libman.h"
  31
  32 enum    rew {
  33         REW_REWIND,
  34         REW_NOHALT,
  35         REW_HALT
  36 };
  37
  38 static  int              blk_close(MACRO_PROT_ARGS);
  39 static  int              blk_exp(MACRO_PROT_ARGS);
  40 static  int              blk_imp(MACRO_PROT_ARGS);
  41 static  int              in_line_eoln(MACRO_PROT_ARGS);
  42 static  int              man_args(struct man *, int,
  43                                 int *, char *, char **);
  44
  45 static  int              rew_scope(enum man_type,
  46                                 struct man *, enum mant);
  47 static  enum rew         rew_dohalt(enum mant, enum man_type,
  48                                 const struct man_node *);
  49 static  enum rew         rew_block(enum mant, enum man_type,
  50                                 const struct man_node *);
  51 static  void             rew_warn(struct man *,
  52                                 struct man_node *, enum mandocerr);
  53
  54 const   struct man_macro __man_macros[MAN_MAX] = {
  55         { in_line_eoln, MAN_NSCOPED }, /* br */
  56         { in_line_eoln, MAN_BSCOPE }, /* TH */
  57         { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SH */
  58         { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SS */
  59         { blk_imp, MAN_BSCOPE | MAN_SCOPED | MAN_FSCOPED }, /* TP */
  60         { blk_imp, MAN_BSCOPE }, /* LP */
  61         { blk_imp, MAN_BSCOPE }, /* PP */
  62         { blk_imp, MAN_BSCOPE }, /* P */
  63         { blk_imp, MAN_BSCOPE }, /* IP */
  64         { blk_imp, MAN_BSCOPE }, /* HP */
  65         { in_line_eoln, MAN_SCOPED }, /* SM */
  66         { in_line_eoln, MAN_SCOPED }, /* SB */
  67         { in_line_eoln, 0 }, /* BI */
  68         { in_line_eoln, 0 }, /* IB */
  69         { in_line_eoln, 0 }, /* BR */
  70         { in_line_eoln, 0 }, /* RB */
  71         { in_line_eoln, MAN_SCOPED }, /* R */
  72         { in_line_eoln, MAN_SCOPED }, /* B */
  73         { in_line_eoln, MAN_SCOPED }, /* I */
  74         { in_line_eoln, 0 }, /* IR */
  75         { in_line_eoln, 0 }, /* RI */
  76         { in_line_eoln, MAN_NSCOPED }, /* na */
  77         { in_line_eoln, MAN_NSCOPED }, /* sp */
  78         { in_line_eoln, MAN_BSCOPE }, /* nf */
  79         { in_line_eoln, MAN_BSCOPE }, /* fi */
  80         { blk_close, 0 }, /* RE */
  81         { blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* RS */
  82         { in_line_eoln, 0 }, /* DT */
  83         { in_line_eoln, 0 }, /* UC */
  84         { in_line_eoln, 0 }, /* PD */
  85         { in_line_eoln, 0 }, /* AT */
  86         { in_line_eoln, 0 }, /* in */
  87         { in_line_eoln, 0 }, /* ft */
  88         { in_line_eoln, 0 }, /* OP */
  89         { in_line_eoln, MAN_BSCOPE }, /* EX */
  90         { in_line_eoln, MAN_BSCOPE }, /* EE */
  91 };
  92
  93 const   struct man_macro * const man_macros = __man_macros;
  94
  95
  96 /*
  97  * Warn when "n" is an explicit non-roff macro.
  98  */
  99 static void
 100 rew_warn(struct man *m, struct man_node *n, enum mandocerr er)
 101 {
 102
 103         if (er == MANDOCERR_MAX || MAN_BLOCK != n->type)
 104                 return;
 105         if (MAN_VALID & n->flags)
 106                 return;
 107         if ( ! (MAN_EXPLICIT & man_macros[n->tok].flags))
 108                 return;
 109
 110         assert(er < MANDOCERR_FATAL);
 111         man_nmsg(m, n, er);
 112 }
 113
 114
 115 /*
 116  * Rewind scope.  If a code "er" != MANDOCERR_MAX has been provided, it
 117  * will be used if an explicit block scope is being closed out.
 118  */
 119 int
 120 man_unscope(struct man *m, const struct man_node *to,
 121                 enum mandocerr er)
 122 {
 123         struct man_node *n;
 124
 125         assert(to);
 126
 127         m->next = MAN_NEXT_SIBLING;
 128
 129         /* LINTED */
 130         while (m->last != to) {
 131                 /*
 132                  * Save the parent here, because we may delete the
 133                  * m->last node in the post-validation phase and reset
 134                  * it to m->last->parent, causing a step in the closing
 135                  * out to be lost.
 136                  */
 137                 n = m->last->parent;
 138                 rew_warn(m, m->last, er);
 139                 if ( ! man_valid_post(m))
 140                         return(0);
 141                 m->last = n;
 142                 assert(m->last);
 143         }
 144
 145         rew_warn(m, m->last, er);
 146         if ( ! man_valid_post(m))
 147                 return(0);
 148
 149         return(1);
 150 }
 151
 152
 153 static enum rew
 154 rew_block(enum mant ntok, enum man_type type, const struct man_node *n)
 155 {
 156
 157         if (MAN_BLOCK == type && ntok == n->parent->tok &&
 158                         MAN_BODY == n->parent->type)
 159                 return(REW_REWIND);
 160         return(ntok == n->tok ? REW_HALT : REW_NOHALT);
 161 }
 162
 163
 164 /*
 165  * There are three scope levels: scoped to the root (all), scoped to the
 166  * section (all less sections), and scoped to subsections (all less
 167  * sections and subsections).
 168  */
 169 static enum rew
 170 rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n)
 171 {
 172         enum rew         c;
 173
 174         /* We cannot progress beyond the root ever. */
 175         if (MAN_ROOT == n->type)
 176                 return(REW_HALT);
 177
 178         assert(n->parent);
 179
 180         /* Normal nodes shouldn't go to the level of the root. */
 181         if (MAN_ROOT == n->parent->type)
 182                 return(REW_REWIND);
 183
 184         /* Already-validated nodes should be closed out. */
 185         if (MAN_VALID & n->flags)
 186                 return(REW_NOHALT);
 187
 188         /* First: rewind to ourselves. */
 189         if (type == n->type && tok == n->tok) {
 190                 if (MAN_EXPLICIT & man_macros[n->tok].flags)
 191                         return(REW_HALT);
 192                 else
 193                         return(REW_REWIND);
 194         }
 195
 196         /*
 197          * Next follow the implicit scope-smashings as defined by man.7:
 198          * section, sub-section, etc.
 199          */
 200
 201         switch (tok) {
 202         case (MAN_SH):
 203                 break;
 204         case (MAN_SS):
 205                 /* Rewind to a section, if a block. */
 206                 if (REW_NOHALT != (c = rew_block(MAN_SH, type, n)))
 207                         return(c);
 208                 break;
 209         case (MAN_RS):
 210                 /* Preserve empty paragraphs before RS. */
 211                 if (0 == n->nchild && (MAN_P == n->tok ||
 212                     MAN_PP == n->tok || MAN_LP == n->tok))
 213                         return(REW_HALT);
 214                 /* Rewind to a subsection, if a block. */
 215                 if (REW_NOHALT != (c = rew_block(MAN_SS, type, n)))
 216                         return(c);
 217                 /* Rewind to a section, if a block. */
 218                 if (REW_NOHALT != (c = rew_block(MAN_SH, type, n)))
 219                         return(c);
 220                 break;
 221         default:
 222                 /* Rewind to an offsetter, if a block. */
 223                 if (REW_NOHALT != (c = rew_block(MAN_RS, type, n)))
 224                         return(c);
 225                 /* Rewind to a subsection, if a block. */
 226                 if (REW_NOHALT != (c = rew_block(MAN_SS, type, n)))
 227                         return(c);
 228                 /* Rewind to a section, if a block. */
 229                 if (REW_NOHALT != (c = rew_block(MAN_SH, type, n)))
 230                         return(c);
 231                 break;
 232         }
 233
 234         return(REW_NOHALT);
 235 }
 236
 237
 238 /*
 239  * Rewinding entails ascending the parse tree until a coherent point,
 240  * for example, the `SH' macro will close out any intervening `SS'
 241  * scopes.  When a scope is closed, it must be validated and actioned.
 242  */
 243 static int
 244 rew_scope(enum man_type type, struct man *m, enum mant tok)
 245 {
 246         struct man_node *n;
 247         enum rew         c;
 248
 249         /* LINTED */
 250         for (n = m->last; n; n = n->parent) {
 251                 /*
 252                  * Whether we should stop immediately (REW_HALT), stop
 253                  * and rewind until this point (REW_REWIND), or keep
 254                  * rewinding (REW_NOHALT).
 255                  */
 256                 c = rew_dohalt(tok, type, n);
 257                 if (REW_HALT == c)
 258                         return(1);
 259                 if (REW_REWIND == c)
 260                         break;
 261         }
 262
 263         /*
 264          * Rewind until the current point.  Warn if we're a roff
 265          * instruction that's mowing over explicit scopes.
 266          */
 267         assert(n);
 268
 269         return(man_unscope(m, n, MANDOCERR_MAX));
 270 }
 271
 272
 273 /*
 274  * Close out a generic explicit macro.
 275  */
 276 /* ARGSUSED */
 277 int
 278 blk_close(MACRO_PROT_ARGS)
 279 {
 280         enum mant                ntok;
 281         const struct man_node   *nn;
 282
 283         switch (tok) {
 284         case (MAN_RE):
 285                 ntok = MAN_RS;
 286                 break;
 287         default:
 288                 abort();
 289                 /* NOTREACHED */
 290         }
 291
 292         for (nn = m->last->parent; nn; nn = nn->parent)
 293                 if (ntok == nn->tok && MAN_BLOCK == nn->type)
 294                         break;
 295
 296         if (NULL != nn)
 297                 man_unscope(m, nn, MANDOCERR_MAX);
 298         else
 299                 man_pmsg(m, line, ppos, MANDOCERR_NOSCOPE);
 300
 301         return(1);
 302 }
 303
 304
 305 /* ARGSUSED */
 306 int
 307 blk_exp(MACRO_PROT_ARGS)
 308 {
 309         struct man_node *n;
 310         int              la;
 311         char            *p;
 312
 313         /* Close out prior implicit scopes. */
 314
 315         if ( ! rew_scope(MAN_BLOCK, m, tok))
 316                 return(0);
 317
 318         if ( ! man_block_alloc(m, line, ppos, tok))
 319                 return(0);
 320         if ( ! man_head_alloc(m, line, ppos, tok))
 321                 return(0);
 322
 323         for (;;) {
 324                 la = *pos;
 325                 if ( ! man_args(m, line, pos, buf, &p))
 326                         break;
 327                 if ( ! man_word_alloc(m, line, la, p))
 328                         return(0);
 329         }
 330
 331         assert(m);
 332         assert(tok != MAN_MAX);
 333
 334         for (n = m->last; n; n = n->parent) {
 335                 if (n->tok != tok)
 336                         continue;
 337                 assert(MAN_HEAD == n->type);
 338                 man_unscope(m, n, MANDOCERR_MAX);
 339                 break;
 340         }
 341
 342         return(man_body_alloc(m, line, ppos, tok));
 343 }
 344
 345
 346
 347 /*
 348  * Parse an implicit-block macro.  These contain a MAN_HEAD and a
 349  * MAN_BODY contained within a MAN_BLOCK.  Rules for closing out other
 350  * scopes, such as `SH' closing out an `SS', are defined in the rew
 351  * routines.
 352  */
 353 /* ARGSUSED */
 354 int
 355 blk_imp(MACRO_PROT_ARGS)
 356 {
 357         int              la;
 358         char            *p;
 359         struct man_node *n;
 360
 361         /* Close out prior scopes. */
 362
 363         if ( ! rew_scope(MAN_BODY, m, tok))
 364                 return(0);
 365         if ( ! rew_scope(MAN_BLOCK, m, tok))
 366                 return(0);
 367
 368         /* Allocate new block & head scope. */
 369
 370         if ( ! man_block_alloc(m, line, ppos, tok))
 371                 return(0);
 372         if ( ! man_head_alloc(m, line, ppos, tok))
 373                 return(0);
 374
 375         n = m->last;
 376
 377         /* Add line arguments. */
 378
 379         for (;;) {
 380                 la = *pos;
 381                 if ( ! man_args(m, line, pos, buf, &p))
 382                         break;
 383                 if ( ! man_word_alloc(m, line, la, p))
 384                         return(0);
 385         }
 386
 387         /* Close out head and open body (unless MAN_SCOPE). */
 388
 389         if (MAN_SCOPED & man_macros[tok].flags) {
 390                 /* If we're forcing scope (`TP'), keep it open. */
 391                 if (MAN_FSCOPED & man_macros[tok].flags) {
 392                         m->flags |= MAN_BLINE;
 393                         return(1);
 394                 } else if (n == m->last) {
 395                         m->flags |= MAN_BLINE;
 396                         return(1);
 397                 }
 398         }
 399
 400         if ( ! rew_scope(MAN_HEAD, m, tok))
 401                 return(0);
 402         return(man_body_alloc(m, line, ppos, tok));
 403 }
 404
 405
 406 /* ARGSUSED */
 407 int
 408 in_line_eoln(MACRO_PROT_ARGS)
 409 {
 410         int              la;
 411         char            *p;
 412         struct man_node *n;
 413
 414         if ( ! man_elem_alloc(m, line, ppos, tok))
 415                 return(0);
 416
 417         n = m->last;
 418
 419         for (;;) {
 420                 la = *pos;
 421                 if ( ! man_args(m, line, pos, buf, &p))
 422                         break;
 423                 if ( ! man_word_alloc(m, line, la, p))
 424                         return(0);
 425         }
 426
 427         /*
 428          * If no arguments are specified and this is MAN_SCOPED (i.e.,
 429          * next-line scoped), then set our mode to indicate that we're
 430          * waiting for terms to load into our context.
 431          */
 432
 433         if (n == m->last && MAN_SCOPED & man_macros[tok].flags) {
 434                 assert( ! (MAN_NSCOPED & man_macros[tok].flags));
 435                 m->flags |= MAN_ELINE;
 436                 return(1);
 437         }
 438
 439         /* Set ignorable context, if applicable. */
 440
 441         if (MAN_NSCOPED & man_macros[tok].flags) {
 442                 assert( ! (MAN_SCOPED & man_macros[tok].flags));
 443                 m->flags |= MAN_ILINE;
 444         }
 445
 446         assert(MAN_ROOT != m->last->type);
 447         m->next = MAN_NEXT_SIBLING;
 448
 449         /*
 450          * Rewind our element scope.  Note that when TH is pruned, we'll
 451          * be back at the root, so make sure that we don't clobber as
 452          * its sibling.
 453          */
 454
 455         for ( ; m->last; m->last = m->last->parent) {
 456                 if (m->last == n)
 457                         break;
 458                 if (m->last->type == MAN_ROOT)
 459                         break;
 460                 if ( ! man_valid_post(m))
 461                         return(0);
 462         }
 463
 464         assert(m->last);
 465
 466         /*
 467          * Same here regarding whether we're back at the root.
 468          */
 469
 470         if (m->last->type != MAN_ROOT && ! man_valid_post(m))
 471                 return(0);
 472
 473         return(1);
 474 }
 475
 476
 477 int
 478 man_macroend(struct man *m)
 479 {
 480
 481         return(man_unscope(m, m->first, MANDOCERR_SCOPEEXIT));
 482 }
 483
 484 static int
 485 man_args(struct man *m, int line, int *pos, char *buf, char **v)
 486 {
 487         char     *start;
 488
 489         assert(*pos);
 490         *v = start = buf + *pos;
 491         assert(' ' != *start);
 492
 493         if ('\0' == *start)
 494                 return(0);
 495
 496         *v = mandoc_getarg(m->parse, v, line, pos);
 497         return(1);
 498 }