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

Diff for /mandoc/eqn_term.c between version 1.1 and 1.13

version 1.1, 2011/07/22 10:50:46 version 1.13, 2017/07/08 14:51:04
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
    * Copyright (c) 2014, 2015, 2017 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 14 
Line 15 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
 #ifdef HAVE_CONFIG_H  
 #include "config.h"  #include "config.h"
 #endif  
   
   #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 27 
Line 28 
 #include "out.h"  #include "out.h"
 #include "term.h"  #include "term.h"
   
 static void     eqn_box(struct termp *p, const struct eqn_box *);  static  const enum termfont fontmap[EQNFONT__MAX] = {
 static void     eqn_box_post(struct termp *p, const struct eqn_box *);          TERMFONT_NONE, /* EQNFONT_NONE */
 static void     eqn_box_pre(struct termp *p, const struct eqn_box *);          TERMFONT_NONE, /* EQNFONT_ROMAN */
 static void     eqn_text(struct termp *p, const struct eqn_box *);          TERMFONT_BOLD, /* EQNFONT_BOLD */
           TERMFONT_BOLD, /* EQNFONT_FAT */
           TERMFONT_UNDER /* EQNFONT_ITALIC */
   };
   
   static void     eqn_box(struct termp *, const struct eqn_box *);
   
   
 void  void
 term_eqn(struct termp *p, const struct eqn *ep)  term_eqn(struct termp *p, const struct eqn_box *bp)
 {  {
   
         p->flags |= TERMP_NONOSPACE;          eqn_box(p, bp);
         eqn_box(p, ep->root);          p->flags &= ~TERMP_NOSPACE;
         p->flags &= ~TERMP_NONOSPACE;  
 }  }
   
 static void  static void
 eqn_box(struct termp *p, const struct eqn_box *bp)  eqn_box(struct termp *p, const struct eqn_box *bp)
 {  {
           const struct eqn_box *child;
           int delim;
   
         eqn_box_pre(p, bp);          /* Delimiters around this box? */
         eqn_text(p, bp);  
   
         if (bp->first)          if ((bp->type == EQN_LIST && bp->expectargs > 1) ||
                 eqn_box(p, bp->first);              (bp->type == EQN_PILE && (bp->prev || bp->next)) ||
               (bp->parent != NULL && (bp->parent->pos == EQNPOS_SQRT ||
               /* Diacritic followed by ^ or _. */
               ((bp->top != NULL || bp->bottom != NULL) &&
                bp->parent->type == EQN_SUBEXPR &&
                bp->parent->pos != EQNPOS_OVER && bp->next != NULL) ||
               /* Nested over, sub, sup, from, to. */
               (bp->type == EQN_SUBEXPR && bp->pos != EQNPOS_SQRT &&
                ((bp->parent->type == EQN_LIST && bp->expectargs == 1) ||
                 (bp->parent->type == EQN_SUBEXPR &&
                  bp->pos != EQNPOS_SQRT)))))) {
                   if (bp->parent->type == EQN_SUBEXPR && bp->prev != NULL)
                           p->flags |= TERMP_NOSPACE;
                   term_word(p, bp->left != NULL ? bp->left : "(");
                   p->flags |= TERMP_NOSPACE;
                   delim = 1;
           } else
                   delim = 0;
   
         eqn_box_post(p, bp);          /* Handle Fonts and text. */
   
         if (bp->next)          if (bp->font != EQNFONT_NONE)
                 eqn_box(p, bp->next);                  term_fontpush(p, fontmap[(int)bp->font]);
 }  
   
 static void          if (bp->text != NULL)
 eqn_box_pre(struct termp *p, const struct eqn_box *bp)                  term_word(p, bp->text);
 {  
   
         if (EQN_LIST == bp->type)          /* Special box types. */
                 term_word(p, "{");  
         if (bp->left)  
                 term_word(p, bp->left);  
 }  
   
 static void          if (bp->pos == EQNPOS_SQRT) {
 eqn_box_post(struct termp *p, const struct eqn_box *bp)                  term_word(p, "sqrt");
 {                  if (bp->first != NULL) {
                           p->flags |= TERMP_NOSPACE;
                           eqn_box(p, bp->first);
                   }
           } else if (bp->type == EQN_SUBEXPR) {
                   child = bp->first;
                   eqn_box(p, child);
                   p->flags |= TERMP_NOSPACE;
                   term_word(p, bp->pos == EQNPOS_OVER ? "/" :
                       (bp->pos == EQNPOS_SUP ||
                        bp->pos == EQNPOS_TO) ? "^" : "_");
                   p->flags |= TERMP_NOSPACE;
                   child = child->next;
                   if (child != NULL) {
                           eqn_box(p, child);
                           if (bp->pos == EQNPOS_FROMTO ||
                               bp->pos == EQNPOS_SUBSUP) {
                                   p->flags |= TERMP_NOSPACE;
                                   term_word(p, "^");
                                   p->flags |= TERMP_NOSPACE;
                                   child = child->next;
                                   if (child != NULL)
                                           eqn_box(p, child);
                           }
                   }
           } else {
                   child = bp->first;
                   if (bp->type == EQN_MATRIX &&
                       child != NULL &&
                       child->type == EQN_LIST &&
                       child->expectargs > 1)
                           child = child->first;
                   while (child != NULL) {
                           eqn_box(p,
                               bp->type == EQN_PILE &&
                               child->type == EQN_LIST &&
                               child->expectargs > 1 &&
                               child->args == 1 ?
                               child->first : child);
                           child = child->next;
                   }
           }
   
         if (EQN_LIST == bp->type)          /* Handle Fonts and diacritics. */
                 term_word(p, "}");  
         if (bp->right)  
                 term_word(p, bp->right);  
         if (bp->above)  
                 term_word(p, "|");  
 }  
   
 static void          if (bp->font != EQNFONT_NONE)
 eqn_text(struct termp *p, const struct eqn_box *bp)                  term_fontpop(p);
 {          if (bp->top != NULL) {
                   p->flags |= TERMP_NOSPACE;
                   term_word(p, bp->top);
           }
           if (bp->bottom != NULL) {
                   p->flags |= TERMP_NOSPACE;
                   term_word(p, "_");
           }
   
         if (bp->text)          /* Right delimiter after this box? */
                 term_word(p, bp->text);  
           if (delim) {
                   p->flags |= TERMP_NOSPACE;
                   term_word(p, bp->right != NULL ? bp->right : ")");
                   if (bp->parent->type == EQN_SUBEXPR && bp->next != NULL)
                           p->flags |= TERMP_NOSPACE;
           }
 }  }

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.13

CVSweb