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

Diff for /mandoc/eqn.c between version 1.63 and 1.69

version 1.63, 2017/06/20 17:24:35 version 1.69, 2017/06/23 21:04:57
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$
 /*  /*
  * Copyright (c) 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>   * 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 20 
Line 20 
 #include <sys/types.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
   #include <ctype.h>
 #include <limits.h>  #include <limits.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 80  enum eqn_tok {
Line 81  enum eqn_tok {
         EQN_TOK_TDEFINE,          EQN_TOK_TDEFINE,
         EQN_TOK_NDEFINE,          EQN_TOK_NDEFINE,
         EQN_TOK_UNDEF,          EQN_TOK_UNDEF,
         EQN_TOK_EOF,  
         EQN_TOK_ABOVE,          EQN_TOK_ABOVE,
         EQN_TOK__MAX          EQN_TOK__MAX,
           EQN_TOK_FUNC,
           EQN_TOK_QUOTED,
           EQN_TOK_SYM,
           EQN_TOK_EOF
 };  };
   
 static  const char *eqn_toks[EQN_TOK__MAX] = {  static  const char *eqn_toks[EQN_TOK__MAX] = {
Line 130  static const char *eqn_toks[EQN_TOK__MAX] = {
Line 134  static const char *eqn_toks[EQN_TOK__MAX] = {
         "tdefine", /* EQN_TOK_TDEFINE */          "tdefine", /* EQN_TOK_TDEFINE */
         "ndefine", /* EQN_TOK_NDEFINE */          "ndefine", /* EQN_TOK_NDEFINE */
         "undef", /* EQN_TOK_UNDEF */          "undef", /* EQN_TOK_UNDEF */
         NULL, /* EQN_TOK_EOF */  
         "above", /* EQN_TOK_ABOVE */          "above", /* EQN_TOK_ABOVE */
 };  };
   
   static  const char *const eqn_func[] = {
           "acos", "acsc", "and",  "arc",  "asec", "asin", "atan",
           "cos",  "cosh", "coth", "csc",  "det",  "exp",  "for",
           "if",   "lim",  "ln",   "log",  "max",  "min",
           "sec",  "sin",  "sinh", "tan",  "tanh", "Im",   "Re",
   };
   
 enum    eqn_symt {  enum    eqn_symt {
         EQNSYM_alpha,          EQNSYM_alpha,
         EQNSYM_beta,          EQNSYM_beta,
Line 498  eqn_tok_parse(struct eqn_node *ep, char **p)
Line 508  eqn_tok_parse(struct eqn_node *ep, char **p)
         size_t           i, sz;          size_t           i, sz;
         int              quoted;          int              quoted;
   
         if (NULL != p)          if (p != NULL)
                 *p = NULL;                  *p = NULL;
   
         quoted = ep->data[ep->cur] == '"';          quoted = ep->data[ep->cur] == '"';
   
         if (NULL == (start = eqn_nexttok(ep, &sz)))          if ((start = eqn_nexttok(ep, &sz)) == NULL)
                 return EQN_TOK_EOF;                  return EQN_TOK_EOF;
   
         if (quoted) {          if (quoted) {
                 if (p != NULL)                  if (p != NULL)
                         *p = mandoc_strndup(start, sz);                          *p = mandoc_strndup(start, sz);
                 return EQN_TOK__MAX;                  return EQN_TOK_QUOTED;
         }          }
   
         for (i = 0; i < EQN_TOK__MAX; i++) {          for (i = 0; i < EQN_TOK__MAX; i++)
                 if (NULL == eqn_toks[i])  
                         continue;  
                 if (STRNEQ(start, sz, eqn_toks[i], strlen(eqn_toks[i])))                  if (STRNEQ(start, sz, eqn_toks[i], strlen(eqn_toks[i])))
                         break;                          return i;
   
           for (i = 0; i < EQNSYM__MAX; i++) {
                   if (STRNEQ(start, sz,
                       eqnsyms[i].str, strlen(eqnsyms[i].str))) {
                           mandoc_asprintf(p, "\\[%s]", eqnsyms[i].sym);
                           return EQN_TOK_SYM;
                   }
         }          }
   
         if (i == EQN_TOK__MAX && NULL != p)          if (p != NULL)
                 *p = mandoc_strndup(start, sz);                  *p = mandoc_strndup(start, sz);
   
         return i;          for (i = 0; i < sizeof(eqn_func)/sizeof(*eqn_func); i++)
                   if (STRNEQ(start, sz, eqn_func[i], strlen(eqn_func[i])))
                           return EQN_TOK_FUNC;
   
           return EQN_TOK__MAX;
 }  }
   
 static void  static void
Line 554  eqn_box_alloc(struct eqn_node *ep, struct eqn_box *par
Line 573  eqn_box_alloc(struct eqn_node *ep, struct eqn_box *par
         bp->parent = parent;          bp->parent = parent;
         bp->parent->args++;          bp->parent->args++;
         bp->expectargs = UINT_MAX;          bp->expectargs = UINT_MAX;
           bp->font = bp->parent->font;
         bp->size = ep->gsize;          bp->size = ep->gsize;
   
         if (NULL != parent->first) {          if (NULL != parent->first) {
Line 702  static enum rofferr
Line 722  static enum rofferr
 eqn_parse(struct eqn_node *ep, struct eqn_box *parent)  eqn_parse(struct eqn_node *ep, struct eqn_box *parent)
 {  {
         char             sym[64];          char             sym[64];
         struct eqn_box  *cur;          struct eqn_box  *cur, *nbox;
         const char      *start;          const char      *cp, *cpn, *start;
         char            *p;          char            *p;
         size_t           i, sz;          size_t           sz;
         enum eqn_tok     tok, subtok;          enum eqn_tok     tok, subtok;
         enum eqn_post    pos;          enum eqn_post    pos;
           enum { CCL_LET, CCL_DIG, CCL_PUN } ccl, ccln;
         int              size;          int              size;
   
         assert(parent != NULL);          assert(parent != NULL);
Line 768  this_tok:
Line 789  this_tok:
                 parent = eqn_box_makebinary(ep, EQNPOS_NONE, parent);                  parent = eqn_box_makebinary(ep, EQNPOS_NONE, parent);
                 parent->type = EQN_LISTONE;                  parent->type = EQN_LISTONE;
                 parent->expectargs = 1;                  parent->expectargs = 1;
                   parent->font = EQNFONT_ROMAN;
                 switch (tok) {                  switch (tok) {
                 case EQN_TOK_DOTDOT:                  case EQN_TOK_DOTDOT:
                         strlcpy(sym, "\\[ad]", sizeof(sym));                          strlcpy(sym, "\\[ad]", sizeof(sym));
Line 1067  this_tok:
Line 1089  this_tok:
                  * TODO: make sure we're not in an open subexpression.                   * TODO: make sure we're not in an open subexpression.
                  */                   */
                 return ROFF_EQN;                  return ROFF_EQN;
         default:          case EQN_TOK__MAX:
                 assert(tok == EQN_TOK__MAX);          case EQN_TOK_FUNC:
                 assert(NULL != p);          case EQN_TOK_QUOTED:
           case EQN_TOK_SYM:
                   assert(p != NULL);
                 /*                  /*
                  * If we already have something in the stack and we're                   * If we already have something in the stack and we're
                  * in an expression, then rewind til we're not any more.                   * in an expression, then rewind til we're not any more.
Line 1078  this_tok:
Line 1102  this_tok:
                         parent = parent->parent;                          parent = parent->parent;
                 cur = eqn_box_alloc(ep, parent);                  cur = eqn_box_alloc(ep, parent);
                 cur->type = EQN_TEXT;                  cur->type = EQN_TEXT;
                 for (i = 0; i < EQNSYM__MAX; i++)                  cur->text = p;
                         if (0 == strcmp(eqnsyms[i].str, p)) {                  switch (tok) {
                                 (void)snprintf(sym, sizeof(sym),                  case EQN_TOK_FUNC:
                                         "\\[%s]", eqnsyms[i].sym);                          cur->font = EQNFONT_ROMAN;
                                 cur->text = mandoc_strdup(sym);                          break;
                                 free(p);                  case EQN_TOK_QUOTED:
                           if (cur->font == EQNFONT_NONE)
                                   cur->font = EQNFONT_ITALIC;
                           break;
                   case EQN_TOK_SYM:
                           break;
                   default:
                           if (cur->font != EQNFONT_NONE || *p == '\0')
                                 break;                                  break;
                           cpn = p - 1;
                           ccln = CCL_LET;
                           for (;;) {
                                   /* Advance to next character. */
                                   cp = cpn++;
                                   ccl = ccln;
                                   ccln = isalpha((unsigned char)*cpn) ? CCL_LET :
                                       isdigit((unsigned char)*cpn) ||
                                       (*cpn == '.' && (ccl == CCL_DIG ||
                                        isdigit((unsigned char)cpn[1]))) ?
                                       CCL_DIG : CCL_PUN;
                                   /* No boundary before first character. */
                                   if (cp < p)
                                           continue;
                                   cur->font = ccl == CCL_LET ?
                                       EQNFONT_ITALIC : EQNFONT_ROMAN;
                                   if (*cp == '\\')
                                           mandoc_escape(&cpn, NULL, NULL);
                                   /* No boundary after last character. */
                                   if (*cpn == '\0')
                                           break;
                                   if (ccln == ccl)
                                           continue;
                                   /* Boundary found, split the text. */
                                   if (parent->args == parent->expectargs) {
                                           /* Remove the text from the tree. */
                                           if (cur->prev == NULL)
                                                   parent->first = cur->next;
                                           else
                                                   cur->prev->next = NULL;
                                           parent->last = cur->prev;
                                           parent->args--;
                                           /* Set up a list instead. */
                                           nbox = eqn_box_alloc(ep, parent);
                                           nbox->type = EQN_LIST;
                                           /* Insert the word into the list. */
                                           nbox->first = nbox->last = cur;
                                           cur->parent = nbox;
                                           cur->prev = NULL;
                                           parent = nbox;
                                   }
                                   /* Append a new text box. */
                                   nbox = eqn_box_alloc(ep, parent);
                                   nbox->type = EQN_TEXT;
                                   nbox->text = mandoc_strdup(cpn);
                                   /* Truncate the old box. */
                                   p = mandoc_strndup(cur->text,
                                       cpn - cur->text);
                                   free(cur->text);
                                   cur->text = p;
                                   /* Setup to process the new box. */
                                   cur = nbox;
                                   p = nbox->text;
                                   cpn = p - 1;
                                   ccln = CCL_LET;
                         }                          }
                           break;
                 if (i == EQNSYM__MAX)                  }
                         cur->text = p;  
                 /*                  /*
                  * Post-process list status.                   * Post-process list status.
                  */                   */
Line 1096  this_tok:
Line 1181  this_tok:
                     parent->args == parent->expectargs)                      parent->args == parent->expectargs)
                         parent = parent->parent;                          parent = parent->parent;
                 break;                  break;
           default:
                   abort();
         }          }
         goto next_tok;          goto next_tok;
 }  }
Legend:
Removed from v.1.63  
changed lines
  Added in v.1.69
CVSweb