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

Diff for /mandoc/Attic/mdocterm.c between version 1.29 and 1.39

version 1.29, 2009/03/04 13:57:35 version 1.39, 2009/03/11 00:39:58
Line 16 
Line 16 
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR   * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.   * PERFORMANCE OF THIS SOFTWARE.
  */   */
 #include <sys/utsname.h>  #include <sys/types.h>
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
Line 25 
Line 25 
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #ifndef __OpenBSD__  
 #include <time.h>  
 #endif  
   
 #include "mmain.h"  #include "mmain.h"
 #include "term.h"  #include "term.h"
Line 55  static void    chara(struct termp *, char);
Line 52  static void    chara(struct termp *, char);
 static  void              stringa(struct termp *,  static  void              stringa(struct termp *,
                                 const char *, size_t);                                  const char *, size_t);
 static  void              symbola(struct termp *, enum tsym);  static  void              symbola(struct termp *, enum tsym);
   static  void              sanity(const struct mdoc_node *);
 static  void              stylea(struct termp *, enum tstyle);  static  void              stylea(struct termp *, enum tstyle);
   
 #ifdef __linux__  #ifdef __linux__
Line 76  static struct termenc   termenc1[] = {
Line 74  static struct termenc   termenc1[] = {
 };  };
   
 static  struct termenc    termenc2[] = {  static  struct termenc    termenc2[] = {
           { "rC",           TERMSYM_RBRACE },
           { "lC",           TERMSYM_LBRACE },
         { "rB",           TERMSYM_RBRACK },          { "rB",           TERMSYM_RBRACK },
         { "lB",           TERMSYM_LBRACK },          { "lB",           TERMSYM_LBRACK },
           { "ra",           TERMSYM_RANGLE },
           { "la",           TERMSYM_LANGLE },
         { "Lq",           TERMSYM_LDQUOTE },          { "Lq",           TERMSYM_LDQUOTE },
         { "lq",           TERMSYM_LDQUOTE },          { "lq",           TERMSYM_LDQUOTE },
         { "Rq",           TERMSYM_RDQUOTE },          { "Rq",           TERMSYM_RDQUOTE },
Line 99  static struct termenc   termenc2[] = {
Line 101  static struct termenc   termenc2[] = {
         { "Le",           TERMSYM_LE },          { "Le",           TERMSYM_LE },
         { "<=",           TERMSYM_LE },          { "<=",           TERMSYM_LE },
         { "Ge",           TERMSYM_GE },          { "Ge",           TERMSYM_GE },
         { "=>",           TERMSYM_GE },          { ">=",           TERMSYM_GE },
         { "==",           TERMSYM_EQ },          { "==",           TERMSYM_EQ },
         { "Ne",           TERMSYM_NEQ },          { "Ne",           TERMSYM_NEQ },
         { "!=",           TERMSYM_NEQ },          { "!=",           TERMSYM_NEQ },
Line 161  static struct termsym   termsym_ansi[] = {
Line 163  static struct termsym   termsym_ansi[] = {
         { " ", 1 },             /* TERMSYM_SPACE */          { " ", 1 },             /* TERMSYM_SPACE */
         { ".", 1 },             /* TERMSYM_PERIOD */          { ".", 1 },             /* TERMSYM_PERIOD */
         { "", 0 },              /* TERMSYM_BREAK */          { "", 0 },              /* TERMSYM_BREAK */
           { "<", 1 },             /* TERMSYM_LANGLE */
           { ">", 1 },             /* TERMSYM_RANGLE */
           { "{", 1 },             /* TERMSYM_LBRACE */
           { "}", 1 },             /* TERMSYM_RBRACE */
 };  };
   
 static  const char        ansi_clear[]  = { 27, '[', '0', 'm' };  static  const char        ansi_clear[]  = { 27, '[', '0', 'm' };
Line 177  static struct termsym   termstyle_ansi[] = {
Line 183  static struct termsym   termstyle_ansi[] = {
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct mmain    *p;          struct mmain      *p;
           int                c;
         const struct mdoc *mdoc;          const struct mdoc *mdoc;
         struct termp     termp;          struct termp       termp;
   
         p = mmain_alloc();          p = mmain_alloc();
   
         if ( ! mmain_getopt(p, argc, argv, NULL, NULL, NULL, NULL))          c = mmain_getopt(p, argc, argv, NULL, NULL, NULL, NULL);
                 mmain_exit(p, 1);          if (1 != c)
                   mmain_exit(p, -1 == c ? 1 : 0);
   
         if (NULL == (mdoc = mmain_mdoc(p)))          if (NULL == (mdoc = mmain_mdoc(p)))
                 mmain_exit(p, 1);                  mmain_exit(p, 1);
Line 283  flushln(struct termp *p)
Line 291  flushln(struct termp *p)
   
                 /* LINTED */                  /* LINTED */
                 for (j = i, vsz = 0; j < p->col; j++) {                  for (j = i, vsz = 0; j < p->col; j++) {
                         if (isspace((int)p->buf[j]))                          if (isspace((u_char)p->buf[j]))
                                 break;                                  break;
                         else if (27 == p->buf[j]) {                          else if (27 == p->buf[j]) {
                                 assert(j + 4 <= p->col);                                  assert(j + 4 <= p->col);
Line 316  flushln(struct termp *p)
Line 324  flushln(struct termp *p)
                                 putchar('\n');                                  putchar('\n');
                                 for (j = 0; j < p->rmargin; j++)                                  for (j = 0; j < p->rmargin; j++)
                                         putchar(' ');                                          putchar(' ');
                                 vis = p->offset;                                  vis = p->rmargin - p->offset;
                         } else if (vis + vsz > bp)                          } else if (vis + vsz > bp)
                                 warnx("word breaks right margin");                                  warnx("word breaks right margin");
   
Line 330  flushln(struct termp *p)
Line 338  flushln(struct termp *p)
                  */                   */
   
                 for ( ; i < p->col; i++) {                  for ( ; i < p->col; i++) {
                         if (isspace((int)p->buf[i]))                          if (isspace((u_char)p->buf[i]))
                                 break;                                  break;
                         putchar(p->buf[i]);                          putchar(p->buf[i]);
                 }                  }
Line 347  flushln(struct termp *p)
Line 355  flushln(struct termp *p)
          */           */
   
         if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {          if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {
                 putchar('\n');                  if ( ! (TERMP_NONOBREAK & p->flags)) {
                 for (i = 0; i < p->rmargin; i++)                          putchar('\n');
                         putchar(' ');                          for (i = 0; i < p->rmargin; i++)
                                   putchar(' ');
                   }
                 p->col = 0;                  p->col = 0;
                 return;                  return;
         }          }
Line 359  flushln(struct termp *p)
Line 369  flushln(struct termp *p)
          * pad to the right margin and stay off.           * pad to the right margin and stay off.
          */           */
   
         if (p->flags & TERMP_NOBREAK)          if (p->flags & TERMP_NOBREAK) {
                 for ( ; vis < maxvis; vis++)                  if ( ! (TERMP_NONOBREAK & p->flags))
                         putchar(' ');                          for ( ; vis < maxvis; vis++)
         else                                  putchar(' ');
           } else
                 putchar('\n');                  putchar('\n');
   
         p->col = 0;          p->col = 0;
Line 430  word(struct termp *p, const char *word)
Line 441  word(struct termp *p, const char *word)
   
         /* LINTED */          /* LINTED */
         for (j = i = 0; i < len; i++) {          for (j = i = 0; i < len; i++) {
                 if ( ! isspace((int)word[i])) {                  if ( ! isspace((u_char)word[i])) {
                         j++;                          j++;
                         continue;                          continue;
                 }                  }
   
                 /* Escaped spaces don't delimit... */                  /* Escaped spaces don't delimit... */
                 if (i > 0 && isspace((int)word[i]) &&                  if (i > 0 && isspace((u_char)word[i]) &&
                                 '\\' == word[i - 1]) {                                  '\\' == word[i - 1]) {
                         j++;                          j++;
                         continue;                          continue;
Line 469  body(struct termp *p, struct termpair *ppair,
Line 480  body(struct termp *p, struct termpair *ppair,
         int              dochild;          int              dochild;
         struct termpair  pair;          struct termpair  pair;
   
           /* Some quick sanity-checking. */
   
           sanity(node);
   
         /* Pre-processing. */          /* Pre-processing. */
   
         dochild = 1;          dochild = 1;
Line 483  body(struct termp *p, struct termpair *ppair,
Line 498  body(struct termp *p, struct termpair *ppair,
                         if ( ! (*termacts[node->tok].pre)(p, &pair, meta, node))                          if ( ! (*termacts[node->tok].pre)(p, &pair, meta, node))
                                 dochild = 0;                                  dochild = 0;
         } else /* MDOC_TEXT == node->type */          } else /* MDOC_TEXT == node->type */
                 word(p, node->data.text.string);                  word(p, node->string);
   
         /* Children. */          /* Children. */
   
Line 563  footer(struct termp *p, const struct mdoc_meta *meta)
Line 578  footer(struct termp *p, const struct mdoc_meta *meta)
 static void  static void
 header(struct termp *p, const struct mdoc_meta *meta)  header(struct termp *p, const struct mdoc_meta *meta)
 {  {
         char            *buf, *title, *bufp, *vbuf;          char            *buf, *title, *bufp;
         const char      *pp;  
         struct utsname   uts;  
   
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
         p->offset = 0;          p->offset = 0;
Line 574  header(struct termp *p, const struct mdoc_meta *meta)
Line 587  header(struct termp *p, const struct mdoc_meta *meta)
                 err(1, "malloc");                  err(1, "malloc");
         if (NULL == (title = malloc(p->rmargin)))          if (NULL == (title = malloc(p->rmargin)))
                 err(1, "malloc");                  err(1, "malloc");
         if (NULL == (vbuf = malloc(p->rmargin)))  
                 err(1, "malloc");  
   
         if (NULL == (pp = mdoc_vol2a(meta->vol))) {  
                 switch (meta->msec) {  
                 case (MSEC_1):  
                         /* FALLTHROUGH */  
                 case (MSEC_6):  
                         /* FALLTHROUGH */  
                 case (MSEC_7):  
                         pp = mdoc_vol2a(VOL_URM);  
                         break;  
                 case (MSEC_8):  
                         pp = mdoc_vol2a(VOL_SMM);  
                         break;  
                 case (MSEC_2):  
                         /* FALLTHROUGH */  
                 case (MSEC_3):  
                         /* FALLTHROUGH */  
                 case (MSEC_4):  
                         /* FALLTHROUGH */  
                 case (MSEC_5):  
                         pp = mdoc_vol2a(VOL_PRM);  
                         break;  
                 case (MSEC_9):  
                         pp = mdoc_vol2a(VOL_KM);  
                         break;  
                 default:  
                         break;  
                 }  
         }  
         vbuf[0] = 0;  
   
         if (pp) {  
                 if (-1 == uname(&uts))  
                         err(1, "uname");  
                 (void)strlcat(vbuf, uts.sysname, p->rmargin);  
                 (void)strlcat(vbuf, " ", p->rmargin);  
         } else if (NULL == (pp = mdoc_msec2a(meta->msec)))  
                 pp = mdoc_msec2a(MSEC_local);  
   
         (void)strlcat(vbuf, pp, p->rmargin);  
   
         /*          /*
          * The header is strange.  It has three components, which are           * The header is strange.  It has three components, which are
          * really two with the first duplicated.  It goes like this:           * really two with the first duplicated.  It goes like this:
Line 630  header(struct termp *p, const struct mdoc_meta *meta)
Line 601  header(struct termp *p, const struct mdoc_meta *meta)
          * switches on the manual section.           * switches on the manual section.
          */           */
   
         if (mdoc_arch2a(meta->arch))          assert(meta->vol);
                 (void)snprintf(buf, p->rmargin, "%s (%s)",          (void)strlcpy(buf, meta->vol, p->rmargin);
                                 vbuf, mdoc_arch2a(meta->arch));  
         else  
                 (void)strlcpy(buf, vbuf, p->rmargin);  
   
         pp = mdoc_msec2a(meta->msec);          if (meta->arch) {
                   (void)strlcat(buf, " (", p->rmargin);
                   (void)strlcat(buf, meta->arch, p->rmargin);
                   (void)strlcat(buf, ")", p->rmargin);
           }
   
         (void)snprintf(title, p->rmargin, "%s(%s)",          (void)snprintf(title, p->rmargin, "%s(%d)",
                         meta->title, pp ? pp : "");                          meta->title, meta->msec);
   
         for (bufp = title; *bufp; bufp++)          for (bufp = title; *bufp; bufp++)
                 *bufp = toupper(*bufp);                  *bufp = toupper((u_char)*bufp);
   
         p->offset = 0;          p->offset = 0;
         p->rmargin = (p->maxrmargin - strlen(buf)) / 2;          p->rmargin = (p->maxrmargin - strlen(buf)) / 2;
Line 671  header(struct termp *p, const struct mdoc_meta *meta)
Line 643  header(struct termp *p, const struct mdoc_meta *meta)
         p->flags &= ~TERMP_NOSPACE;          p->flags &= ~TERMP_NOSPACE;
   
         free(title);          free(title);
         free(vbuf);  
         free(buf);          free(buf);
 }  }
   
Line 718  pescape(struct termp *p, const char *word, size_t *i, 
Line 689  pescape(struct termp *p, const char *word, size_t *i, 
 {  {
         size_t           j;          size_t           j;
   
         (*i)++;          if (++(*i) >= len) {
         assert(*i < len);                  warnx("ignoring bad escape sequence");
                   return;
           }
   
         if ('(' == word[*i]) {          if ('(' == word[*i]) {
                 (*i)++;                  (*i)++;
                 assert(*i + 1 < len);                  if (*i + 1 >= len) {
                           warnx("ignoring bad escape sequence");
                           return;
                   }
                 nescape(p, &word[*i], 2);                  nescape(p, &word[*i], 2);
                 (*i)++;                  (*i)++;
                 return;                  return;
   
         } else if ('*' == word[*i]) {          } else if ('*' == word[*i]) {
                 /* XXX - deprecated! */  
                 (*i)++;                  (*i)++;
                 assert(*i < len);                  if (*i >= len) {
                           warnx("ignoring bad escape sequence");
                           return;
                   }
                 switch (word[*i]) {                  switch (word[*i]) {
                 case ('('):                  case ('('):
                         (*i)++;                          (*i)++;
                         assert(*i + 1 < len);                          if (*i + 1 >= len) {
                                   warnx("ignoring bad escape sequence");
                                   return;
                           }
                         nescape(p, &word[*i], 2);                          nescape(p, &word[*i], 2);
                         (*i)++;                          (*i)++;
                         return;                          return;
Line 755  pescape(struct termp *p, const char *word, size_t *i, 
Line 736  pescape(struct termp *p, const char *word, size_t *i, 
         for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)          for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
                 /* Loop... */ ;                  /* Loop... */ ;
   
         assert(word[*i]);          if (0 == word[*i]) {
                   warnx("ignoring bad escape sequence");
                   return;
           }
         nescape(p, &word[*i - j], j);          nescape(p, &word[*i - j], j);
 }  }
   
Line 870  chara(struct termp *p, char c)
Line 854  chara(struct termp *p, char c)
         }          }
         p->buf[(p->col)++] = c;          p->buf[(p->col)++] = c;
 }  }
   
   
   static void
   sanity(const struct mdoc_node *n)
   {
   
           switch (n->type) {
           case (MDOC_TEXT):
                   if (n->child)
                           errx(1, "regular form violated (1)");
                   if (NULL == n->parent)
                           errx(1, "regular form violated (2)");
                   if (NULL == n->string)
                           errx(1, "regular form violated (3)");
                   switch (n->parent->type) {
                   case (MDOC_TEXT):
                           /* FALLTHROUGH */
                   case (MDOC_ROOT):
                           errx(1, "regular form violated (4)");
                           /* NOTREACHED */
                   default:
                           break;
                   }
                   break;
           case (MDOC_ELEM):
                   if (NULL == n->parent)
                           errx(1, "regular form violated (5)");
                   switch (n->parent->type) {
                   case (MDOC_TAIL):
                           /* FALLTHROUGH */
                   case (MDOC_BODY):
                           /* FALLTHROUGH */
                   case (MDOC_HEAD):
                           break;
                   default:
                           errx(1, "regular form violated (6)");
                           /* NOTREACHED */
                   }
                   if (n->child) switch (n->child->type) {
                   case (MDOC_TEXT):
                           break;
                   default:
                           errx(1, "regular form violated (7(");
                           /* NOTREACHED */
                   }
                   break;
           case (MDOC_HEAD):
                   /* FALLTHROUGH */
           case (MDOC_BODY):
                   /* FALLTHROUGH */
           case (MDOC_TAIL):
                   if (NULL == n->parent)
                           errx(1, "regular form violated (8)");
                   if (MDOC_BLOCK != n->parent->type)
                           errx(1, "regular form violated (9)");
                   if (n->child) switch (n->child->type) {
                   case (MDOC_BLOCK):
                           /* FALLTHROUGH */
                   case (MDOC_ELEM):
                           /* FALLTHROUGH */
                   case (MDOC_TEXT):
                           break;
                   default:
                           errx(1, "regular form violated (a)");
                           /* NOTREACHED */
                   }
                   break;
           case (MDOC_BLOCK):
                   if (NULL == n->parent)
                           errx(1, "regular form violated (b)");
                   if (NULL == n->child)
                           errx(1, "regular form violated (c)");
                   switch (n->parent->type) {
                   case (MDOC_ROOT):
                           /* FALLTHROUGH */
                   case (MDOC_HEAD):
                           /* FALLTHROUGH */
                   case (MDOC_BODY):
                           /* FALLTHROUGH */
                   case (MDOC_TAIL):
                           break;
                   default:
                           errx(1, "regular form violated (d)");
                           /* NOTREACHED */
                   }
                   switch (n->child->type) {
                   case (MDOC_ROOT):
                           /* FALLTHROUGH */
                   case (MDOC_ELEM):
                           errx(1, "regular form violated (e)");
                           /* NOTREACHED */
                   default:
                           break;
                   }
                   break;
           case (MDOC_ROOT):
                   if (n->parent)
                           errx(1, "regular form violated (f)");
                   if (NULL == n->child)
                           errx(1, "regular form violated (10)");
                   switch (n->child->type) {
                   case (MDOC_BLOCK):
                           break;
                   default:
                           errx(1, "regular form violated (11)");
                           /* NOTREACHED */
                   }
                   break;
           }
   }
   
Legend:
Removed from v.1.29  
changed lines
  Added in v.1.39
CVSweb