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

Diff for /docbook2mdoc/macro.c between version 1.6 and 1.10

version 1.6, 2019/04/06 22:37:57 version 1.10, 2019/04/12 08:48:16
Line 31  void
Line 31  void
 macro_open(struct format *f, const char *name)  macro_open(struct format *f, const char *name)
 {  {
         switch (f->linestate) {          switch (f->linestate) {
           case LINE_MACRO:
                   if (f->flags & FMT_NOSPC) {
                           fputs(" Ns ", stdout);
                           break;
                   }
                   if (f->flags & (FMT_CHILD | FMT_IMPL)) {
                           putchar(' ');
                           break;
                   }
                   /* FALLTHROUGH */
         case LINE_TEXT:          case LINE_TEXT:
                 putchar('\n');                  putchar('\n');
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case LINE_NEW:          case LINE_NEW:
                 putchar('.');                  putchar('.');
                 f->linestate = LINE_MACRO;                  f->linestate = LINE_MACRO;
                   f->flags = 0;
                 break;                  break;
         case LINE_MACRO:  
                 putchar(' ');  
                 if (f->spc == 0)  
                         fputs("Ns ", stdout);  
                 break;  
         }          }
         fputs(name, stdout);          fputs(name, stdout);
           f->flags &= FMT_IMPL;
           f->flags |= FMT_ARG;
 }  }
   
 void  void
 macro_close(struct format *f)  macro_close(struct format *f)
 {  {
         if (f->linestate == LINE_NEW)          if (f->linestate != LINE_NEW)
                 return;                  putchar('\n');
         putchar('\n');  
         f->linestate = LINE_NEW;          f->linestate = LINE_NEW;
           f->flags = 0;
 }  }
   
 void  void
 macro_line(struct format *f, const char *name)  macro_line(struct format *f, const char *name)
 {  {
           macro_close(f);
         macro_open(f, name);          macro_open(f, name);
         macro_close(f);          macro_close(f);
 }  }
   
 /*  /*
  * At the end of a macro, decide whether the line needs to remain open  
  * because the next node follows without intervening whitespace;  
  * otherwise, close the line.  
  */  
 void  
 macro_closepunct(struct format *f, struct pnode *pn)  
 {  
         char            *cp;  
   
         if ((pn = TAILQ_NEXT(pn, child)) != NULL && pn->spc == 0) {  
   
                 /*  
                  * If a non-text node follows without intervening  
                  * whitespace, the handler of that node will decide  
                  * whether and how to suppress whitespace.  To allow  
                  * that, the macro line needs to remain open.  
                  */  
   
                 if (pn->node != NODE_TEXT && pn->node != NODE_ESCAPE)  
                         return;  
   
                 /*  
                  * Give closing punctuation  
                  * in the form of trailing macro arguments.  
                  */  
   
                 while (*pn->b != '\0' &&  
                     strchr("!),.:;?]", *pn->b) != NULL) {  
                         putchar(' ');  
                         putchar(*pn->b);  
                         pn->b++;  
                         pn->bsz--;  
                 }  
   
                 /*  
                  * Text follows without intervening whitespace.  
                  * Append the first word with .Ns.  
                  */  
   
                 if (*pn->b != '\0' && isspace((unsigned char)*pn->b) == 0) {  
                         fputs(" Ns", stdout);  
                         for (cp = pn->b; *cp != '\0'; cp++)  
                                 if (isspace((unsigned char)*cp))  
                                         break;  
                         *cp = '\0';  
                         macro_addarg(f, pn->b, ARG_SPACE);  
                         pn->bsz -= cp - pn->b;  
                         pn->b = cp;  
                         if (pn->bsz > 0) {  
                                 pn->b++;  
                                 pn->bsz--;  
                                 pn->spc = 1;  
                         }  
                 }  
   
                 /* Skip whitespace after the first word. */  
   
                 while (isspace((unsigned char)*pn->b)) {  
                         pn->b++;  
                         pn->bsz--;  
                         pn->spc = 1;  
                 }  
         }  
         macro_close(f);  
 }  
   
 /*  
  * Print an argument string on a macro line, collapsing whitespace.   * Print an argument string on a macro line, collapsing whitespace.
  */   */
 void  void
Line 202  macro_argline(struct format *f, const char *name, cons
Line 144  macro_argline(struct format *f, const char *name, cons
  * Recursively append text from the children of a node to a macro line.   * Recursively append text from the children of a node to a macro line.
  */   */
 void  void
 macro_addnode(struct format *f, struct pnode *pn, int flags)  macro_addnode(struct format *f, struct pnode *n, int flags)
 {  {
         struct pnode    *nc;          struct pnode    *nc;
         int              quote_now;          int              quote_now;
Line 214  macro_addnode(struct format *f, struct pnode *pn, int 
Line 156  macro_addnode(struct format *f, struct pnode *pn, int 
          * that text, letting macro_addarg() decide about quoting.           * that text, letting macro_addarg() decide about quoting.
          */           */
   
         while ((nc = TAILQ_FIRST(&pn->childq)) != NULL &&          while ((nc = TAILQ_FIRST(&n->childq)) != NULL &&
             TAILQ_NEXT(nc, child) == NULL)              TAILQ_NEXT(nc, child) == NULL)
                 pn = nc;                  n = nc;
   
         if (pn->node == NODE_TEXT || pn->node == NODE_ESCAPE) {          if (n->node == NODE_TEXT || n->node == NODE_ESCAPE) {
                 macro_addarg(f, pn->b, flags);                  macro_addarg(f, n->b, flags);
                 return;                  return;
         }          }
   
Line 257  macro_addnode(struct format *f, struct pnode *pn, int 
Line 199  macro_addnode(struct format *f, struct pnode *pn, int 
 }  }
   
 void  void
 macro_nodeline(struct format *f, const char *name, struct pnode *pn, int flags)  macro_nodeline(struct format *f, const char *name, struct pnode *n, int flags)
 {  {
         macro_open(f, name);          macro_open(f, name);
         macro_addnode(f, pn, ARG_SPACE | flags);          macro_addnode(f, n, ARG_SPACE | flags);
         macro_close(f);          macro_close(f);
 }  }
   
Line 270  macro_nodeline(struct format *f, const char *name, str
Line 212  macro_nodeline(struct format *f, const char *name, str
  * line otherwise.  The flag ARG_SPACE inserts spaces between words.   * line otherwise.  The flag ARG_SPACE inserts spaces between words.
  */   */
 void  void
 print_text(struct format *f, const char *word, int flags) {  print_text(struct format *f, const char *word, int flags)
   {
         switch (f->linestate) {          switch (f->linestate) {
         case LINE_NEW:          case LINE_NEW:
                   if (*word == '.' || *word == '\'')
                           fputs("\\&", stdout);
                 break;                  break;
         case LINE_TEXT:          case LINE_TEXT:
                 if (flags & ARG_SPACE)                  if (flags & ARG_SPACE)
Line 282  print_text(struct format *f, const char *word, int fla
Line 227  print_text(struct format *f, const char *word, int fla
                 macro_close(f);                  macro_close(f);
                 break;                  break;
         }          }
         fputs(word, stdout);          while (*word != '\0') {
                   putchar(*word);
                   if (*word++ == '\\')
                           putchar('e');
           }
         f->linestate = LINE_TEXT;          f->linestate = LINE_TEXT;
           f->flags = 0;
 }  }
   
 /*  /*
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.10
CVSweb