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

Diff for /pod2mdoc/pod2mdoc.c between version 1.7 and 1.12

version 1.7, 2014/03/23 23:35:59 version 1.12, 2014/04/01 11:58:32
Line 26 
Line 26 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
   /*
    * In what section can we find Perl manuals?
    */
   #define PERL_SECTION    "3p"
   
 struct  args {  struct  args {
         const char      *title; /* override "Dt" title */          const char      *title; /* override "Dt" title */
         const char      *date; /* override "Dd" date */          const char      *date; /* override "Dd" date */
Line 39  enum list {
Line 44  enum list {
         LIST__MAX          LIST__MAX
 };  };
   
   enum    sect {
           SECT_NONE = 0,
           SECT_NAME, /* NAME section */
           SECT_SYNOPSIS, /* SYNOPSIS section */
   };
   
 struct  state {  struct  state {
         int              parsing; /* after =cut of before command */          int              parsing; /* after =cut of before command */
         int              paused; /* in =begin and before =end */          int              paused; /* in =begin and before =end */
         int              haspar; /* in paragraph: do we need Pp? */          int              haspar; /* in paragraph: do we need Pp? */
         int              isname; /* are we the NAME section? */          enum sect        sect; /* which section are we in? */
         const char      *fname; /* file being parsed */          const char      *fname; /* file being parsed */
 #define LIST_STACKSZ     128  #define LIST_STACKSZ     128
         enum list        lstack[LIST_STACKSZ]; /* open lists */          enum list        lstack[LIST_STACKSZ]; /* open lists */
Line 158  formatescape(const char *buf, size_t *start, size_t en
Line 169  formatescape(const char *buf, size_t *start, size_t en
 }  }
   
 /*  /*
  * Skip space characters.   * Run some heuristics to intuit a link format.
    * I recognise L<foo::bar> as a Perl manpage, printing it in section 3p;
    * or a general UNIX foo(5) manpage.
    * If I recognise one, I set "start" to be the end of the sequence so
    * that the caller can safely just continue processing.
    * Otherwise, I don't touch "start".
  */   */
 static int  static int
 skipspace(const char *buf, size_t *start, size_t end)  trylink(const char *buf, size_t *start, size_t end, size_t dsz)
 {  {
         size_t           sv = *start;          size_t          sv, nstart, nend, i, j;
           int             hasdouble;
   
         while (*start < end && ' ' == buf[*start])          /*
                 (*start)++;           * Scan to the start of the terminus.
            * This function is more or less replicated in the formatcode()
            * for null or index formatting codes.
            */
           hasdouble = 0;
           for (sv = nstart = *start; nstart < end; nstart++) {
                   /* Do we have a double-colon? */
                   if (':' == buf[nstart] &&
                           nstart > sv &&
                           ':' == buf[nstart - 1])
                           hasdouble = 1;
                   if ('>' != buf[nstart])
                           continue;
                   else if (dsz == 1)
                           break;
                   assert(nstart > 0);
                   if (' ' != buf[nstart - 1])
                           continue;
                   i = nstart;
                   for (j = 0; i < end && j < dsz; j++)
                           if ('>' != buf[i++])
                                   break;
                   if (dsz == j)
                           break;
           }
   
           /* We don't care about stubs. */
           if (nstart == end || nstart == *start)
                   return(0);
   
         return(*start > sv);          /* Set nend to the end of content. */
           nend = nstart;
           if (dsz > 1)
                   nend--;
   
           /*
            * Provide for some common invocations of the link primitive.
            * First, allow us to link to other Perl manuals.
            */
           if (hasdouble)
                   printf("Xr %.*s " PERL_SECTION,
                           (int)(nend - sv), &buf[sv]);
           else if (nend - sv > 3 && isalnum(buf[sv]) &&
                           ')' == buf[nend - 1] &&
                           isdigit((int)buf[nend - 2]) &&
                           '(' == buf[nend - 3])
                   printf("Xr %.*s %c",
                           (int)(nend - 3 - sv),
                           &buf[sv], buf[nend - 2]);
           else
                   return(0);
   
           *start = nstart;
           return(1);
 }  }
   
 /*  /*
Line 185  skipspace(const char *buf, size_t *start, size_t end)
Line 253  skipspace(const char *buf, size_t *start, size_t end)
  * reentrant).   * reentrant).
  */   */
 static int  static int
 formatcode(const char *buf, size_t *start,  formatcode(struct state *st, const char *buf,
         size_t end, int reentrant, int nomacro)          size_t *start, size_t end, int reentrant, int nomacro)
 {  {
         enum fmt         fmt;          enum fmt         fmt;
         size_t           i, j, dsz;          size_t           i, j, dsz;
Line 204  formatcode(const char *buf, size_t *start, 
Line 272  formatcode(const char *buf, size_t *start, 
   
         if (FMT__MAX == fmt) {          if (FMT__MAX == fmt) {
                 putchar(last = buf[(*start)++]);                  putchar(last = buf[(*start)++]);
                   if ('\\' == last)
                           putchar('e');
                 return(0);                  return(0);
         }          }
   
Line 290  formatcode(const char *buf, size_t *start, 
Line 360  formatcode(const char *buf, size_t *start, 
                         printf("Em ");                          printf("Em ");
                         break;                          break;
                 case (FMT_BOLD):                  case (FMT_BOLD):
                           /*
                            * Doclifting: if we're a bold "-xx" and we're
                            * in the SYNOPSIS section, then it's likely
                            * that we're a flag.
                            * Be really strict: only do this when the dash
                            * is followed by alnums til the end marker,
                            * which mustn't be a custom.
                            */
                           if (SECT_SYNOPSIS == st->sect &&
                                   end - *start > 1 &&
                                   '-' == buf[*start] &&
                                   (isalnum((int)buf[*start + 1]) ||
                                    '?' == buf[*start + 1])) {
                                   for (i = *start + 1; i < end; i++)
                                           if ( ! isalnum((int)buf[i]))
                                                   break;
                                   if (i < end && '>' == buf[i]) {
                                           (*start)++;
                                           printf("Fl ");
                                           break;
                                   }
                           }
                         printf("Sy ");                          printf("Sy ");
                         break;                          break;
                 case (FMT_CODE):                  case (FMT_CODE):
                         printf("Qo Li ");                          printf("Qo Li ");
                         break;                          break;
                 case (FMT_LINK):                  case (FMT_LINK):
                         printf("Lk ");                          if ( ! trylink(buf, start, end, dsz))
                                   printf("No ");
                         break;                          break;
                 case (FMT_FILE):                  case (FMT_FILE):
                         printf("Pa ");                          printf("Pa ");
                         break;                          break;
                 case (FMT_NBSP):                  case (FMT_NBSP):
                         /* TODO. */  
                         printf("No ");                          printf("No ");
                         break;                          break;
                 default:                  default:
Line 338  formatcode(const char *buf, size_t *start, 
Line 430  formatcode(const char *buf, size_t *start, 
                         }                          }
                 }                  }
                 if (*start + 1 < end && '<' == buf[*start + 1]) {                  if (*start + 1 < end && '<' == buf[*start + 1]) {
                         formatcode(buf, start, end, 1, nomacro);                          formatcode(st, buf, start, end, 1, nomacro);
                         continue;                          continue;
                 }                  }
   
Line 363  formatcode(const char *buf, size_t *start, 
Line 455  formatcode(const char *buf, size_t *start, 
                 else                  else
                         putchar(last = buf[*start]);                          putchar(last = buf[*start]);
   
                   /* Protect against character escapes. */
                   if ('\\' == last)
                           putchar('e');
   
                 (*start)++;                  (*start)++;
   
                 if (' ' == last)                  if (' ' == last)
Line 389  formatcode(const char *buf, size_t *start, 
Line 485  formatcode(const char *buf, size_t *start, 
  * Calls formatcode() til the end of a paragraph.   * Calls formatcode() til the end of a paragraph.
  */   */
 static void  static void
 formatcodeln(const char *buf, size_t *start, size_t end, int nomacro)  formatcodeln(struct state *st, const char *buf,
           size_t *start, size_t end, int nomacro)
 {  {
   
         last = ' ';          last = ' ';
         while (*start < end)  {          while (*start < end)  {
                 if (*start + 1 < end && '<' == buf[*start + 1]) {                  if (*start + 1 < end && '<' == buf[*start + 1]) {
                         formatcode(buf, start, end, 1, nomacro);                          formatcode(st, buf, start, end, 1, nomacro);
                         continue;                          continue;
                 }                  }
                 /*                  /*
Line 412  formatcodeln(const char *buf, size_t *start, size_t en
Line 509  formatcodeln(const char *buf, size_t *start, size_t en
                                  ' ' == buf[*start + 2]))                                   ' ' == buf[*start + 2]))
                         printf("\\&");                          printf("\\&");
   
                 if ('\n' != buf[*start])                  if ('\n' == buf[*start])
                         putchar(last = buf[*start]);  
                 else  
                         putchar(last = ' ');                          putchar(last = ' ');
                   else
                           putchar(last = buf[*start]);
   
                   /* Protect against character escapes. */
                   if ('\\' == last)
                           putchar('e');
   
                 (*start)++;                  (*start)++;
         }          }
 }  }
Line 471  command(struct state *st, const char *buf, size_t star
Line 573  command(struct state *st, const char *buf, size_t star
                 return;                  return;
   
         start += csz;          start += csz;
         skipspace(buf, &start, end);          while (start < end && ' ' == buf[start])
                   start++;
   
         len = end - start;          len = end - start;
   
         if (st->paused) {          if (st->paused) {
Line 488  command(struct state *st, const char *buf, size_t star
Line 592  command(struct state *st, const char *buf, size_t star
                  * how pod2man handles it.                   * how pod2man handles it.
                  */                   */
                 printf(".Sh ");                  printf(".Sh ");
                 st->isname = 0;                  st->sect = SECT_NONE;
                 if (end - start == 4)                  if (end - start == 4) {
                         if (0 == memcmp(&buf[start], "NAME", 4))                          if (0 == memcmp(&buf[start], "NAME", 4))
                                 st->isname = 1;                                  st->sect = SECT_NAME;
                 formatcodeln(buf, &start, end, 1);                  } else if (end - start == 8) {
                           if (0 == memcmp(&buf[start], "SYNOPSIS", 8))
                                   st->sect = SECT_SYNOPSIS;
                   }
                   formatcodeln(st, buf, &start, end, 1);
                 putchar('\n');                  putchar('\n');
                 st->haspar = 1;                  st->haspar = 1;
                 break;                  break;
         case (CMD_HEAD2):          case (CMD_HEAD2):
                 printf(".Ss ");                  printf(".Ss ");
                 formatcodeln(buf, &start, end, 1);                  formatcodeln(st, buf, &start, end, 1);
                 putchar('\n');                  putchar('\n');
                 st->haspar = 1;                  st->haspar = 1;
                 break;                  break;
         case (CMD_HEAD3):          case (CMD_HEAD3):
                 puts(".Pp");                  puts(".Pp");
                 printf(".Em ");                  printf(".Em ");
                 formatcodeln(buf, &start, end, 0);                  formatcodeln(st, buf, &start, end, 0);
                 putchar('\n');                  putchar('\n');
                 puts(".Pp");                  puts(".Pp");
                 st->haspar = 1;                  st->haspar = 1;
Line 513  command(struct state *st, const char *buf, size_t star
Line 621  command(struct state *st, const char *buf, size_t star
         case (CMD_HEAD4):          case (CMD_HEAD4):
                 puts(".Pp");                  puts(".Pp");
                 printf(".No ");                  printf(".No ");
                 formatcodeln(buf, &start, end, 0);                  formatcodeln(st, buf, &start, end, 0);
                 putchar('\n');                  putchar('\n');
                 puts(".Pp");                  puts(".Pp");
                 st->haspar = 1;                  st->haspar = 1;
Line 567  command(struct state *st, const char *buf, size_t star
Line 675  command(struct state *st, const char *buf, size_t star
                 switch (st->lstack[st->lpos - 1]) {                  switch (st->lstack[st->lpos - 1]) {
                 case (LIST_TAG):                  case (LIST_TAG):
                         printf(".It ");                          printf(".It ");
                         formatcodeln(buf, &start, end, 0);                          formatcodeln(st, buf, &start, end, 0);
                         putchar('\n');                          putchar('\n');
                         break;                          break;
                 case (LIST_ENUM):                  case (LIST_ENUM):
Line 624  command(struct state *st, const char *buf, size_t star
Line 732  command(struct state *st, const char *buf, size_t star
 static void  static void
 verbatim(struct state *st, const char *buf, size_t start, size_t end)  verbatim(struct state *st, const char *buf, size_t start, size_t end)
 {  {
         size_t           sv = start;          int              last;
   
         if ( ! st->parsing || st->paused)          if ( ! st->parsing || st->paused)
                 return;                  return;
   
         puts(".Bd -literal");          puts(".Bd -literal");
         while (start < end) {          for (last = ' '; start < end; start++) {
                 if (start > sv && '\n' == buf[start - 1])                  /*
                    * Handle accidental macros (newline starting with
                    * control character) and escapes.
                    */
                   if ('\n' == last)
                         if ('.' == buf[start] || '\'' == buf[start])                          if ('.' == buf[start] || '\'' == buf[start])
                                 printf("\\&");                                  printf("\\&");
                 putchar(buf[start++]);                  putchar(last = buf[start]);
                   if ('\\' == buf[start])
                           printf("e");
         }          }
         putchar('\n');          putchar('\n');
         puts(".Ed");          puts(".Ed");
Line 662  ordinary(struct state *st, const char *buf, size_t sta
Line 776  ordinary(struct state *st, const char *buf, size_t sta
          * we're in "name - description" format.           * we're in "name - description" format.
          * To wit, print out a "Nm" and "Nd" in that format.           * To wit, print out a "Nm" and "Nd" in that format.
          */           */
         if (st->isname) {          if (SECT_NAME == st->sect) {
                 for (i = end - 1; i > start; i--)                  for (i = end - 1; i > start; i--)
                         if ('-' == buf[i])                          if ('-' == buf[i])
                                 break;                                  break;
Line 673  ordinary(struct state *st, const char *buf, size_t sta
Line 787  ordinary(struct state *st, const char *buf, size_t sta
                                 if ('-' != buf[i])                                  if ('-' != buf[i])
                                         break;                                          break;
                         printf(".Nm ");                          printf(".Nm ");
                         formatcodeln(buf, &start, i + 1, 1);                          formatcodeln(st, buf, &start, i + 1, 1);
                         putchar('\n');                          putchar('\n');
                         start = j + 1;                          start = j + 1;
                         printf(".Nd ");                          printf(".Nd ");
                         formatcodeln(buf, &start, end, 1);                          formatcodeln(st, buf, &start, end, 1);
                         putchar('\n');                          putchar('\n');
                         return;                          return;
                 }                  }
Line 703  ordinary(struct state *st, const char *buf, size_t sta
Line 817  ordinary(struct state *st, const char *buf, size_t sta
                                 printf("\\&");                                  printf("\\&");
                         else if ('\n' == last && '\'' == buf[start])                          else if ('\n' == last && '\'' == buf[start])
                                 printf("\\&");                                  printf("\\&");
   #if notyet
                           /*
                            * If we're in the SYNOPSIS, have square
                            * brackets indicate that we're opening and
                            * closing an optional context.
                            */
                           if (SECT_SYNOPSIS == st->sect) {
                                   if ('[' == buf[start] ||
                                           ']' == buf[start]) {
                                           if (last != '\n')
                                                   putchar('\n');
                                           if ('[' == buf[start])
                                                   printf(".Oo\n");
                                           else
                                                   printf(".Oc\n");
                                           start++;
                                           continue;
                                   }
                           }
   #endif
                         putchar(last = buf[start++]);                          putchar(last = buf[start++]);
                           if ('\\' == last)
                                   putchar('e');
                 }                  }
   
                 if (start < end - 1 && '<' == buf[start + 1]) {                  if (start < end - 1 && '<' == buf[start + 1]) {
Line 713  ordinary(struct state *st, const char *buf, size_t sta
Line 849  ordinary(struct state *st, const char *buf, size_t sta
                          * what, so print a newline now.                           * what, so print a newline now.
                          * Then print the (possibly nested) macros and                           * Then print the (possibly nested) macros and
                          * following that, a newline.                           * following that, a newline.
                            * Consume all whitespace so we don't
                            * accidentally start an implicit literal line.
                          */                           */
                         if (formatcode(buf, &start, end, 0, 0)) {                          if (formatcode(st, buf, &start, end, 0, 0)) {
                                 putchar(last = '\n');                                  putchar(last = '\n');
                                 while (start < end && ' ' == buf[start])                                  while (start < end && ' ' == buf[start])
                                         start++;                                          start++;
Line 743  ordinary(struct state *st, const char *buf, size_t sta
Line 881  ordinary(struct state *st, const char *buf, size_t sta
                         for ( ; start < end; start++)                          for ( ; start < end; start++)
                                 if (' ' != buf[start] && '\t' != buf[start])                                  if (' ' != buf[start] && '\t' != buf[start])
                                         break;                                          break;
                 } else if (start < end) {                  }
                         /*  
                          * Default: print the character.  
                          * Escape initial control characters.  
                          */  
                         if ('\n' == last && '.' == buf[start])  
                                 printf("\\&");  
                         else if ('\n' == last && '\'' == buf[start])  
                                 printf("\\&");  
                         putchar(last = buf[start++]);  
                 }  
         }          }
   
         if (last != '\n')          if (last != '\n')
Line 817  dofile(const struct args *args, const char *fname, 
Line 945  dofile(const struct args *args, const char *fname, 
                 if (NULL != (cp = strrchr(title, '.'))) {                  if (NULL != (cp = strrchr(title, '.'))) {
                         *cp++ = '\0';                          *cp++ = '\0';
                         if (0 == strcmp(cp, "pm"))                          if (0 == strcmp(cp, "pm"))
                                 section = "3p";                                  section = PERL_SECTION;
                 }                  }
         }          }
   
Legend:
Removed from v.1.7  
changed lines
  Added in v.1.12
CVSweb