[BACK]Return to main.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.128 and 1.147

version 1.128, 2011/01/01 13:37:40 version 1.147, 2011/03/07 01:35:51
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 128  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 128  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "no title in document",          "no title in document",
         "document title should be all caps",          "document title should be all caps",
         "unknown manual section",          "unknown manual section",
         "cannot parse date argument",          "date missing, using today's date",
           "cannot parse date, using it verbatim",
         "prologue macros out of order",          "prologue macros out of order",
         "duplicate prologue macro",          "duplicate prologue macro",
         "macro not allowed in prologue",          "macro not allowed in prologue",
Line 146  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 147  static const char * const mandocerrs[MANDOCERR_MAX] = 
         /* related to macros and nesting */          /* related to macros and nesting */
         "skipping obsolete macro",          "skipping obsolete macro",
         "skipping paragraph macro",          "skipping paragraph macro",
           "skipping no-space macro",
         "blocks badly nested",          "blocks badly nested",
         "child violates parent syntax",          "child violates parent syntax",
         "nested displays are not portable",          "nested displays are not portable",
Line 153  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 155  static const char * const mandocerrs[MANDOCERR_MAX] = 
   
         /* related to missing macro arguments */          /* related to missing macro arguments */
         "skipping empty macro",          "skipping empty macro",
           "argument count wrong",
         "missing display type",          "missing display type",
         "list type must come first",          "list type must come first",
         "tag lists require a width argument",          "tag lists require a width argument",
         "missing font type",          "missing font type",
           "skipping end of block that is not open",
   
         /* related to bad macro arguments */          /* related to bad macro arguments */
         "skipping argument",          "skipping argument",
Line 176  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 180  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "bad comment style",          "bad comment style",
         "unknown escape sequence",          "unknown escape sequence",
         "unterminated quoted string",          "unterminated quoted string",
   
         "generic error",          "generic error",
   
           /* related to tables */
         "bad table syntax",          "bad table syntax",
         "bad table option",          "bad table option",
         "bad table layout",          "bad table layout",
         "no table layout cells specified",          "no table layout cells specified",
           "no table data cells specified",
           "ignore data in cell",
           "data block still open",
           "ignoring extra data cells",
   
         "input stack limit exceeded, infinite loop?",          "input stack limit exceeded, infinite loop?",
         "skipping bad character",          "skipping bad character",
           "escaped character not allowed in a name",
         "skipping text before the first section header",          "skipping text before the first section header",
         "skipping unknown macro",          "skipping unknown macro",
         "NOT IMPLEMENTED: skipping request",          "NOT IMPLEMENTED, please use groff: skipping request",
         "line scope broken",          "line scope broken",
         "argument count wrong",          "argument count wrong",
         "skipping end of block that is not open",          "skipping end of block that is not open",
Line 526  fdesc(struct curparse *curp)
Line 537  fdesc(struct curparse *curp)
         }          }
   
         assert(curp->roff);          assert(curp->roff);
         if ( ! roff_endparse(curp->roff)) {          roff_endparse(curp->roff);
                 assert(MANDOCLEVEL_FATAL <= file_status);  
                 goto cleanup;  
         }  
   
         /*          /*
          * With -Wstop and warnings or errors of at least           * With -Wstop and warnings or errors of at least
Line 650  pdesc(struct curparse *curp)
Line 658  pdesc(struct curparse *curp)
 static void  static void
 parsebuf(struct curparse *curp, struct buf blk, int start)  parsebuf(struct curparse *curp, struct buf blk, int start)
 {  {
           const struct tbl_span   *span;
         struct buf       ln;          struct buf       ln;
         enum rofferr     rr;          enum rofferr     rr;
         int              i, of, rc;          int              i, of, rc;
Line 678  parsebuf(struct curparse *curp, struct buf blk, int st
Line 687  parsebuf(struct curparse *curp, struct buf blk, int st
                 }                  }
   
                 while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {                  while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {
   
                           /*
                            * When finding an unescaped newline character,
                            * leave the character loop to process the line.
                            * Skip a preceding carriage return, if any.
                            */
   
                           if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz &&
                               '\n' == blk.buf[i + 1])
                                   ++i;
                         if ('\n' == blk.buf[i]) {                          if ('\n' == blk.buf[i]) {
                                 ++i;                                  ++i;
                                 ++lnn;                                  ++lnn;
Line 712  parsebuf(struct curparse *curp, struct buf blk, int st
Line 731  parsebuf(struct curparse *curp, struct buf blk, int st
                                 continue;                                  continue;
                         }                          }
   
                         /* Found escape & at least one other char. */                          /*
                            * Found escape and at least one other character.
                            * When it's a newline character, skip it.
                            * When there is a carriage return in between,
                            * skip that one as well.
                            */
   
                           if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&
                               '\n' == blk.buf[i + 2])
                                   ++i;
                         if ('\n' == blk.buf[i + 1]) {                          if ('\n' == blk.buf[i + 1]) {
                                 i += 2;                                  i += 2;
                                 /* Escaped newlines are skipped over */  
                                 ++lnn;                                  ++lnn;
                                 continue;                                  continue;
                         }                          }
Line 803  rerun:
Line 829  rerun:
                 }                  }
   
                 /*                  /*
                    * If we encounter errors in the recursive parsebuf()
                    * call, make sure we don't continue parsing.
                    */
   
                   if (MANDOCLEVEL_FATAL <= file_status)
                           break;
   
                   /*
                  * If input parsers have not been allocated, do so now.                   * If input parsers have not been allocated, do so now.
                  * We keep these instanced betwen parsers, but set them                   * We keep these instanced betwen parsers, but set them
                  * locally per parse routine since we can use different                   * locally per parse routine since we can use different
Line 820  rerun:
Line 854  rerun:
                  * currently open parse.  Since we only get here if                   * currently open parse.  Since we only get here if
                  * there does exist data (see tbl_data.c), we're                   * there does exist data (see tbl_data.c), we're
                  * guaranteed that something's been allocated.                   * guaranteed that something's been allocated.
                    * Do the same for ROFF_EQN.
                  */                   */
   
                 if (ROFF_TBL == rr) {                  rc = -1;
                         assert(curp->man || curp->mdoc);  
                         if (curp->man)  
                                 man_addspan(curp->man, roff_span(curp->roff));  
                         else  
                                 mdoc_addspan(curp->mdoc, roff_span(curp->roff));  
   
                 } else if (curp->man || curp->mdoc) {                  if (ROFF_TBL == rr)
                           while (NULL != (span = roff_span(curp->roff))) {
                                   rc = curp->man ?
                                           man_addspan(curp->man, span) :
                                           mdoc_addspan(curp->mdoc, span);
                                   if (0 == rc)
                                           break;
                           }
                   else if (ROFF_EQN == rr)
                           rc = curp->mdoc ?
                                   mdoc_addeqn(curp->mdoc,
                                           roff_eqn(curp->roff)) :
                                   man_addeqn(curp->man,
                                           roff_eqn(curp->roff));
                   else if (curp->man || curp->mdoc)
                         rc = curp->man ?                          rc = curp->man ?
                                 man_parseln(curp->man,                                  man_parseln(curp->man,
                                         curp->line, ln.buf, of) :                                          curp->line, ln.buf, of) :
                                 mdoc_parseln(curp->mdoc,                                  mdoc_parseln(curp->mdoc,
                                         curp->line, ln.buf, of);                                          curp->line, ln.buf, of);
   
                         if ( ! rc) {                  if (0 == rc) {
                                 assert(MANDOCLEVEL_FATAL <= file_status);                          assert(MANDOCLEVEL_FATAL <= file_status);
                                 break;                          break;
                         }  
                 }                  }
   
                 /* Temporary buffers typically are not full. */                  /* Temporary buffers typically are not full. */
Legend:
Removed from v.1.128  
changed lines
  Added in v.1.147
CVSweb