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

Diff for /mandoc/mdoc_macro.c between version 1.183 and 1.185

version 1.183, 2015/02/12 12:24:33 version 1.185, 2015/04/02 22:48:17
Line 7 
Line 7 
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.   * copyright notice and this permission notice appear in all copies.
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Line 26 
Line 26 
 #include <string.h>  #include <string.h>
 #include <time.h>  #include <time.h>
   
 #include "mdoc.h"  
 #include "mandoc.h"  #include "mandoc.h"
 #include "libmdoc.h"  #include "roff.h"
   #include "mdoc.h"
 #include "libmandoc.h"  #include "libmandoc.h"
   #include "libmdoc.h"
   
 static  void            blk_full(MACRO_PROT_ARGS);  static  void            blk_full(MACRO_PROT_ARGS);
 static  void            blk_exp_close(MACRO_PROT_ARGS);  static  void            blk_exp_close(MACRO_PROT_ARGS);
Line 44  static void  phrase_ta(MACRO_PROT_ARGS);
Line 45  static void  phrase_ta(MACRO_PROT_ARGS);
 static  void            dword(struct mdoc *, int, int, const char *,  static  void            dword(struct mdoc *, int, int, const char *,
                                  enum mdelim, int);                                   enum mdelim, int);
 static  void            append_delims(struct mdoc *, int, int *, char *);  static  void            append_delims(struct mdoc *, int, int *, char *);
 static  enum mdoct      lookup(struct mdoc *, enum mdoct,  static  int             lookup(struct mdoc *, int, int, int, const char *);
                                 int, int, const char *);  
 static  int             macro_or_word(MACRO_PROT_ARGS, int);  static  int             macro_or_word(MACRO_PROT_ARGS, int);
 static  int             parse_rest(struct mdoc *, enum mdoct,  static  int             parse_rest(struct mdoc *, int, int, int *, char *);
                                 int, int *, char *);  static  int             rew_alt(int);
 static  enum mdoct      rew_alt(enum mdoct);  static  void            rew_elem(struct mdoc *, int);
 static  void            rew_elem(struct mdoc *, enum mdoct);  static  void            rew_last(struct mdoc *, const struct roff_node *);
 static  void            rew_last(struct mdoc *, const struct mdoc_node *);  static  void            rew_pending(struct mdoc *, const struct roff_node *);
 static  void            rew_pending(struct mdoc *, const struct mdoc_node *);  
   
 const   struct mdoc_macro __mdoc_macros[MDOC_MAX] = {  const   struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
         { in_line_argn, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ap */          { in_line_argn, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ap */
Line 209  const struct mdoc_macro * const mdoc_macros = __mdoc_m
Line 208  const struct mdoc_macro * const mdoc_macros = __mdoc_m
 void  void
 mdoc_macroend(struct mdoc *mdoc)  mdoc_macroend(struct mdoc *mdoc)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
   
         /* Scan for open explicit scopes. */          /* Scan for open explicit scopes. */
   
Line 217  mdoc_macroend(struct mdoc *mdoc)
Line 216  mdoc_macroend(struct mdoc *mdoc)
             mdoc->last->parent : mdoc->last;              mdoc->last->parent : mdoc->last;
   
         for ( ; n; n = n->parent)          for ( ; n; n = n->parent)
                 if (n->type == MDOC_BLOCK &&                  if (n->type == ROFFT_BLOCK &&
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT)                      mdoc_macros[n->tok].flags & MDOC_EXPLICIT)
                         mandoc_msg(MANDOCERR_BLK_NOEND, mdoc->parse,                          mandoc_msg(MANDOCERR_BLK_NOEND, mdoc->parse,
                             n->line, n->pos, mdoc_macronames[n->tok]);                              n->line, n->pos, mdoc_macronames[n->tok]);
Line 231  mdoc_macroend(struct mdoc *mdoc)
Line 230  mdoc_macroend(struct mdoc *mdoc)
  * Look up the macro at *p called by "from",   * Look up the macro at *p called by "from",
  * or as a line macro if from == MDOC_MAX.   * or as a line macro if from == MDOC_MAX.
  */   */
 static enum mdoct  static int
 lookup(struct mdoc *mdoc, enum mdoct from, int line, int ppos, const char *p)  lookup(struct mdoc *mdoc, int from, int line, int ppos, const char *p)
 {  {
         enum mdoct       res;          int      res;
   
         if (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {          if (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {
                 res = mdoc_hash_find(p);                  res = mdoc_hash_find(p);
Line 253  lookup(struct mdoc *mdoc, enum mdoct from, int line, i
Line 252  lookup(struct mdoc *mdoc, enum mdoct from, int line, i
  * Rewind up to and including a specific node.   * Rewind up to and including a specific node.
  */   */
 static void  static void
 rew_last(struct mdoc *mdoc, const struct mdoc_node *to)  rew_last(struct mdoc *mdoc, const struct roff_node *to)
 {  {
         struct mdoc_node *n, *np;          struct roff_node *n, *np;
   
         assert(to);          assert(to);
         mdoc->next = MDOC_NEXT_SIBLING;          mdoc->next = MDOC_NEXT_SIBLING;
Line 280  rew_last(struct mdoc *mdoc, const struct mdoc_node *to
Line 279  rew_last(struct mdoc *mdoc, const struct mdoc_node *to
  * Rewind up to a specific block, including all blocks that broke it.   * Rewind up to a specific block, including all blocks that broke it.
  */   */
 static void  static void
 rew_pending(struct mdoc *mdoc, const struct mdoc_node *n)  rew_pending(struct mdoc *mdoc, const struct roff_node *n)
 {  {
   
         for (;;) {          for (;;) {
                 rew_last(mdoc, n);                  rew_last(mdoc, n);
   
                 switch (n->type) {                  switch (n->type) {
                 case MDOC_HEAD:                  case ROFFT_HEAD:
                         mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);                          mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);
                         return;                          return;
                 case MDOC_BLOCK:                  case ROFFT_BLOCK:
                         break;                          break;
                 default:                  default:
                         return;                          return;
Line 303  rew_pending(struct mdoc *mdoc, const struct mdoc_node 
Line 302  rew_pending(struct mdoc *mdoc, const struct mdoc_node 
                         if ((n = n->parent) == NULL)                          if ((n = n->parent) == NULL)
                                 return;                                  return;
   
                         if (n->type == MDOC_BLOCK ||                          if (n->type == ROFFT_BLOCK ||
                             n->type == MDOC_HEAD) {                              n->type == ROFFT_HEAD) {
                                 if (n->flags & MDOC_ENDED)                                  if (n->flags & MDOC_ENDED)
                                         break;                                          break;
                                 else                                  else
Line 318  rew_pending(struct mdoc *mdoc, const struct mdoc_node 
Line 317  rew_pending(struct mdoc *mdoc, const struct mdoc_node 
  * For a block closing macro, return the corresponding opening one.   * For a block closing macro, return the corresponding opening one.
  * Otherwise, return the macro itself.   * Otherwise, return the macro itself.
  */   */
 static enum mdoct  static int
 rew_alt(enum mdoct tok)  rew_alt(int tok)
 {  {
         switch (tok) {          switch (tok) {
         case MDOC_Ac:          case MDOC_Ac:
Line 361  rew_alt(enum mdoct tok)
Line 360  rew_alt(enum mdoct tok)
 }  }
   
 static void  static void
 rew_elem(struct mdoc *mdoc, enum mdoct tok)  rew_elem(struct mdoc *mdoc, int tok)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
   
         n = mdoc->last;          n = mdoc->last;
         if (MDOC_ELEM != n->type)          if (n->type != ROFFT_ELEM)
                 n = n->parent;                  n = n->parent;
         assert(MDOC_ELEM == n->type);          assert(n->type == ROFFT_ELEM);
         assert(tok == n->tok);          assert(tok == n->tok);
         rew_last(mdoc, n);          rew_last(mdoc, n);
 }  }
Line 387  dword(struct mdoc *mdoc, int line, int col, const char
Line 386  dword(struct mdoc *mdoc, int line, int col, const char
   
         if (may_append &&          if (may_append &&
             ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&              ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&
             d == DELIM_NONE && mdoc->last->type == MDOC_TEXT &&              d == DELIM_NONE && mdoc->last->type == ROFFT_TEXT &&
             mdoc_isdelim(mdoc->last->string) == DELIM_NONE) {              mdoc_isdelim(mdoc->last->string) == DELIM_NONE) {
                 mdoc_word_append(mdoc, p);                  mdoc_word_append(mdoc, p);
                 return;                  return;
Line 452  static int
Line 451  static int
 macro_or_word(MACRO_PROT_ARGS, int parsed)  macro_or_word(MACRO_PROT_ARGS, int parsed)
 {  {
         char            *p;          char            *p;
         enum mdoct       ntok;          int              ntok;
   
         p = buf + ppos;          p = buf + ppos;
         ntok = MDOC_MAX;          ntok = MDOC_MAX;
Line 481  macro_or_word(MACRO_PROT_ARGS, int parsed)
Line 480  macro_or_word(MACRO_PROT_ARGS, int parsed)
 static void  static void
 blk_exp_close(MACRO_PROT_ARGS)  blk_exp_close(MACRO_PROT_ARGS)
 {  {
         struct mdoc_node *body;         /* Our own body. */          struct roff_node *body;         /* Our own body. */
         struct mdoc_node *endbody;      /* Our own end marker. */          struct roff_node *endbody;      /* Our own end marker. */
         struct mdoc_node *itblk;        /* An It block starting later. */          struct roff_node *itblk;        /* An It block starting later. */
         struct mdoc_node *later;        /* A sub-block starting later. */          struct roff_node *later;        /* A sub-block starting later. */
         struct mdoc_node *n;            /* Search back to our block. */          struct roff_node *n;            /* Search back to our block. */
   
         int              j, lastarg, maxargs, nl;          int              j, lastarg, maxargs, nl;
         enum margserr    ac;          enum margserr    ac;
         enum mdoct       atok, ntok;          int              atok, ntok;
         char            *p;          char            *p;
   
         nl = MDOC_NEWLINE & mdoc->flags;          nl = MDOC_NEWLINE & mdoc->flags;
Line 522  blk_exp_close(MACRO_PROT_ARGS)
Line 521  blk_exp_close(MACRO_PROT_ARGS)
   
                 /* Remember the start of our own body. */                  /* Remember the start of our own body. */
   
                 if (n->type == MDOC_BODY && atok == n->tok) {                  if (n->type == ROFFT_BODY && atok == n->tok) {
                         if (n->end == ENDBODY_NOT)                          if (n->end == ENDBODY_NOT)
                                 body = n;                                  body = n;
                         continue;                          continue;
                 }                  }
   
                 if (n->type != MDOC_BLOCK || n->tok == MDOC_Nm)                  if (n->type != ROFFT_BLOCK || n->tok == MDOC_Nm)
                         continue;                          continue;
   
                 if (n->tok == MDOC_It) {                  if (n->tok == MDOC_It) {
Line 663  static void
Line 662  static void
 in_line(MACRO_PROT_ARGS)  in_line(MACRO_PROT_ARGS)
 {  {
         int              la, scope, cnt, firstarg, mayopen, nc, nl;          int              la, scope, cnt, firstarg, mayopen, nc, nl;
         enum mdoct       ntok;          int              ntok;
         enum margserr    ac;          enum margserr    ac;
         enum mdelim      d;          enum mdelim      d;
         struct mdoc_arg *arg;          struct mdoc_arg *arg;
Line 847  blk_full(MACRO_PROT_ARGS)
Line 846  blk_full(MACRO_PROT_ARGS)
 {  {
         int               la, nl, parsed;          int               la, nl, parsed;
         struct mdoc_arg  *arg;          struct mdoc_arg  *arg;
         struct mdoc_node *blk; /* Our own or a broken block. */          struct roff_node *blk; /* Our own or a broken block. */
         struct mdoc_node *head; /* Our own head. */          struct roff_node *head; /* Our own head. */
         struct mdoc_node *body; /* Our own body. */          struct roff_node *body; /* Our own body. */
         struct mdoc_node *n;          struct roff_node *n;
         enum margserr     ac, lac;          enum margserr     ac, lac;
         char             *p;          char             *p;
   
Line 873  blk_full(MACRO_PROT_ARGS)
Line 872  blk_full(MACRO_PROT_ARGS)
                                         n->flags |= MDOC_BROKEN;                                          n->flags |= MDOC_BROKEN;
                                 continue;                                  continue;
                         }                          }
                         if (n->type != MDOC_BLOCK)                          if (n->type != ROFFT_BLOCK)
                                 continue;                                  continue;
   
                         if (tok == MDOC_It && n->tok == MDOC_Bl) {                          if (tok == MDOC_It && n->tok == MDOC_Bl) {
Line 1016  blk_full(MACRO_PROT_ARGS)
Line 1015  blk_full(MACRO_PROT_ARGS)
   
                 /*                  /*
                  * Emit leading punctuation (i.e., punctuation before                   * Emit leading punctuation (i.e., punctuation before
                  * the MDOC_HEAD) for non-phrase types.                   * the ROFFT_HEAD) for non-phrase types.
                  */                   */
   
                 if (head == NULL &&                  if (head == NULL &&
Line 1086  blk_full(MACRO_PROT_ARGS)
Line 1085  blk_full(MACRO_PROT_ARGS)
                                 n->flags |= MDOC_BROKEN;                                  n->flags |= MDOC_BROKEN;
                         continue;                          continue;
                 }                  }
                 if (n->type == MDOC_BLOCK &&                  if (n->type == ROFFT_BLOCK &&
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {                      mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
                         n->flags = MDOC_BROKEN;                          n->flags = MDOC_BROKEN;
                         head->flags = MDOC_ENDED;                          head->flags = MDOC_ENDED;
Line 1113  blk_part_imp(MACRO_PROT_ARGS)
Line 1112  blk_part_imp(MACRO_PROT_ARGS)
         int               la, nl;          int               la, nl;
         enum margserr     ac;          enum margserr     ac;
         char             *p;          char             *p;
         struct mdoc_node *blk; /* saved block context */          struct roff_node *blk; /* saved block context */
         struct mdoc_node *body; /* saved body context */          struct roff_node *body; /* saved body context */
         struct mdoc_node *n;          struct roff_node *n;
   
         nl = MDOC_NEWLINE & mdoc->flags;          nl = MDOC_NEWLINE & mdoc->flags;
   
Line 1171  blk_part_imp(MACRO_PROT_ARGS)
Line 1170  blk_part_imp(MACRO_PROT_ARGS)
                                 n->flags |= MDOC_BROKEN;                                  n->flags |= MDOC_BROKEN;
                         continue;                          continue;
                 }                  }
                 if (n->type == MDOC_BLOCK &&                  if (n->type == ROFFT_BLOCK &&
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {                      mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
                         n->flags |= MDOC_BROKEN;                          n->flags |= MDOC_BROKEN;
                         if ( ! (body->flags & MDOC_ENDED)) {                          if ( ! (body->flags & MDOC_ENDED)) {
Line 1206  blk_part_exp(MACRO_PROT_ARGS)
Line 1205  blk_part_exp(MACRO_PROT_ARGS)
 {  {
         int               la, nl;          int               la, nl;
         enum margserr     ac;          enum margserr     ac;
         struct mdoc_node *head; /* keep track of head */          struct roff_node *head; /* keep track of head */
         char             *p;          char             *p;
   
         nl = MDOC_NEWLINE & mdoc->flags;          nl = MDOC_NEWLINE & mdoc->flags;
Line 1263  in_line_argn(MACRO_PROT_ARGS)
Line 1262  in_line_argn(MACRO_PROT_ARGS)
         struct mdoc_arg *arg;          struct mdoc_arg *arg;
         char            *p;          char            *p;
         enum margserr    ac;          enum margserr    ac;
         enum mdoct       ntok;          int              ntok;
         int              state; /* arg#; -1: not yet open; -2: closed */          int              state; /* arg#; -1: not yet open; -2: closed */
         int              la, maxargs, nl;          int              la, maxargs, nl;
   
Line 1377  in_line_argn(MACRO_PROT_ARGS)
Line 1376  in_line_argn(MACRO_PROT_ARGS)
 static void  static void
 in_line_eoln(MACRO_PROT_ARGS)  in_line_eoln(MACRO_PROT_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
         struct mdoc_arg         *arg;          struct mdoc_arg         *arg;
   
         if ((tok == MDOC_Pp || tok == MDOC_Lp) &&          if ((tok == MDOC_Pp || tok == MDOC_Lp) &&
Line 1409  in_line_eoln(MACRO_PROT_ARGS)
Line 1408  in_line_eoln(MACRO_PROT_ARGS)
  * or until the next macro, call that macro, and return 1.   * or until the next macro, call that macro, and return 1.
  */   */
 static int  static int
 parse_rest(struct mdoc *mdoc, enum mdoct tok, int line, int *pos, char *buf)  parse_rest(struct mdoc *mdoc, int tok, int line, int *pos, char *buf)
 {  {
         int              la;          int              la;
   
Line 1444  ctx_synopsis(MACRO_PROT_ARGS)
Line 1443  ctx_synopsis(MACRO_PROT_ARGS)
 static void  static void
 phrase_ta(MACRO_PROT_ARGS)  phrase_ta(MACRO_PROT_ARGS)
 {  {
         struct mdoc_node *body, *n;          struct roff_node *body, *n;
   
         /* Make sure we are in a column list or ignore this macro. */          /* Make sure we are in a column list or ignore this macro. */
   
Line 1452  phrase_ta(MACRO_PROT_ARGS)
Line 1451  phrase_ta(MACRO_PROT_ARGS)
         for (n = mdoc->last; n != NULL; n = n->parent) {          for (n = mdoc->last; n != NULL; n = n->parent) {
                 if (n->flags & MDOC_ENDED)                  if (n->flags & MDOC_ENDED)
                         continue;                          continue;
                 if (n->tok == MDOC_It && n->type == MDOC_BODY)                  if (n->tok == MDOC_It && n->type == ROFFT_BODY)
                         body = n;                          body = n;
                 if (n->tok == MDOC_Bl)                  if (n->tok == MDOC_Bl)
                         break;                          break;
Legend:
Removed from v.1.183  
changed lines
  Added in v.1.185
CVSweb