Logo Search packages:      
Sourcecode: bibclean version File versions  Download package

fix.c

#include <config.h>
#include "xctype.h"
#include "xstring.h"

RCSID("$Id: fix.c,v 1.6 1999/05/20 13:36:45 beebe Exp beebe $")

#include "yesorno.h"
#include "token.h"

#define SKIP_SPACE(p)   while (isspace((unsigned char)*p)) ++p

typedef struct s_name_pair
{
    const char *old_name;
    const char *new_name;
} NAME_PAIR;

extern char current_value[];  /* string value */
extern YESorNO    fix_font_changes;       /* brace {\em E. Coli}? */
extern YESorNO    fix_initials;           /* reformat A.U. Thor?  */
extern YESorNO    fix_names;        /* reformat Bach, P.D.Q? */
extern NAME_PAIR month_pair[];
extern YESorNO    Scribe;                 /* Scribe format input */

extern YESorNO    check_junior ARGS((const char *last_name_));
extern void check_length ARGS((size_t n_));
extern char shared_string[MAX_TOKEN_SIZE];

static void brace_font_changes ARGS((void));
char        *fix_author ARGS((char *author_));
void        fix_month ARGS((void));
void        fix_namelist ARGS((void));
void        fix_pages ARGS((void));
char        *fix_periods ARGS((char *author_));
void        fix_title ARGS((void));
static const char *month_token ARGS((const char *s_, size_t *p_len_));


static void
brace_font_changes(VOID)
{
    int b_level;              /* brace level */
    size_t k;                       /* index into current_value[] */
    size_t m;                       /* index into s[] */
    YESorNO need_close_brace;
    char *p;                        /* pointer into current_value[] */
    char *s = shared_string;        /* memory-saving device */

    /*******************************************************************
      If the user has coded a title string like

      "Signal-transducing {G} proteins in {\em Dictyostelium Discoideum}"

      or

      "Signal-transducing {G} proteins in {\em {D}ictyostelium {D}iscoideum}"

      BibTeX styles that downcase titles will downcase the name
      Dictyostelium Discoideum, even WITH the protecting braces around
      the D's.  The solution offered by this function is to rewrite
      the title string as

      "Signal-transducing {G} proteins in {{\em Dictyostelium Discoideum}}"

      This action cannot be taken without forethought, because there
      are many cases where the downcasing inside font changes is
      consistent, so the default run-time option is -no-fix-font-changes.

    *******************************************************************/

    for (b_level = 0, k = 0, m = 0, need_close_brace = NO;
       current_value[k] ; ++k, ++m)
    {
      switch (current_value[k])
      {
      case '{':               /* '}' for balance */
          b_level++;
          if (b_level == 1)
          {
            p = &current_value[k+1];
            SKIP_SPACE(p);
            if (*p == '{')          /* '}' for balance */
                break;        /* already have extra brace level */
            if (
                (strncmp(p,"\\bf",3) == 0) ||
                (strncmp(p,"\\em",3) == 0) ||
                (strncmp(p,"\\it",3) == 0) ||
                (strncmp(p,"\\rm",3) == 0) ||
                (strncmp(p,"\\sf",3) == 0) ||
                (strncmp(p,"\\sl",3) == 0) ||
                (strncmp(p,"\\tt",3) == 0) )
            {
                s[m++] = '{'; /* '}' for balance */
                need_close_brace = YES;
            }
          }
          break;
                  /* '{' for balance */
      case '}':
          if ((b_level == 1) && (need_close_brace == YES))
          {                   /* '{' for balance */
            s[m++] = '}';
            need_close_brace = NO;
          }
          b_level--;
          break;

      default:
          break;
      }
      s[m] = current_value[k];
    }
    s[m] = '\0';              /* terminate collected string */
    (void)strcpy(current_value, s);
}


#if defined(HAVE_STDC)
char *                        /* normalize author names and return */
fix_author(char *author)      /* new string from static space */
#else /* K&R style */
char *
fix_author(author)            /* normalize author names and return */
char *author;                 /* new string from static space */
#endif
{
    size_t a;                 /* index into author[] */
    int b_level;        /* brace level */
    char *p;                  /* pointer into author[] */
    char *pcomma;       /* pointer to last unbraced comma in author[] */
    static char s[MAX_TOKEN_SIZE]; /* returned to caller */

    /* Convert "Smith, J.K." to "J. K. Smith" provided "," and "." are */
    /* at brace level 0 */

    if (fix_names == NO)
      return (author);

    /* Leave untouched entries like: */
    /* author = "P. D. Q. Bach (113 MozartStrasse, Vienna, Austria)" */
    if (strchr(author,'(') != (char*)NULL)
      return (author);

    /*******************************************************************
      We now have a tricky job.  Some names have additional parts,
      which BibTeX calls "von" and "Jr.".  It permits them to be input
      as (see L. Lamport, ``LaTeX User's Guide and Reference Manual'',
      pp. 141--142)

            Brinch Hansen, Per      OR    Per {Brinch Hansen}
            Ford, Jr., Henry  OR    Henry {Ford, Jr.}
            {Steele Jr.}, Guy L.    OR    Guy L. {Steele Jr.}
            von Beethoven, Ludwig   OR    Ludwig von Beethoven
            {von Beethoven}, Ludwig OR    Ludwig {von Beethoven}

      The last two lines are NOT equivalent; the first will be
      alphabetized under Beethoven, and the second under von.

      Other examples include names like

            Charles XII, King OR    King Charles XII
            Ford, Sr., Henry  OR    Henry {Ford, Sr.}
            Vallee Poussin, C. L. X. J. de la   OR
                  C. L. X. J. de la Vallee Poussin
            van der Waerden, Bartel Leendert    OR
                  Bartel Leendert van der Waerden

      These transformations conform to the general patterns

            B, A        -->   A B
            B C, A            -->   A B C       (von case)
            B C, A            -->   A {B C}           (Brinch Hansen case)
            B, C, A           -->   A {B, C}    (Jr. case)

      A, B, and C represent one or more space-separated words, or
      brace-delimited strings with arbitrary contents.

      Notice the conflict: the von case differs from Brinch Hansen in
      that braces may NOT be inserted when the name is reordered,
      because this changes the alphabetization.

      In order to deal with this ambiguity, we supply braces in the
      "B C, A" case ONLY when the C part matches something like Jr
      (see the juniors[] table above), or when it looks like a small
      number in Roman numerals.  The latter case is uncommon, and we
      therefore don't bother to attempt to parse it to determine
      whether it is a valid number.

      The "B, C, A" case (multiple level-zero commas) is unambiguous,
      and can be converted to the form "A {B, C}".
    *******************************************************************/

    for (a = 0, b_level = 0, pcomma = (char*)NULL; author[a]; ++a)
    {                   /* convert "Smith, John" to "John Smith" */
      switch (author[a])
      {
      case '{':
          b_level++;
          break;

      case '}':
          b_level--;
          break;

      case ',':
          if (b_level == 0)
            pcomma = &author[a];    /* remember last unbraced comma */
          break;

      default:
          break;
      }
    }
    if (pcomma == (char*)NULL)            /* no commas, so nothing more to do */
      return (author);

    *pcomma = '\0';                 /* terminate "Smith" */

    /* have "Smith, J.K." or "Smith, Jr., J.K." */
    p = pcomma + 1;
    SKIP_SPACE(p);
    (void)strcpy(s,p);              /* s <- "J.K." */
    (void)strcat(s," ");            /* s <- "J.K. " */

    if (check_junior(author) == YES)
    {
      (void)strcat(s,"{");
      (void)strcat(s,author);       /* s <- "J.K. {Smith, Jr.}" */
      (void)strcat(s,"}");
    }
    else
      (void)strcat(s,author);       /* s <- "J.K. Smith" */

    return (strcpy(author,s));
}


void
fix_month(VOID)               /* convert full month names to macros*/
{                       /* for better style-file customization */
    size_t k;                       /* index into month_pair[] and s[] */
    size_t token_length;            /* token length */
    const char *p;                  /* pointer to current_value[] */
    char *s = shared_string;        /* memory-saving device */
    const char *token;              /* pointer into current_value[] */

    for (p = current_value;
       (token = month_token(p,&token_length)) != (const char*)NULL;
       p = (const char*)NULL)
    {
      if (token_length == 1)        /* just copy single-char tokens      */
         *s++ = *token;
      else
      {
          for (k = 0; month_pair[k].old_name != (const char*)NULL; ++k)
          {
            if ((strlen(month_pair[k].old_name) == token_length) &&
                (strnicmp(month_pair[k].old_name,token,token_length) == 0))
            {                 /* change "January" to jan etc. */
                (void)strcpy(s,"\" # ");
                if ((s >= (shared_string + 1)) &&
                  (strncmp(s-1,"\"\" # ",5) == 0))
                { /* eliminate any concatenation with an empty string */
                  s--;
                  *s = '\0';  /* need string terminator for strcat() */
                }
                (void)strcat(s,month_pair[k].new_name);
                (void)strcat(s," # \"");
                s = strchr(s,'\0');
                token_length = 0;   /* so we don't copy twice at loop end */
                break;        /* exit loop after first substitution */
            }
          }                   /* end for (k = 0, ...) */
          (void)strncpy(s,token,token_length); /* no definition, just copy */
          s += token_length;
      }
      if ((s >= (shared_string + 5)) && (strncmp(s-5," # \"\"",5) == 0))
          s -= 5; /* eliminate any concatenation with an empty string */
    }
    *s = '\0';                      /* supply string terminator */
    k = (size_t)(s - shared_string);
    s = shared_string;
    if (strncmp(s,"\"\" # ",5) == 0)
      (void)strcpy(current_value,&s[5]); /* discard initial empty string */
    else
      (void)strcpy(current_value,s);
}


void
fix_namelist(VOID)            /* normalize list of personal names */
{                       /* leaving it in global current_value[] */
    size_t m;                 /* index of start of author in current_value[]*/
    size_t n;                 /* length of current_value[], less 1 */
    char namelist[MAX_TOKEN_SIZE];  /* working copy of current_value[] */
    size_t v;                 /* loop index into current_value[] */

    /* Convert "Smith, J.K. and Brown, P.M." to */
    /* "J. K. Smith and P. M. Brown" */
    /* We loop over names separated by " and ", and hand each off */
    /* to fix_author() */

    n = strlen(current_value) - 1;  /* namelist = "\"...\"" */

    if ((current_value[0] != '"') ||
      (current_value[n] != '"')) /* sanity check */
      return;                 /* not quoted string, may be macro */

    (void)strcpy(namelist,"\"");/* supply initial quotation mark */
    current_value[n] = (char)'\0';  /* clobber final quotation mark */
    for (v = 1, m = 1; v < n; ++v) /* start past initial quotation mark */
    {
      if (strncmp(" and ",&current_value[v],5) == 0)
      {
          current_value[v] = (char)'\0';
          (void)strcat(namelist,fix_periods(fix_author(&current_value[m])));
          (void)strcat(namelist," and ");
          current_value[v] = (char)' ';
          v += 4;
          m = v + 1;
      }
      else if ((Scribe == YES) && (current_value[v] == ';'))
      {                       /* expand semicolons to " and " */
          current_value[v] = (char)'\0';
          (void)strcat(namelist,fix_periods(fix_author(&current_value[m])));
          (void)strcat(namelist," and ");
          current_value[v] = (char)' ';
          m = v + 1;
      }
    }
    (void)strcat(namelist,fix_periods(fix_author(&current_value[m])));
                              /* handle last author */
    (void)strcat(namelist,"\"");    /* supply final quotation mark */
    (void)strcpy(current_value,namelist);
}


void
fix_pages(VOID)
{
    size_t k;                 /* index into current_value[] */
    size_t m;                 /* index into new_value[] */
    char new_value[MAX_TOKEN_SIZE]; /* working copy of new_value[] */
    char last_char;

    last_char = ' ';
    for (m = 0, k = 0; current_value[k]; ++k)
    {                   /* squeeze out spaces around hyphens */
                        /* and convert hyphen runs to en-dashes */
      if (current_value[k] == '-')
      {                 /* convert hyphens to en-dash */
          for ( ; (m > 0) && Isspace(new_value[m-1]) ; )
            --m;        /* discard preceding spaces */
          for ( ; current_value[k+1] == '-'; )
            ++k;
          for ( ; Isspace(current_value[k+1]); )
            ++k;        /* discard following spaces */
          new_value[m++] = (char)'-'; /* save an en-dash */
          /* [04-Mar-1996] force en-dash between digit pairs,
             alpha pairs, and digit-alpha pairs, but not otherwise,
             so ``pages = "A-3-A-7"'' is converted to
             ``pages = "A-3--A-7"''. */
          if ((Isdigit(last_char) && Isdigit(current_value[k+1])) ||
              (Isalpha(last_char) && Isalpha(current_value[k+1])) ||
              (Isdigit(last_char) && Isalpha(current_value[k+1])) ||
            (current_value[k+1] == '?'))
            new_value[m++] = (char)'-';
      }
      else
      {
          new_value[m++] = current_value[k];
          if (!Isspace(current_value[k])) /* remember last non-blank non-hyphen char */
            last_char = current_value[k];
      }
    }
    new_value[m] = (char)'\0';
    (void)strcpy(current_value,new_value);
}


#if defined(HAVE_STDC)
char *
fix_periods(char *author)
#else /* K&R style */
char *
fix_periods(author)
char *author;
#endif
{
    int b_level;              /* brace level */
    size_t a;                       /* index in author[] */
    size_t n;                       /* index in name[] */
    char *name = shared_string;           /* memory-saving device */

    if (fix_initials == NO)
      return author;

    /* Convert "J.K. Smith" to "J. K. Smith" if "." at brace level 0 */

    for (b_level = 0, a = 0, n = 0; /* NO-OP (exit below) */ ; ++a, ++n)
    {
      name[n] = author[a];          /* copy character */
      if (author[a] == '\0')
          break;              /* here's the loop exit */
      switch (author[a])
      {
      case '{':
          b_level++;
          break;

      case '}':
          b_level--;
          break;

      case '.':
          if (b_level == 0)
          {
            if ((a > 0) && Isupper(author[a-1]) && Isupper(author[a+1]))
                name[++n] = (char)' '; /* supply space between initials */
          }
          break;
      }
    }
    return (name);
}


void
fix_title(VOID)                     /* protect upper-case acronyms */
{
    YESorNO brace_letter;
    int b_level;              /* brace level */
    size_t k;                       /* index into s[] */
    char *s = shared_string;        /* memory-saving device */
    size_t t;                       /* index into title[] */

    if (current_value[0] != '\"')
      return;                             /* leave macros alone */

    for (k = 0, b_level = 0, t = 0; current_value[t]; )
    {
      switch (current_value[t])
      {
      case '{':
          b_level++;
          s[k++] = current_value[t++];
          break;

      case '}':
          b_level--;
          s[k++] = current_value[t++];
          break;

      default:
          if (b_level > 0)
            brace_letter = NO;      /* already braced, so no changes */
          else if (Isupper(current_value[t]))   /* maybe brace <upper-case>+ */
          {                   /* or <upper-case><digits> */
            if (Isupper(current_value[t+1]) || Isdigit(current_value[t+1]))
                brace_letter = YES; /* XY -> {XY}, X11 -> {X11} */
            else if (!Isalpha(current_value[t+1]))
            {
                if ((t == 1) && (current_value[t] == 'A'))
                  brace_letter = NO; /* "A gnat" -> "A gnat" */
                else
                  brace_letter = YES; /* "The C book" -> "The {C} Book" */
            }
            else
                brace_letter = NO;  /* everything else unchanged */
          }
          else if (current_value[t] == '\\') /* TeX control word? */
          {
            size_t n;
            size_t nupper;

            for (nupper = 0, n = t + 1; Isalpha(current_value[n]); ++n)
            {                 /* scan over control word */
                if (Isupper(current_value[n]))
                  nupper++;
            }
            if (n > (t + 1))  /* then saw control word */
            {
                if (nupper > 0)     /* then saw upper case letters */
                {             /* so must brace control word */
                  s[k++] = (char)'{';
                  while (t < n)
                      s[k++] = current_value[t++];
                  s[k++] = (char)'}';
                  if ((current_value[t] == '{') &&
                      (current_value[t+1] == '}'))
                      t += 2; /* \TeX{} -> {\TeX} */
                  else if ((current_value[t] == '\\') &&
                      (current_value[t+1] == ' '))
                      t++;    /* \TeX<space> -> {\TeX}<space> */
                  break;            /* jump out of switch() */
                }
            }
            brace_letter = NO;
          }
          else
            brace_letter = NO;
          if (brace_letter)
          {             /* Convert XWS to {XWS} and X11 to {X11} */
            s[k++] = (char)'{';
            while (Isupper(current_value[t]) || Isdigit(current_value[t]))
                s[k++] = current_value[t++];
            s[k++] = (char)'}';
          }
          else
            s[k++] = current_value[t++];
          break;
      }
    }
    s[k] = (char)'\0';
    check_length(k);
    (void)strcpy(current_value,s);
    if (fix_font_changes == YES)
      brace_font_changes();
}


#if defined(HAVE_STDC)
static const char *
month_token(const char *s, size_t *p_len)
#else /* K&R style */
static const char *
month_token(s, p_len)
const char *s;
size_t *p_len;
#endif
{   /* Return pointer to next token in s[], with its length in *p_len */
    /* if s is NULL, the parsing continues from where it was last. */
    /* A token is either a sequence of letters, possibly with a terminal */
    /* period, or else a single character.   Outside quoted strings, all */
    /* characters are considered non-letters. This code is vaguely modelled */
    /* on Standard C's strtok() function. */

    /* Bug fix for version 2.11.4 [09-May-1998]:  Prior to this version,
       a value

           mar # "\slash" # apr

       would be incorrectly transformed

           month = mar # "\slash" # " # apr # "

       because in_quoted_string was incorrect for the remainder of
       the value.

       If the input value was changed to

           mar # "\slash " # apr

       then that space inside the quoted string preserved the
       correctness of in_quoted_string, and the output was correct.

       For version 2.11.4, the body of this function has been entirely
       rewritten to simplify the logic, and ensure its correctness. */

    static int b_level = 0;         /* remembered across calls */
    static YESorNO in_quoted_string = NO; /* remembered across calls */
    static const char *next = (const char *)NULL; /* remembered across calls */
    const char *token;              /* pointer to returned token */

    if (s != (const char*)NULL)           /* do we have a new s[]? */
    {
      next = s;               /* yes, remember it */
      b_level = 0;                  /* and reinitialize state */
      in_quoted_string = NO;        /* variables */
    }

    *p_len = 0;
    token = next;

    switch (*next)
    {
    case '"':
      if (b_level == 0)
          in_quoted_string = (in_quoted_string == YES) ? NO : YES;
      break;

    case '{':                       /* '}' for brace balance */
      b_level++;
      break;
                              /* '{' for brace balance */
    case '}':
      b_level--;
      break;

    default:
      break;
    }

#define ADVANCE ((*p_len)++, next++)

    if ((in_quoted_string == YES) && Isalpha(*next))
    {             /* collect possibly-dot-terminated alphabetic token */
      while (Isalpha(*next))
          ADVANCE;
      if (*next == '.')
          ADVANCE;
    }
    else if (*next != '\0')         /* collect single-character token */
      ADVANCE;

#undef ADVANCE

    return ((*p_len == 0) ? (const char*)NULL : token);
}

Generated by  Doxygen 1.6.0   Back to index