mandoc.c

   1 /*      $Id: mandoc.c,v 1.46 2011/04/09 15:35:30 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2011 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 AUTHORS DISCLAIM ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS 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 <sys/types.h>
  23
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <time.h>
  30
  31 #include "mandoc.h"
  32 #include "libmandoc.h"
  33
  34 #define DATESIZE 32
  35
  36 static  int      a2time(time_t *, const char *, const char *);
  37 static  char    *time2a(time_t);
  38 static  int      numescape(const char *);
  39
  40 /*
  41  * Pass over recursive numerical expressions.  This context of this
  42  * function is important: it's only called within character-terminating
  43  * escapes (e.g., \s[xxxyyy]), so all we need to do is handle initial
  44  * recursion: we don't care about what's in these blocks.
  45  * This returns the number of characters skipped or -1 if an error
  46  * occurs (the caller should bail).
  47  */
  48 static int
  49 numescape(const char *start)
  50 {
  51         int              i;
  52         size_t           sz;
  53         const char      *cp;
  54
  55         i = 0;
  56
  57         /* The expression consists of a subexpression. */
  58
  59         if ('\\' == start[i]) {
  60                 cp = &start[++i];
  61                 /*
  62                  * Read past the end of the subexpression.
  63                  * Bail immediately on errors.
  64                  */
  65                 if (ESCAPE_ERROR == mandoc_escape(&cp, NULL, NULL))
  66                         return(-1);
  67                 return(i + cp - &start[i]);
  68         }
  69
  70         if ('(' != start[i++])
  71                 return(0);
  72
  73         /*
  74          * A parenthesised subexpression.  Read until the closing
  75          * parenthesis, making sure to handle any nested subexpressions
  76          * that might ruin our parse.
  77          */
  78
  79         while (')' != start[i]) {
  80                 sz = strcspn(&start[i], ")\\");
  81                 i += (int)sz;
  82
  83                 if ('\0' == start[i])
  84                         return(-1);
  85                 else if ('\\' != start[i])
  86                         continue;
  87
  88                 cp = &start[++i];
  89                 if (ESCAPE_ERROR == mandoc_escape(&cp, NULL, NULL))
  90                         return(-1);
  91                 i += cp - &start[i];
  92         }
  93
  94         /* Read past the terminating ')'. */
  95         return(++i);
  96 }
  97
  98 /*
  99  * Handle an escaped sequeence.  This should be called with any
 100  * string subsequent a `\'.  Pass a pointer to this substring as "end";
 101  * it will be set to the supremum of the parsed escape sequence.  If
 102  * this returns ESCAPE_ERROR, the string is bogus and should be thrown
 103  * away.  If not ESCAPE_ERROR or ESCAPE_IGNORE, "start" is set to the
 104  * first relevant character of the substring (font, glyph, whatever) of
 105  * length sz.  Both "start" and "sz" may be NULL.
 106  */
 107 enum mandoc_esc
 108 mandoc_escape(const char **end, const char **start, int *sz)
 109 {
 110         char             c, term, numeric;
 111         int              i, lim, ssz, rlim;
 112         const char      *cp, *rstart;
 113         enum mandoc_esc  gly;
 114
 115         cp = *end;
 116         rstart = cp;
 117         if (start)
 118                 *start = rstart;
 119         i = lim = 0;
 120         gly = ESCAPE_ERROR;
 121         term = numeric = '\0';
 122
 123         switch ((c = cp[i++])) {
 124         /*
 125          * First the glyphs.  There are several different forms of
 126          * these, but each eventually returns a substring of the glyph
 127          * name.
 128          */
 129         case ('('):
 130                 gly = ESCAPE_SPECIAL;
 131                 lim = 2;
 132                 break;
 133         case ('['):
 134                 gly = ESCAPE_SPECIAL;
 135                 term = ']';
 136                 break;
 137         case ('C'):
 138                 if ('\'' != cp[i])
 139                         return(ESCAPE_ERROR);
 140                 gly = ESCAPE_SPECIAL;
 141                 term = '\'';
 142                 break;
 143
 144         /*
 145          * Handle all triggers matching \X(xy, \Xx, and \X[xxxx], where
 146          * 'X' is the trigger.  These have opaque sub-strings.
 147          */
 148         case ('F'):
 149                 /* FALLTHROUGH */
 150         case ('g'):
 151                 /* FALLTHROUGH */
 152         case ('k'):
 153                 /* FALLTHROUGH */
 154         case ('M'):
 155                 /* FALLTHROUGH */
 156         case ('m'):
 157                 /* FALLTHROUGH */
 158         case ('n'):
 159                 /* FALLTHROUGH */
 160         case ('V'):
 161                 /* FALLTHROUGH */
 162         case ('Y'):
 163                 if (ESCAPE_ERROR == gly)
 164                         gly = ESCAPE_IGNORE;
 165                 /* FALLTHROUGH */
 166         case ('*'):
 167                 if (ESCAPE_ERROR == gly)
 168                         gly = ESCAPE_PREDEF;
 169                 /* FALLTHROUGH */
 170         case ('f'):
 171                 if (ESCAPE_ERROR == gly)
 172                         gly = ESCAPE_FONT;
 173
 174                 rstart= &cp[i];
 175                 if (start)
 176                         *start = rstart;
 177
 178                 switch (cp[i++]) {
 179                 case ('('):
 180                         lim = 2;
 181                         break;
 182                 case ('['):
 183                         term = ']';
 184                         break;
 185                 default:
 186                         lim = 1;
 187                         i--;
 188                         break;
 189                 }
 190                 break;
 191
 192         /*
 193          * These escapes are of the form \X'Y', where 'X' is the trigger
 194          * and 'Y' is any string.  These have opaque sub-strings.
 195          */
 196         case ('A'):
 197                 /* FALLTHROUGH */
 198         case ('b'):
 199                 /* FALLTHROUGH */
 200         case ('D'):
 201                 /* FALLTHROUGH */
 202         case ('o'):
 203                 /* FALLTHROUGH */
 204         case ('R'):
 205                 /* FALLTHROUGH */
 206         case ('X'):
 207                 /* FALLTHROUGH */
 208         case ('Z'):
 209                 if ('\'' != cp[i++])
 210                         return(ESCAPE_ERROR);
 211                 gly = ESCAPE_IGNORE;
 212                 term = '\'';
 213                 break;
 214
 215         /*
 216          * These escapes are of the form \X'N', where 'X' is the trigger
 217          * and 'N' resolves to a numerical expression.
 218          */
 219         case ('B'):
 220                 /* FALLTHROUGH */
 221         case ('h'):
 222                 /* FALLTHROUGH */
 223         case ('H'):
 224                 /* FALLTHROUGH */
 225         case ('L'):
 226                 /* FALLTHROUGH */
 227         case ('l'):
 228                 /* FALLTHROUGH */
 229         case ('N'):
 230                 if (ESCAPE_ERROR == gly)
 231                         gly = ESCAPE_NUMBERED;
 232                 /* FALLTHROUGH */
 233         case ('S'):
 234                 /* FALLTHROUGH */
 235         case ('v'):
 236                 /* FALLTHROUGH */
 237         case ('w'):
 238                 /* FALLTHROUGH */
 239         case ('x'):
 240                 if (ESCAPE_ERROR == gly)
 241                         gly = ESCAPE_IGNORE;
 242                 if ('\'' != cp[i++])
 243                         return(ESCAPE_ERROR);
 244                 term = numeric = '\'';
 245                 break;
 246
 247         /*
 248          * Sizes get a special category of their own.
 249          */
 250         case ('s'):
 251                 gly = ESCAPE_IGNORE;
 252
 253                 rstart = &cp[i];
 254                 if (start)
 255                         *start = rstart;
 256
 257                 /* See +/- counts as a sign. */
 258                 c = cp[i];
 259                 if ('+' == c || '-' == c || ASCII_HYPH == c)
 260                         ++i;
 261
 262                 switch (cp[i++]) {
 263                 case ('('):
 264                         lim = 2;
 265                         break;
 266                 case ('['):
 267                         term = numeric = ']';
 268                         break;
 269                 case ('\''):
 270                         term = numeric = '\'';
 271                         break;
 272                 default:
 273                         lim = 1;
 274                         i--;
 275                         break;
 276                 }
 277
 278                 /* See +/- counts as a sign. */
 279                 c = cp[i];
 280                 if ('+' == c || '-' == c || ASCII_HYPH == c)
 281                         ++i;
 282
 283                 break;
 284
 285         /*
 286          * Anything else is assumed to be a glyph.
 287          */
 288         default:
 289                 gly = ESCAPE_SPECIAL;
 290                 lim = 1;
 291                 i--;
 292                 break;
 293         }
 294
 295         assert(ESCAPE_ERROR != gly);
 296
 297         rstart = &cp[i];
 298         if (start)
 299                 *start = rstart;
 300
 301         /*
 302          * If a terminating block has been specified, we need to
 303          * handle the case of recursion, which could have their
 304          * own terminating blocks that mess up our parse.  This, by the
 305          * way, means that the "start" and "size" values will be
 306          * effectively meaningless.
 307          */
 308
 309         ssz = 0;
 310         if (numeric && -1 == (ssz = numescape(&cp[i])))
 311                 return(ESCAPE_ERROR);
 312
 313         i += ssz;
 314         rlim = -1;
 315
 316         /*
 317          * We have a character terminator.  Try to read up to that
 318          * character.  If we can't (i.e., we hit the nil), then return
 319          * an error; if we can, calculate our length, read past the
 320          * terminating character, and exit.
 321          */
 322
 323         if ('\0' != term) {
 324                 *end = strchr(&cp[i], term);
 325                 if ('\0' == *end)
 326                         return(ESCAPE_ERROR);
 327
 328                 rlim = *end - &cp[i];
 329                 if (sz)
 330                         *sz = rlim;
 331                 (*end)++;
 332                 goto out;
 333         }
 334
 335         assert(lim > 0);
 336
 337         /*
 338          * We have a numeric limit.  If the string is shorter than that,
 339          * stop and return an error.  Else adjust our endpoint, length,
 340          * and return the current glyph.
 341          */
 342
 343         if ((size_t)lim > strlen(&cp[i]))
 344                 return(ESCAPE_ERROR);
 345
 346         rlim = lim;
 347         if (sz)
 348                 *sz = rlim;
 349
 350         *end = &cp[i] + lim;
 351
 352 out:
 353         assert(rlim >= 0 && rstart);
 354
 355         /* Run post-processors. */
 356
 357         switch (gly) {
 358         case (ESCAPE_FONT):
 359                 if (1 != rlim)
 360                         break;
 361                 switch (*rstart) {
 362                 case ('3'):
 363                         /* FALLTHROUGH */
 364                 case ('B'):
 365                         gly = ESCAPE_FONTBOLD;
 366                         break;
 367                 case ('2'):
 368                         /* FALLTHROUGH */
 369                 case ('I'):
 370                         gly = ESCAPE_FONTITALIC;
 371                         break;
 372                 case ('P'):
 373                         gly = ESCAPE_FONTPREV;
 374                         break;
 375                 case ('1'):
 376                         /* FALLTHROUGH */
 377                 case ('R'):
 378                         gly = ESCAPE_FONTROMAN;
 379                         break;
 380                 }
 381                 break;
 382         case (ESCAPE_SPECIAL):
 383                 if (1 != rlim)
 384                         break;
 385                 if ('c' == *rstart)
 386                         gly = ESCAPE_NOSPACE;
 387                 break;
 388         default:
 389                 break;
 390         }
 391
 392         return(gly);
 393 }
 394
 395 void *
 396 mandoc_calloc(size_t num, size_t size)
 397 {
 398         void            *ptr;
 399
 400         ptr = calloc(num, size);
 401         if (NULL == ptr) {
 402                 perror(NULL);
 403                 exit((int)MANDOCLEVEL_SYSERR);
 404         }
 405
 406         return(ptr);
 407 }
 408
 409
 410 void *
 411 mandoc_malloc(size_t size)
 412 {
 413         void            *ptr;
 414
 415         ptr = malloc(size);
 416         if (NULL == ptr) {
 417                 perror(NULL);
 418                 exit((int)MANDOCLEVEL_SYSERR);
 419         }
 420
 421         return(ptr);
 422 }
 423
 424
 425 void *
 426 mandoc_realloc(void *ptr, size_t size)
 427 {
 428
 429         ptr = realloc(ptr, size);
 430         if (NULL == ptr) {
 431                 perror(NULL);
 432                 exit((int)MANDOCLEVEL_SYSERR);
 433         }
 434
 435         return(ptr);
 436 }
 437
 438
 439 char *
 440 mandoc_strdup(const char *ptr)
 441 {
 442         char            *p;
 443
 444         p = strdup(ptr);
 445         if (NULL == p) {
 446                 perror(NULL);
 447                 exit((int)MANDOCLEVEL_SYSERR);
 448         }
 449
 450         return(p);
 451 }
 452
 453 /*
 454  * Parse a quoted or unquoted roff-style request or macro argument.
 455  * Return a pointer to the parsed argument, which is either the original
 456  * pointer or advanced by one byte in case the argument is quoted.
 457  * Null-terminate the argument in place.
 458  * Collapse pairs of quotes inside quoted arguments.
 459  * Advance the argument pointer to the next argument,
 460  * or to the null byte terminating the argument line.
 461  */
 462 char *
 463 mandoc_getarg(struct mparse *parse, char **cpp, int ln, int *pos)
 464 {
 465         char     *start, *cp;
 466         int       quoted, pairs, white;
 467
 468         /* Quoting can only start with a new word. */
 469         start = *cpp;
 470         if ('"' == *start) {
 471                 quoted = 1;
 472                 start++;
 473         } else
 474                 quoted = 0;
 475
 476         pairs = 0;
 477         white = 0;
 478         for (cp = start; '\0' != *cp; cp++) {
 479                 /* Move left after quoted quotes and escaped backslashes. */
 480                 if (pairs)
 481                         cp[-pairs] = cp[0];
 482                 if ('\\' == cp[0]) {
 483                         if ('\\' == cp[1]) {
 484                                 /* Poor man's copy mode. */
 485                                 pairs++;
 486                                 cp++;
 487                         } else if (0 == quoted && ' ' == cp[1])
 488                                 /* Skip escaped blanks. */
 489                                 cp++;
 490                 } else if (0 == quoted) {
 491                         if (' ' == cp[0]) {
 492                                 /* Unescaped blanks end unquoted args. */
 493                                 white = 1;
 494                                 break;
 495                         }
 496                 } else if ('"' == cp[0]) {
 497                         if ('"' == cp[1]) {
 498                                 /* Quoted quotes collapse. */
 499                                 pairs++;
 500                                 cp++;
 501                         } else {
 502                                 /* Unquoted quotes end quoted args. */
 503                                 quoted = 2;
 504                                 break;
 505                         }
 506                 }
 507         }
 508
 509         /* Quoted argument without a closing quote. */
 510         if (1 == quoted)
 511                 mandoc_msg(MANDOCERR_BADQUOTE, parse, ln, *pos, NULL);
 512
 513         /* Null-terminate this argument and move to the next one. */
 514         if (pairs)
 515                 cp[-pairs] = '\0';
 516         if ('\0' != *cp) {
 517                 *cp++ = '\0';
 518                 while (' ' == *cp)
 519                         cp++;
 520         }
 521         *pos += (int)(cp - start) + (quoted ? 1 : 0);
 522         *cpp = cp;
 523
 524         if ('\0' == *cp && (white || ' ' == cp[-1]))
 525                 mandoc_msg(MANDOCERR_EOLNSPACE, parse, ln, *pos, NULL);
 526
 527         return(start);
 528 }
 529
 530 static int
 531 a2time(time_t *t, const char *fmt, const char *p)
 532 {
 533         struct tm        tm;
 534         char            *pp;
 535
 536         memset(&tm, 0, sizeof(struct tm));
 537
 538         pp = strptime(p, fmt, &tm);
 539         if (NULL != pp && '\0' == *pp) {
 540                 *t = mktime(&tm);
 541                 return(1);
 542         }
 543
 544         return(0);
 545 }
 546
 547 static char *
 548 time2a(time_t t)
 549 {
 550         struct tm        tm;
 551         char            *buf, *p;
 552         size_t           ssz;
 553         int              isz;
 554
 555         localtime_r(&t, &tm);
 556
 557         /*
 558          * Reserve space:
 559          * up to 9 characters for the month (September) + blank
 560          * up to 2 characters for the day + comma + blank
 561          * 4 characters for the year and a terminating '\0'
 562          */
 563         p = buf = mandoc_malloc(10 + 4 + 4 + 1);
 564
 565         if (0 == (ssz = strftime(p, 10 + 1, "%B ", &tm)))
 566                 goto fail;
 567         p += (int)ssz;
 568
 569         if (-1 == (isz = snprintf(p, 4 + 1, "%d, ", tm.tm_mday)))
 570                 goto fail;
 571         p += isz;
 572
 573         if (0 == strftime(p, 4 + 1, "%Y", &tm))
 574                 goto fail;
 575         return(buf);
 576
 577 fail:
 578         free(buf);
 579         return(NULL);
 580 }
 581
 582 char *
 583 mandoc_normdate(struct mparse *parse, char *in, int ln, int pos)
 584 {
 585         char            *out;
 586         time_t           t;
 587
 588         if (NULL == in || '\0' == *in ||
 589             0 == strcmp(in, "$" "Mdocdate$")) {
 590                 mandoc_msg(MANDOCERR_NODATE, parse, ln, pos, NULL);
 591                 time(&t);
 592         }
 593         else if (!a2time(&t, "$" "Mdocdate: %b %d %Y $", in) &&
 594             !a2time(&t, "%b %d, %Y", in) &&
 595             !a2time(&t, "%Y-%m-%d", in)) {
 596                 mandoc_msg(MANDOCERR_BADDATE, parse, ln, pos, NULL);
 597                 t = 0;
 598         }
 599         out = t ? time2a(t) : NULL;
 600         return(out ? out : mandoc_strdup(in));
 601 }
 602
 603 int
 604 mandoc_eos(const char *p, size_t sz, int enclosed)
 605 {
 606         const char *q;
 607         int found;
 608
 609         if (0 == sz)
 610                 return(0);
 611
 612         /*
 613          * End-of-sentence recognition must include situations where
 614          * some symbols, such as `)', allow prior EOS punctuation to
 615          * propogate outward.
 616          */
 617
 618         found = 0;
 619         for (q = p + (int)sz - 1; q >= p; q--) {
 620                 switch (*q) {
 621                 case ('\"'):
 622                         /* FALLTHROUGH */
 623                 case ('\''):
 624                         /* FALLTHROUGH */
 625                 case (']'):
 626                         /* FALLTHROUGH */
 627                 case (')'):
 628                         if (0 == found)
 629                                 enclosed = 1;
 630                         break;
 631                 case ('.'):
 632                         /* FALLTHROUGH */
 633                 case ('!'):
 634                         /* FALLTHROUGH */
 635                 case ('?'):
 636                         found = 1;
 637                         break;
 638                 default:
 639                         return(found && (!enclosed || isalnum((unsigned char)*q)));
 640                 }
 641         }
 642
 643         return(found && !enclosed);
 644 }
 645
 646 int
 647 mandoc_hyph(const char *start, const char *c)
 648 {
 649
 650         /*
 651          * Choose whether to break at a hyphenated character.  We only
 652          * do this if it's free-standing within a word.
 653          */
 654
 655         /* Skip first/last character of buffer. */
 656         if (c == start || '\0' == *(c + 1))
 657                 return(0);
 658         /* Skip first/last character of word. */
 659         if ('\t' == *(c + 1) || '\t' == *(c - 1))
 660                 return(0);
 661         if (' ' == *(c + 1) || ' ' == *(c - 1))
 662                 return(0);
 663         /* Skip double invocations. */
 664         if ('-' == *(c + 1) || '-' == *(c - 1))
 665                 return(0);
 666         /* Skip escapes. */
 667         if ('\\' == *(c - 1))
 668                 return(0);
 669
 670         return(1);
 671 }
 672
 673 /*
 674  * Find out whether a line is a macro line or not.  If it is, adjust the
 675  * current position and return one; if it isn't, return zero and don't
 676  * change the current position.
 677  */
 678 int
 679 mandoc_getcontrol(const char *cp, int *ppos)
 680 {
 681         int             pos;
 682
 683         pos = *ppos;
 684
 685         if ('\\' == cp[pos] && '.' == cp[pos + 1])
 686                 pos += 2;
 687         else if ('.' == cp[pos] || '\'' == cp[pos])
 688                 pos++;
 689         else
 690                 return(0);
 691
 692         while (' ' == cp[pos] || '\t' == cp[pos])
 693                 pos++;
 694
 695         *ppos = pos;
 696         return(1);
 697 }