=================================================================== RCS file: /cvs/pod2mdoc/pod2mdoc.c,v retrieving revision 1.5 retrieving revision 1.6 diff -u -p -r1.5 -r1.6 --- pod2mdoc/pod2mdoc.c 2014/03/23 13:00:24 1.5 +++ pod2mdoc/pod2mdoc.c 2014/03/23 23:23:38 1.6 @@ -1,4 +1,4 @@ -/* $Id: pod2mdoc.c,v 1.5 2014/03/23 13:00:24 kristaps Exp $ */ +/* $Id: pod2mdoc.c,v 1.6 2014/03/23 23:23:38 kristaps Exp $ */ /* * Copyright (c) 2014 Kristaps Dzonsons * @@ -108,6 +108,8 @@ static const char fmts[FMT__MAX] = { 'Z' /* FMT_NULL */ }; +static int last; + /* * Given buf[*start] is at the start of an escape name, read til the end * of the escape ('>') then try to do something with it. @@ -141,7 +143,7 @@ formatescape(const char *buf, size_t *start, size_t en * TODO: right now, we only recognise the named escapes. * Just let the rest of them go. */ - if (0 == strcmp(esc, "lt")) + if (0 == strcmp(esc, "lt")) printf("\\(la"); else if (0 == strcmp(esc, "gt")) printf("\\(ra"); @@ -149,6 +151,10 @@ formatescape(const char *buf, size_t *start, size_t en printf("\\(ba"); else if (0 == strcmp(esc, "sol")) printf("\\(sl"); + else + return; + + last = 'a'; } /* @@ -172,13 +178,15 @@ skipspace(const char *buf, size_t *start, size_t end) * the end of matched production. * If "reentrant", then we're being called after a macro has already * been printed to the current line. - * "last" is set to the last read character: this is used to determine - * whether we should buffer with space or not. - * If "nomacro", then we don't print any macros, just contained data. + * If "nomacro", then we don't print any macros, just contained data + * (e.g., following "Sh" or "Nm"). + * Return whether we've printed a macro or not--in other words, whether + * this should trigger a subsequent newline (this should be ignored when + * reentrant). */ static int formatcode(const char *buf, size_t *start, - size_t end, int reentrant, int last, int nomacro) + size_t end, int reentrant, int nomacro) { enum fmt fmt; size_t i, j, dsz; @@ -186,6 +194,19 @@ formatcode(const char *buf, size_t *start, assert(*start + 1 < end); assert('<' == buf[*start + 1]); + /* + * First, look up the format code. + * If it's not valid, then exit immediately. + */ + for (fmt = 0; fmt < FMT__MAX; fmt++) + if (buf[*start] == fmts[fmt]) + break; + + if (FMT__MAX == fmt) { + putchar(last = buf[(*start)++]); + return(0); + } + /* * Determine whether we're overriding our delimiter. * According to POD, if we have more than one '<' followed by a @@ -201,33 +222,21 @@ formatcode(const char *buf, size_t *start, if (dsz > 1 && (i >= end || ' ' != buf[i])) dsz = 1; - for (fmt = 0; fmt < FMT__MAX; fmt++) - if (buf[*start] == fmts[fmt]) - break; - - /* Invalid macros are just regular text. */ - - if (FMT__MAX == fmt) { - putchar(buf[*start]); - (*start)++; - return(0); - } - /* Remember, if dsz>1, to jump the trailing space. */ *start += dsz + 1 + (dsz > 1 ? 1 : 0); /* - * Escapes don't print macro sequences, so just output them like - * normal text before processing for macros. + * Escapes and ignored codes (NULL and INDEX) don't print macro + * sequences, so just output them like normal text before + * processing for real macros. */ if (FMT_ESCAPE == fmt) { formatescape(buf, start, end); return(0); } else if (FMT_NULL == fmt || FMT_INDEX == fmt) { /* - * For indices and nulls, just consume. - * Be wary of encountering custom delimiters (dsz>1), - * which require special handling. + * Just consume til the end delimiter, accounting for + * whether it's a custom one. */ for ( ; *start < end; (*start)++) { if ('>' != buf[*start]) @@ -249,6 +258,10 @@ formatcode(const char *buf, size_t *start, return(0); } + /* + * Check whether we're supposed to print macro stuff (this is + * suppressed in, e.g., "Nm" and "Sh" macros). + */ if ( ! nomacro) { /* * Print out the macro describing this format code. @@ -257,19 +270,21 @@ formatcode(const char *buf, size_t *start, * indicator. * Otherwise, offset us with a space. */ - if ( ! reentrant && last != '\n') - putchar('\n'); - if ( ! reentrant) + if ( ! reentrant) { + if (last != '\n') + putchar('\n'); putchar('.'); - else + } else putchar(' '); /* - * If we don't have whitespace before us, then suppress - * macro whitespace with Ns. + * If we don't have whitespace before us (and none after + * the opening delimiter), then suppress macro + * whitespace with Pf. */ - if (' ' != last) - printf("Ns "); + if (' ' != last && '\n' != last && ' ' != buf[*start]) + printf("Pf "); + switch (fmt) { case (FMT_ITALIC): printf("Em "); @@ -296,7 +311,7 @@ formatcode(const char *buf, size_t *start, } /* - * Read until we reach the end market (e.g., '>') or until we + * Process until we reach the end marker (e.g., '>') or until we * find a nested format code. * Don't emit any newlines: since we're on a macro line, we * don't want to break the line. @@ -323,7 +338,7 @@ formatcode(const char *buf, size_t *start, } } if (*start + 1 < end && '<' == buf[*start + 1]) { - formatcode(buf, start, end, 1, last, nomacro); + formatcode(buf, start, end, 1, nomacro); continue; } @@ -343,43 +358,30 @@ formatcode(const char *buf, size_t *start, printf("\\&"); /* Suppress newline. */ - if ('\n' == (last = buf[(*start)++])) - last = ' '; + if ('\n' == buf[*start]) + putchar(last = ' '); + else + putchar(last = buf[*start]); - putchar(last); + (*start)++; + + if (' ' == last) + while (*start < end && ' ' == buf[*start]) + (*start)++; } if ( ! nomacro && FMT_CODE == fmt) printf(" Qc "); - if (reentrant) - return(1); - - /* FIXME: with the "Qc", this doens't work good. */ - /* - * If we're not reentrant, we want to put ending punctuation on - * the macro line so that it's properly handled by being - * smooshed against the terminal word. + * We're now subsequent the format code. + * If there isn't a space (or newline) here, and we haven't just + * printed a space, then suppress space. */ - skipspace(buf, start, end); + if ( ! nomacro && ' ' != last) + if (' ' != buf[*start] && '\n' != buf[*start]) + printf(" Ns "); - if (',' != buf[*start] && '.' != buf[*start] && - '!' != buf[*start] && '?' != buf[*start] && - ')' != buf[*start]) - return(1); - while (*start < end) { - if (',' != buf[*start] && - '.' != buf[*start] && - '!' != buf[*start] && - '?' != buf[*start] && - ')' != buf[*start]) - break; - putchar(' '); - putchar(buf[*start]); - (*start)++; - } - skipspace(buf, start, end); return(1); } @@ -389,12 +391,11 @@ formatcode(const char *buf, size_t *start, static void formatcodeln(const char *buf, size_t *start, size_t end, int nomacro) { - int last; last = ' '; while (*start < end) { if (*start + 1 < end && '<' == buf[*start + 1]) { - formatcode(buf, start, end, 1, last, nomacro); + formatcode(buf, start, end, 1, nomacro); continue; } /* @@ -534,6 +535,14 @@ command(struct state *st, const char *buf, size_t star st->lstack[st->lpos - 1] = LIST__MAX; break; case (CMD_ITEM): + if (0 == st->lpos) { + /* + * Bad markup. + * Try to compensate. + */ + st->lstack[st->lpos] = LIST__MAX; + st->lpos++; + } assert(st->lpos > 0); /* * If we're the first =item, guess at what our content @@ -635,7 +644,6 @@ verbatim(struct state *st, const char *buf, size_t sta static void ordinary(struct state *st, const char *buf, size_t start, size_t end) { - int last; size_t i, j; if ( ! st->parsing || st->paused) @@ -699,8 +707,11 @@ ordinary(struct state *st, const char *buf, size_t sta * Then print the (possibly nested) macros and * following that, a newline. */ - if (formatcode(buf, &start, end, 0, last, 0)) + if (formatcode(buf, &start, end, 0, 0)) { putchar(last = '\n'); + while (start < end && ' ' == buf[start]) + start++; + } } else if (start < end && '\n' == buf[start]) { /* * Print the newline only if we haven't already