Missing prototype for getsubopt() on NetBSD fixed.

[mandoc.git] / out.c

diff --git a/out.c b/out.c
index 78abc5dce04bb372e1e346296816849d41a99404..7e5ccad892f95e165cff94e2791cf743ba4d1dbd 100644 (file)
--- a/out.c
+++ b/out.c
@@ -1,4 +1,4 @@
-/*     $Id: out.c,v 1.6 2009/10/22 18:55:32 kristaps Exp $ */
+/*     $Id: out.c,v 1.15 2010/04/07 11:29:55 kristaps Exp $ */
 /*
  * Copyright (c) 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -14,6 +14,10 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
 #include <sys/types.h>
 
 #include <assert.h>
@@ -21,9 +25,29 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
 #include "out.h"
 
+/* See a2roffdeco(). */
+#define        C2LIM(c, l) do { \
+       (l) = 1; \
+       if ('[' == (c) || '\'' == (c)) \
+               (l) = 0; \
+       else if ('(' == (c)) \
+               (l) = 2; } \
+       while (/* CONSTCOND */ 0)
+
+/* See a2roffdeco(). */
+#define        C2TERM(c, t) do { \
+       (t) = 0; \
+       if ('\'' == (c)) \
+               (t) = 1; \
+       else if ('[' == (c)) \
+               (t) = 2; \
+       else if ('(' == (c)) \
+               (t) = 3; } \
+       while (/* CONSTCOND */ 0)
 
 /* 
  * Convert a `scaling unit' to a consistent form, or fail.  Scaling
@@ -162,3 +186,214 @@ time2a(time_t t, char *dst, size_t sz)
        (void)strftime(p, sz, "%Y", &tm);
 }
 
+
+/* 
+ * Returns length of parsed string (the leading "\" should NOT be
+ * included).  This can be zero if the current character is the nil
+ * terminator.  "d" is set to the type of parsed decorator, which may
+ * have an adjoining "word" of size "sz" (e.g., "(ab" -> "ab", 2).
+ */
+int
+a2roffdeco(enum roffdeco *d,
+               const char **word, size_t *sz)
+{
+       int              j, term, lim;
+       char             set;
+       const char      *wp, *sp;
+
+       *d = DECO_NONE;
+       wp = *word;
+
+       switch ((set = *wp)) {
+       case ('\0'):
+               return(0);
+
+       case ('('):
+               if ('\0' == *(++wp))
+                       return(1);
+               if ('\0' == *(wp + 1))
+                       return(2);
+
+               *d = DECO_SPECIAL;
+               *sz = 2;
+               *word = wp;
+               return(3);
+
+       case ('F'):
+               /* FALLTHROUGH */
+       case ('f'):
+               /*
+                * FIXME: this needs work and consolidation (it should
+                * follow the sequence that special characters do, for
+                * one), but isn't a priority at the moment.  Note, for
+                * one, that in reality \fB != \FB, although here we let
+                * these slip by.
+                */
+               switch (*(++wp)) {
+               case ('\0'):
+                       return(1);
+               case ('3'):
+                       /* FALLTHROUGH */
+               case ('B'):
+                       *d = DECO_BOLD;
+                       return(2);
+               case ('2'):
+                       /* FALLTHROUGH */
+               case ('I'):
+                       *d = DECO_ITALIC;
+                       return(2);
+               case ('P'):
+                       *d = DECO_PREVIOUS;
+                       return(2);
+               case ('1'):
+                       /* FALLTHROUGH */
+               case ('R'):
+                       *d = DECO_ROMAN;
+                       return(2);
+               case ('('):
+                       if ('\0' == *(++wp))
+                               return(2);
+                       if ('\0' == *(wp + 1))
+                               return(3);
+
+                       *d = 'F' == set ? DECO_FFONT : DECO_FONT;
+                       *sz = 2;
+                       *word = wp;
+                       return(4);
+               case ('['):
+                       *word = ++wp;
+                       for (j = 0; *wp && ']' != *wp; wp++, j++)
+                               /* Loop... */ ;
+
+                       if ('\0' == *wp)
+                               return(j + 2);
+
+                       *d = 'F' == set ? DECO_FFONT : DECO_FONT;
+                       *sz = (size_t)j;
+                       return(j + 3);
+               default:
+                       break;
+               }
+
+               *d = 'F' == set ? DECO_FFONT : DECO_FONT;
+               *sz = 1;
+               *word = wp;
+               return(2);
+
+       case ('*'):
+               switch (*(++wp)) {
+               case ('\0'):
+                       return(1);
+
+               case ('('):
+                       if ('\0' == *(++wp))
+                               return(2);
+                       if ('\0' == *(wp + 1))
+                               return(3);
+
+                       *d = DECO_RESERVED;
+                       *sz = 2;
+                       *word = wp;
+                       return(4);
+
+               case ('['):
+                       *word = ++wp;
+                       for (j = 0; *wp && ']' != *wp; wp++, j++)
+                               /* Loop... */ ;
+
+                       if ('\0' == *wp)
+                               return(j + 2);
+
+                       *d = DECO_RESERVED;
+                       *sz = (size_t)j;
+                       return(j + 3);
+
+               default:
+                       break;
+               }
+
+               *d = DECO_RESERVED;
+               *sz = 1;
+               *word = wp;
+               return(2);
+
+       case ('s'):
+               sp = wp;
+               if ('\0' == *(++wp))
+                       return(1);
+
+               C2LIM(*wp, lim);
+               C2TERM(*wp, term);
+
+               if (term) 
+                       wp++;
+
+               *word = wp;
+
+               if (*wp == '+' || *wp == '-')
+                       ++wp;
+
+               switch (*wp) {
+               case ('\''):
+                       /* FALLTHROUGH */
+               case ('['):
+                       /* FALLTHROUGH */
+               case ('('):
+                       if (term) 
+                               return((int)(wp - sp));
+
+                       C2LIM(*wp, lim);
+                       C2TERM(*wp, term);
+                       wp++;
+                       break;
+               default:
+                       break;
+               }
+
+               if ( ! isdigit((u_char)*wp))
+                       return((int)(wp - sp));
+
+               for (j = 0; isdigit((u_char)*wp); j++) {
+                       if (lim && j >= lim)
+                               break;
+                       ++wp;
+               }
+
+               if (term && term < 3) {
+                       if (1 == term && *wp != '\'')
+                               return((int)(wp - sp));
+                       if (2 == term && *wp != ']')
+                               return((int)(wp - sp));
+                       ++wp;
+               }
+
+               *d = DECO_SIZE;
+               return((int)(wp - sp));
+
+       case ('['):
+               *word = ++wp;
+
+               for (j = 0; *wp && ']' != *wp; wp++, j++)
+                       /* Loop... */ ;
+
+               if ('\0' == *wp)
+                       return(j + 1);
+
+               *d = DECO_SPECIAL;
+               *sz = (size_t)j;
+               return(j + 2);
+
+       case ('c'):
+               *d = DECO_NOSPACE;
+               *sz = 1;
+               return(1);
+
+       default:
+               break;
+       }
+
+       *d = DECO_SPECIAL;
+       *word = wp;
+       *sz = 1;
+       return(1);
+}