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

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

version 1.138, 2011/01/12 15:50:42 version 1.147, 2011/03/07 01:35:51
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010, 2011 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 196  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 198  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "escaped character not allowed in a name",          "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 656  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 684  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 718  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 834  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.138  
changed lines
  Added in v.1.147
CVSweb