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

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

version 1.33, 2009/03/05 13:12:12 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 },          { "ra",           TERMSYM_RANGLE },
Line 165  static struct termsym   termsym_ansi[] = {
Line 165  static struct termsym   termsym_ansi[] = {
         { "", 0 },              /* TERMSYM_BREAK */          { "", 0 },              /* TERMSYM_BREAK */
         { "<", 1 },             /* TERMSYM_LANGLE */          { "<", 1 },             /* TERMSYM_LANGLE */
         { ">", 1 },             /* TERMSYM_RANGLE */          { ">", 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 181  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 476  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 490  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 570  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 581  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 637  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((u_char)*bufp);                  *bufp = toupper((u_char)*bufp);
Line 678  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 725  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 762  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 877  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.33  
changed lines
  Added in v.1.39
CVSweb