xref: /csrg-svn/contrib/bib/src/bibargs.c (revision 60507)

#ifndef lint
static char sccsid[] = "@(#)bibargs.c	2.13	05/27/93";
#endif not lint
/*
        Authored by: Tim Budd, University of Arizona, 1983.
                version 7/4/83

        Various modifications suggested by:
                David Cherveny - Duke University Medical Center
                Phil Garrison - UC Berkeley
                M. J. Hawley - Yale University


	       version 8/23/1988

	 Adapted to use TiB style macro calls (i.e. |macro|)
	       A. Dain Samples




        read argument strings for bib and listrefs
        do name formatting, printing lines, other actions common to both
                                                        */
# include <stdio.h>
# include <ctype.h>
# include "bib.h"
# define LINELENGTH 1024
# define MAXDEFS     500             /* maximum number of defined words */

/* global variables */
   char bibfname[120];          /* file name currently being read            */
   int  biblineno;              /* line number currently being referenced    */
   int  abbrev       = false;   /* automatically abbreviate names            */
   int  capsmcap     = false;   /* print names in caps small caps (CACM form)*/
   int  TibOption    = false;   /* expect files in TiB format                */
   int	TibxOption   = false;   /* to create files for bib2tib               */
   int  numrev       = 0;       /* number of authors names to reverse        */
   int  edabbrev     = false;   /* abbreviate editors names ?                */
   int  edcapsmcap   = false;   /* print editors in cap small caps           */
   int  ednumrev     = 0;       /* number of editors to reverse              */
   int	max_klen     = 6;	/* max size of key			     */
   int  sort         = false;   /* sort references ? (default no)            */
   int  foot         = false;   /* footnoted references ? (default endnotes) */
   int  doacite      = true;    /* place citations ?                         */
   int	redefWarning = false;	/* warnings on attempted redefs ?	     */
   int  hyphen       = false;   /* hypenate contiguous references            */
   int  ordcite      = true;    /* order multiple citations                  */
   char sortstr[80]  = "1";     /* sorting template                          */
   char trailstr[80] = "";      /* trailing characters to output             */
   char pfile[400];             /* private file name                         */
   int  personal = false;       /* personal file given ? (default no)        */
   char citetemplate[80] = "1"; /* citation template                         */
   struct wordinfo words[MAXDEFS];     /* defined words */
   struct wordinfo *wordhash[HASHSIZE];
   struct wordinfo *wordsearch();
   int  wordtop = 0;           /* number of defined words         */
   char letterSeen[128];   /* keeps track of keyletters
		       * so we know whether to emit a .ds
		       * or a .as
		      /* */

/* where output goes */
   extern FILE *tfd;
/* reference file information */
   extern struct refinfo refinfo[];
   extern char reffile[];
#ifndef INCORE
   extern FILE *rfd;
#endif not INCORE
   extern int numrefs;
   extern char *programName;

char *usageArr[] = {
"-aa    abbreviate authors' first names",
"-arN   reverse first N authors' names; no N, do all",
"-ax    print authors' last names in Caps-Small",
"-cS    use template S for citations",
"-d	change the default directory",
"-ea    abbreviate editors' first names",
"-ex    print editors' last names in Caps-Small",
"-erN   reverse first N editors' names; no N, do all",
"-f     dump reference after citation for footnotes",
"-iFILE process FILE (e.g. a file of definitions)",
"-h     hyphenate sequences of citations (turns on -o)",
"-nS    turn off options; S is composed of the option letters 'afhosx'",
"-pFILE search these FILEs (comma separated list) instead of INDEX",
"-R	print warnings when duplicate definitions of names are ignored",
"-sS    sort references according to template S",
"-tTYPE use the style TYPE",
"-Tib   expect files to be in TiB format (which see)",
"-Tibx	write a file for converting bib to TiB-style |macros|",
"",
0
};

void
usageErr(argv0, opt, str)
    char *argv0;
    char *opt;
    char *str;
{
    char  **p;
    fprintf(stderr, "Illegal invocation of %s.  Acceptable options:\n",
                                            argv0);
    fprintf(stderr, "Argument: %s\n", opt);
    fprintf(stderr, "Problem:  %s\n", str);
    for (p = usageArr; *p != 0; p++) {
        fprintf(stderr, "    %s\n", *p);
        }
}

/* bibwarning - print out a warning message */
  /*VARARGS1*/
  bibwarning(msg, a1, a2)
  char *msg;
{
  fprintf(stderr,"%s: `%s', line %d: ", programName, bibfname, biblineno);
  fprintf(stderr, msg, a1, a2);
  fprintf(stderr, "\n");
}



/* doargs - read command argument line for both bib and listrefs
            set switch values
            call rdtext on file arguments, after dumping
            default style file if no alternative style is given
*/

   int doargs(argc, argv, defstyle)
   int argc;
   char **argv, defstyle[];
{  int numfiles, i, style;
   char *p, *q, *walloc();
   FILE *fd;

   numfiles = 0;
   style = true;
   TibxOption = false;
   newbibdir(BMACLIB);

   programName = argv[0];
   for (i = 1; i < argc; i++)
      if (argv[i][0] == '-')
         switch(argv[i][1]) {
            case 'a':  for (p = &argv[i][2]; *p; p++)
                          if (*p == 'a' || *p == 0)
                             abbrev = true;
                           else if (*p == 'x')
                             capsmcap = true;
                           else if (*p == 'r') {
                             if (*(p+1))
                                numrev = atoi(p+1);
                              else
                                numrev = 1000;
                              break;
                              }
                       break;

            case 'c':  if (argv[i][2] == 0)
                          error("citation string expected for 'c'");
                       else
                          for (p = citetemplate,q = &argv[i][2]; *p++ = *q++; );
                       break;

	    case 'd':  if (argv[i][2])
			    p = &argv[i][2];
		       else {  /* take next arg */
			    i++;
			    p = argv[i];
			    }
		       newbibdir(p);
		       break;

            case 'e':  for (p = &argv[i][2]; *p; p++)
                          if (*p == 'a')
                             edabbrev = true;
                           else if (*p == 'x')
                             edcapsmcap = true;
                           else if (*p == 'r') {
                             if (*(p+1))
                                ednumrev = atoi(p+1);
                              else
                                ednumrev = 1000;
                              break;
                              }
                       break;

            case 'f':  CASE_f:
		       foot = true;
                       hyphen = false;
                       break;

            case 'i':  CASE_i:
		       if (argv[i][2])
                          p = &argv[i][2];
                       else { /* take next arg */
                          i++;
                          p = argv[i];
                          }
                       incfile(p);
                       break;

	    case 'l':  if (argv[i][2]){
                          max_klen  = atoi(&argv[i][2]);
			  if (max_klen > REFSIZE)
			      error("too long key size");
		       } else {
			  error("-l needs a numeric value");
		       }
		       break;

            case 'h':  hyphen = ordcite = true;
                       break;

            case 'n':  for (p = &argv[i][2]; *p; p++)
                          if (*p == 'a')
                             abbrev = false;
                          else if (*p == 'f')
                             foot = false;
                          else if (*p == 'h')
                             hyphen = false;
                          else if (*p == 'o')
                             ordcite = false;
                          else if (*p == 'R')
                             redefWarning = false;
                          else if (*p == 'r')
                             numrev = 0;
                          else if (*p == 's')
                             sort = false;
                          else if (*p == 'x')
                             capsmcap = false;
                          else if (*p == 'v')
                             doacite = true;
                       break;

            case 'o':  ordcite = true;
                       break;

            case 'p':  if (argv[i][2])
                          p = &argv[i][2];
                       else {  /* take next arg */
                          i++;
                          p = argv[i];
                          }
                       strcpy(pfile, p);
                       personal = true;
                       break;

	    case 'R':  redefWarning = true;
		       break;

            case 'r':  if (argv[i][2] == 0)  /* synonym -ar */
                          numrev = 1000;
                       else
                          numrev = atoi(&argv[i][2]);
                       break;

            case 's':  sort = true;
                       if (argv[i][2])
                          for (p = sortstr,q = &argv[i][2]; *p++ = *q++; );
                       break;

            case 't':  style = false;
		       goto CASE_i;

	   case 'T':   if (strcmp("Tib", &(argv[i][1])) == 0)
			   TibOption = true;
		       else if (strcmp("Tibx",&(argv[i][1])) == 0)
			   TibxOption = true;
		       else {
			    usageErr(argv[0], argv[i],
				    "Did you want the Tib option?");
			    error("'%s' invalid switch", argv[i]);
			    }
		       break;

            case 'v':  doacite = false;
		       goto CASE_f;

            case 'x':  capsmcap = true; /* synonym for -ax */
                       break;

            case 0:    if (style) {  /* no style command given, take default */
                          style = false;
                          incfile( defstyle );
                          }
                       strcpy(bibfname,"<stdin>");
                       rdtext(stdin);
                       numfiles++;
                       break;

            default:   usageErr(argv[0], argv[i], "Invalid switch");
                       error("'%c' invalid switch", argv[i][1]);
            }
      else { /* file name */
         numfiles++;
         if (style) {
            style = false;
            incfile( defstyle );
            }
         fd = fopen(argv[i], "r");
         if (fd == NULL) {
            error("can't open file %s", argv[i]);
            }
         else {
            strcpy(bibfname, argv[i]);
            rdtext(fd);
            fclose(fd);
            }
         }

   if (style) incfile( defstyle );
   if (TibxOption) {
     /*
     Emits m4 macros that allow easy transformation of old bib-style
     bibliographic databases into tib-style.  The primary problem
     (although not the only one) is the change of |macro| calls.
      */
      reg struct wordinfo *wp;
      FILE *outf;
      outf = fopen("bib.m4.in","w");
      for (i=0; i<HASHSIZE; i++) {
	 for (wp = wordhash[i]; wp != NULL; wp = wp->wi_hp) {
	    fprintf(outf,"define(%s,|%s__m4_|)dnl\n",wp->wi_word,wp->wi_word);
	    }
	 }
      fclose(outf);
      }
   return(numfiles);

}

newbibdir(name)
	char *name;
{
   strreplace(COMFILE, BMACLIB, name);
   strreplace(DEFSTYLE, BMACLIB, name);
   strcpy(BMACLIB, name);
   wordrestuff("BMACLIB", BMACLIB);
   fprintf(tfd, ".ds l] %s\n", BMACLIB);
}

/* incfile - read in an included file  */
incfile(np)
   char *np;
{  char name[120];
   FILE *fd;
   char *p, line[LINELENGTH], dline[LINELENGTH], word[80], *tfgets();
   int  i, getwrd();

   strcpy(line, bibfname); /* temporary save in case of errors */
   /* first try ./<yourfile> */
      strcpy(bibfname, np);
      fd = fopen(bibfname, "r");
   /* try BMACLIB/<yourfile> */
   if (fd == NULL && *np != '/') {
      strcpy(name, BMACLIB); strcat(name, "/"); strcat(name, np);
      strcpy(bibfname, name);
      fd = fopen(bibfname, "r");
      }
   /* try BMACLIB/tibmacs/<yourfile> */
   if (TibOption && fd == NULL && *np != '/') {
      strcpy(name, BMACLIB); strcat(name, "/tibmacs/"); strcat(name, np);
      strcpy(bibfname, name);
      fd = fopen(bibfname, "r");
      }
   /* try BMACLIB/bibmacs/<yourfile> */
   if (!TibOption && fd == NULL && *np != '/') {
      strcpy(name, BMACLIB); strcat(name, "/bibmacs/"); strcat(name, np);
      strcpy(bibfname, name);
      fd = fopen(bibfname, "r");
      }
   /* try ./bib.<yourfile> */
   if (fd == NULL && *np != '/') {
      strcpy(name, "bib."); strcat(name, np);
      strcpy(bibfname, name);
      fd = fopen(bibfname, "r");
      }
   /* try BMACLIB/bib.<yourfile> */
   if (fd == NULL && *np != '/') {
      strcpy(name,BMACLIB); strcat(name, "/bib."); strcat(name, np);
      strcpy(bibfname, name);
      fd = fopen(bibfname, "r");
      }
   if (fd == NULL) {
      /* unsave old name */
      strcpy(bibfname, line);
      bibwarning("%s: can't find", np);
      exit(1);
      }

   /* now go off and process file */
   biblineno = 1;
   while (tfgets(line, LINELENGTH, fd) != NULL) {
      biblineno++;
      switch(line[0]) {

         case '#': break;

         case 'A': for (p = &line[1]; *p; p++)
                      if (*p == 'A' || *p == '\0')
                         abbrev = true;
                      else if (*p == 'X')
                         capsmcap = true;
                      else if (*p == 'R') {
                         if (*(p+1))
                            numrev = atoi(p+1);
                         else
                            numrev = 1000;
                         break;
                         }
                   break;

         case 'C': for (p = &line[1]; *p == ' '; p++) ;
                   strcpy(citetemplate, p);
                   break;

         case 'D': if ((i = getwrd(line, 1, word)) == 0)
                      error("word expected in definition");
		   if (wordsearch(word)) { /* already there-toss rest of def.*/
			if (redefWarning)
			   bibwarning("Attempted redefine of %s ignored.",word);
			while(line[strlen(line)-1] == '\\' ) {
                            if (tfgets(line, LINELENGTH, fd) == NULL) break;
			}
			break;
		   }
                   for (p = &line[i]; isspace(*p); p++) ;
                   for (strcpy(dline, p); dline[strlen(dline)-1] == '\\'; ){
                       dline[strlen(dline)-1] = '\n';
                       if (tfgets(line, LINELENGTH, fd) == NULL) break;
                       strcat(dline, line);
                       }
		   wordstuff(word, dline);
                   break;

         case 'E': for (p = &line[1]; *p; p++)
                      if (*p == 'A')
                         edabbrev = true;
                      else if (*p == 'X')
                         edcapsmcap = true;
                      else if (*p == 'R') {
                         if (*(p+1))
                            ednumrev = atoi(p+1);
                         else
                            ednumrev = 1000;
                         break;
                         }
                   break;

         case 'F': foot = true;
                   hyphen = false;
                   break;

         case 'I': for (p = &line[1]; *p == ' '; p++);
                   expand(p);
                   incfile(p);
                   break;

         case 'H': hyphen = ordcite = true;
                   break;

         case 'O': ordcite = true;
                   break;

         case 'R': if (line[1] == 0)  /* this is now replaced by AR */
                      numrev = 1000;
                   else
                      numrev = atoi(&line[1]);
                   break;

         case 'S': sort = true;
                   for (p = &line[1]; *p == ' '; p++) ;
                   strcpy(sortstr, p);
                   break;

         case 'T': for (p = &line[1]; *p == ' '; p++) ;
                   strcpy(trailstr, p);
                   break;

         case 'X': capsmcap = true;     /* this is now replace by AX */
                   break;

         default:  fprintf(tfd,"%s\n",line);
                   while (fgets(line, LINELENGTH, fd) != NULL)
                      fputs(line, tfd);
                   return;
         }

   }
   /* close up */
   fclose(fd);
}

/* error - report unrecoverable error message */
  /*VARARGS1*/
  error(str, a1, a2)
  char *str;
{
  bibwarning(str, a1, a2);
  /*
   *	clean up temp files and exit
   */
  cleanup(1);
}

#ifndef INCORE
#ifdef READWRITE
/*
** fixrfd( mode ) -- re-opens the rfd file to be read or write,
**      depending on the mode.  Uses a static int to save the current mode
**      and avoid unnecessary re-openings.
*/
fixrfd( mode )
register int mode;
{
	static int cur_mode = WRITE;    /* rfd open for writing initially */

	if (mode != cur_mode)
	{
		rfd = freopen(reffile, ((mode == READ)? "r" : "a"), rfd);
		cur_mode = mode;
		if (rfd == NULL)
		      error("Hell!  Couldn't re-open reference file %s",
			reffile);
	}
}
#endif
#endif not INCORE


/* tfgets - fgets which trims off newline */
   char *tfgets(line, n, ptr)
   char line[];
   int  n;
   FILE *ptr;
{  reg char *p;

   p = fgets(line, n, ptr);
   if (p == NULL)
      return(NULL);
   else
      for (p = line; *p; p++)
         if (*p == '\n')
            *p = 0;
   return(line);
}

/* getwrd - place next word from in[i] into out */
int getwrd(in, i, out)
   reg char in[], out[];
   reg int i;
{  int j;

   j = 0;
   while (isspace(in[i]))
      i++;
   if (in[i] != '\0')
      while (in[i]  != '\0' && !isspace(in[i]))
         out[j++] = in[i++];
   else
      i = 0;    /* signals end of in[i..]   */
   out[j] = 0;
   return (i);
}

/* walloc - allocate enough space for a word */
char *walloc(word)
   char *word;
{  char *i, *malloc();
   i = malloc(1 + strlen(word));
   if (i == NULL)
      error("out of storage");
   strcpy(i, word);
   return(i);
}

/* isword - see if character is legit word char */
#define iswordc(c) (isalnum(c) || c == '&' || c == '_')

   expand(line)
   char *line;
{  char line2[REFSIZE], word[REFSIZE];
   reg	struct wordinfo *wp;
   reg	char *p, *q, *w;

   q = line2;
   if (TibOption) {
      /* expand only macro names in |name| vertical bars; name must exist */
      for (p = line; *p != '\0'; /* VOID */ ) {
	 if (*p == '|') {
	    p++;
	    w = word;
	    while (*p != '|' && *p != '\0' && !isspace(*p)) { *w++ = *p++; }
	    *w = '\0';
	    /* skip second '|', if present */
	    if (*p++ != '|') {
	       --p;
	       bibwarning("Unbalanced |macro| bars\n");
	       }
	    else if ((wp = wordsearch(word)) != 0) {
	       strcpy(word, wp->wi_def);
	       if (wp->wi_expanding) {
		  bibwarning("Recursive definition for |%s|\n", word);
		  }
	       else {
		  wp->wi_expanding = true;
		  expand(word);
		  wp->wi_expanding = false;
		  }
	       }
	    else {
	       char errword[REFSIZE];
	       bibwarning("word |%s| not defined\n", word);
	       strcpy(errword, "?");
	       strcat(errword, word);
	       strcat(errword, "?");
	       wordstuff(word, errword);
	       strcpy(word, errword);
	       }
	    for (w = word; *w != '\0'; *q++ = *w++);
	    }
	 else {
	    *q++ = *p++;
	    }
	 }
      }
   else {
      for (p = line; *p != '\0'; /*VOID*/){
	 if (isalnum(*p)) {
	    for (w = word; *p && iswordc(*p); ) *w++ = *p++;
	    *w = 0;
	    if (wp = wordsearch(word)){
	       if (wp->wi_expanding)
		  bibwarning("Recursive definition for %s\n", word);
	       else {
		  strcpy(word, wp->wi_def);
		  wp->wi_expanding = true;
		  expand(word);
		  wp->wi_expanding = false;
		  }
	       }
	    for (w = word; *w != '\0'; *q++ = *w++);
	    }
	 else if (*p == '\\' && *(p+1) != '\0') {
	    *q++ = *p++;
	    *q++ = *p++;
	    }
	 else {
	    *q++ = *p++;
	    }
	 }
      }
   *q = 0;
   strcpy(line, line2);
}

/* wordstuff- save a word and its definition, building a hash table */
   wordstuff(word, def)
   char *word, *def;
{
   int i;
   if (wordtop >= MAXDEFS)
	error("too many definitions, max of %d", MAXDEFS);
   words[wordtop].wi_length = strlen(word);
   words[wordtop].wi_word = word ? walloc(word) : NULL;
   words[wordtop].wi_def = def ? walloc(def) : NULL;
   i = strhash(word);
   words[wordtop].wi_expanding = false;
   words[wordtop].wi_hp = wordhash[i];
   wordhash[i] = &words[wordtop];
   wordtop++;
}
   struct wordinfo *wordsearch(word)
   char *word;
{
   reg int lg;
   reg struct wordinfo *wp;
   lg = strlen(word);
   for (wp = wordhash[strhash(word)]; wp; wp = wp->wi_hp){
	if (wp->wi_length == lg && (strcmp(wp->wi_word, word) == 0)){
		return(wp);
	}
   }
   return(0);
}
/* wordrestuff - save a word and its definition, but replace any existing
 * definition; this could be more efficient, but it is only used to
 * redefine BMACLIB at the present.  -ads 8/88
 */
   wordrestuff(word, def)
   char *word, *def;
{
   struct wordinfo *wp = wordsearch(word);
   if (wp == NULL) wordstuff(word, def);
   else {
      if (wp->wi_word != NULL) free(wp->wi_word);
      if (wp->wi_def != NULL) free(wp->wi_def);
      wp->wi_length = strlen(word);
      wp->wi_word = word ? walloc(word) : NULL;
      wp->wi_def = def ? walloc(def) : NULL;
      wp->wi_expanding = false;
      }
}

   int strhash(str)
   reg char *str;
{
   reg int value = 0;
   for (value = 0; *str; value <<= 2, value += *str++)/*VOID*/;
   value %= HASHSIZE;
   if (value < 0)
	value += HASHSIZE;
   return(value);
}

/* rdref - read text for an already cited reference */
   rdref(p, ref)
   struct refinfo *p;
   char ref[REFSIZE];
{
   ref[0] = 0;
#ifndef INCORE
#ifdef READWRITE
   fixrfd( READ );                      /* fix access mode of rfd, if nec. */
#endif
   fseek(rfd, p->ri_pos, 0);
   fread(ref, p->ri_length, 1, rfd);
#else INCORE
   strcpy(ref, p->ri_ref);
#endif INCORE
}

/* wrref - write text for a new reference */
   wrref(p, ref)
   struct refinfo *p;
   char ref[REFSIZE];
{
#ifndef INCORE
#ifdef READWRITE
    fixrfd( WRITE );                 /* fix access mode of rfd, if nec. */
#else
    fseek(rfd, p->ri_pos, 0);        /* go to end of rfd */
#endif
    fwrite(ref, p->ri_length, 1, rfd);
#else INCORE
   p->ri_ref = walloc(ref);
#endif INCORE
}

/* breakname - break a name into first and last name */
   breakname(line, first, last)
   char line[], first[], last[];
{  reg char *t, *f, *q, *r, *p;

   for (t = line; *t != '\n'; t++);
   for (t--; isspace(*t); t--);

   /* now strip off last name */
   for (q = t; isspace(*q) == 0 || ((*q == ' ') & (*(q-1) == '\\')); q--)
      if (q == line)
         break;
   f = q;
   if (q != line) {
      q++;
      for (; isspace(*f); f--);
      f++;
      }

   /* first name is start to f, last name is q to t */

   for (r = first, p = line; p != f; )
      *r++ = *p++;
   *r = 0;
   for (r = last, p = q, t++; q != t; )
      *r++ = *q++;
   *r = 0;

}

/* match - see if string1 is a substring of string2 (case independent)*/
   int match(str1, str2)
   reg char str1[], str2[];
{  reg int  j, i;
   char a, b;

   for (i = 0; str2[i]; i++) {
      for (j = 0; str1[j]; j++) {
         if (isupper(a = str2[i+j]))
            a = (a - 'A') + 'a';
         if (isupper(b = str1[j]))
            b = (b - 'A') + 'a';
         if (a != b)
            break;
         }
      if (str1[j] == 0)
         return(true);
      }
   return(false);
}

/* scopy - append a copy of one string to another */
   char *scopy(p, q)
   reg char *p, *q;
{
   while (*p++ = *q++)
      ;
   return(--p);
}

/* rcomp - reference comparison routine for qsort utility */
   int rcomp(ap, bp)
   struct refinfo *ap, *bp;
{  char ref1[REFSIZE], ref2[REFSIZE], field1[MAXFIELD], field2[MAXFIELD];
   reg	char *p, *q;
   char *getfield();
   int  neg, res;
   int  fields_found;

   rdref(ap, ref1);
   rdref(bp, ref2);
   for (p = sortstr; *p; p = q) {
      if (*p == '-') {
         p++;
         neg = true;
         }
      else
         neg = false;
      q = getfield(p, field1, ref1);
      fields_found = true;
      if (q == 0) {
	 res = 1;
	 fields_found = false;
      } else if (strcmp (field1, "") == 0) {	/* field not found */
         if (*p == 'A') {
            getfield("F", field1, ref1);
	    if (strcmp (field1, "") == 0) {
               getfield("I", field1, ref1);
	       if (strcmp (field1, "") == 0) {
	          res = 1;
		  fields_found = false;
	       }
	    }
	 } else {
	    res = 1;
	    fields_found = false;
	 }
      }

      if (getfield(p, field2, ref2) == 0) {
	 res = -1;
	 fields_found = false;
      } else if (strcmp (field2, "") == 0) {	/* field not found */
         if (*p == 'A') {
            getfield("F", field2, ref2);
	    if (strcmp (field2, "") == 0) {
               getfield("I", field2, ref2);
	       if (strcmp (field2, "") == 0) {
	          res = -1;
		  fields_found = false;
	       }
	    }
	 } else {
	    res = -1;
	    fields_found = false;
	 }
      }
      if (fields_found) {
         if (*p == 'A') {
            if (isupper(field1[0]))
               field1[0] -= 'A' - 'a';
            if (isupper(field2[0]))
               field2[0] -= 'A' - 'a';
            }
         res = strcmp(field1, field2);
         }
      if (neg)
         res = - res;
      if (res != 0)
         break;
      }
   if (res == 0)
      if (ap < bp)
         res = -1;
      else
         res = 1;
   return(res);
}

/* makecites - make standard citation strings, using citetemplate currently in effect */
   makecites()
{  char ref[REFSIZE], tempcite[100], *malloc();
   reg int  i;

   for (i = 0; i < numrefs; i++) {
      rdref(&refinfo[i], ref);
      bldcite(tempcite, i, ref);
      refinfo[i].ri_cite = malloc(2 + strlen(tempcite));
      if (refinfo[i].ri_cite == NULL)
         error("out of storage");
      strcpy(refinfo[i].ri_cite, tempcite);
      }
}

/* bldcite - build a single citation string */
   bldcite(cp, i, ref)
   char *cp, ref[];
   int  i;
{  reg char *p, *q, *fp;
   char c;
   char field[REFSIZE];
   char *getfield(), *aabet(), *aabetlast(),
        *fullaabet(), *multfull();

   getfield("F", field, ref);
   if (field[0] != 0)
      for (p = field; *p; p++)
         *cp++ = *p;
   else {
      p = citetemplate;
      field[0] = 0;
      while (c = *p++) {
         if (isalpha(c)) {                      /* field name   */
            q = getfield(p-1, field, ref);
            if (q != 0) {
               p = q;
               for (fp = field; *fp; )
                  *cp++ = *fp++;
               }
            }
         else if (c == '1') {                   /* numeric  order */
            sprintf(field,"%d",1 + i);
            for (fp = field; *fp; )
               *cp++ = *fp++;
            }
         else if (c == '2')                     /* alternate alphabetic */
            cp = aabet(cp, ref);
         else if (c == '3')                     /* Astrophysical Journal style*/
            cp = multfull(cp, ref, 3);
         else if (c == '4')                     /* Computing Surveys style*/
            cp = multfull(cp, ref, 2);
	 else if (c == '8')			/* Full alphabetic */
	    cp = fullaabet(cp, ref);
         else if (c == '9')                     /* Last name of Senior Author*/
            cp = aabetlast(cp, ref);
	 else if (c == '0') {			/* print nothing */
            for (fp = field; *fp; )
               *cp++ = *fp++;
            }
         else if (c == '{') {                   /* other information   */
            while (*p != '}')
               if (*p == 0)
                  error("unexpected end of citation template");
               else
                  *cp++ = *p++;
            p++;
            }
         else if (c == '<') {
            while (*p != '>') {
               if (*p == 0)
                  error("unexpected end of citation template");
               else
                  *cp++ = *p++;
               }
            p++;
            }
         else if (c != '@')
            *cp++ = c;
         }
      }
   *cp++ = 0;
}

/* alternate alphabetic citation style -
        if 1 author - first three letters of last name
        if 2 authors - first two letters of first, followed by first letter of
                                seond
        if 3 or more authors - first letter of first three authors */
   char *aabet(cp, ref)
   char *cp, ref[];
{  char field[REFSIZE], temp[100];
   reg char *np, *fp;
   int j, getname();

   if (getname(1, field, temp, ref)) {
      np = cp;
      fp = field;
      for (j = 1; j <= 3; j++)
         if (*fp != 0)
            *cp++ = *fp++;
      if (getname(2, field, temp, ref))
         np[2] = field[0];
      if (getname(3, field, temp, ref)) {
         np[1] = np[2];
         np[2] = field[0];
         }
      }
return(cp);
}

/* alternate alphabetic citation style -
	first two characters of last names of all authors
	up to max_klen characters.
*/
   char *fullaabet(cp, ref)
   char *cp, ref[];
{  char field[REFSIZE], temp[100];
   reg char	*fp;
   char	*lastcp;
   int getname();
   int i;

   lastcp = cp + max_klen;
   for (i= 1; getname(i, field, temp, ref); i++) {
      for (fp = field; *fp && (fp < &(field[3])); )
	 if (cp > lastcp)
	     break;
         else if (isalpha(*fp))
	     *cp++ = *fp++;
	 else
	     fp++;
   }
   return(cp);
}


/* alternate alphabetic citation style -
	entire last name of senior author
*/
   char *aabetlast(cp, ref)
   char *cp, ref[];
{  char field[REFSIZE], temp[100];
   reg char	*fp;
   int getname();

   if (getname(1, field, temp, ref)) {
      for (fp = field; *fp; )
         *cp++ = *fp++;
   }
   return(cp);
}

/*
  Multiple full authors last names (1, 2 or 3 full names).

  If maxauthors<3
        if 1 author - last name date
        if 2 authors - last name and last name date
        if 3 or more authors - last name et al. date
  If maxauthors>=3
        if 1 author - last name date
        if 2 authors - last name and last name date
        if 3 authors - last name, last name and last name date
        if 4 or more authors - last name et al. date */
   char *multfull(cp, ref, maxauthors)
   char *cp, ref[];
   int maxauthors;
{  char name1[100], name2[100], name3[100], temp[100];
   reg char *fp;
   int getname();

   if (getname(1, name1, temp, ref)) {
      for (fp = name1; *fp; )
         *cp++ = *fp++;
      if (((maxauthors >= 3) && (getname(4, name3, temp, ref)))
	  || ((maxauthors < 3) && (getname(3, name3, temp, ref)))) {
         for (fp = " \\*(e]"; *fp; )
            *cp++ = *fp++;
         }
      else if (getname(2, name2, temp, ref)) {
         if (getname(3, name3, temp, ref)) {
            for (fp = "\\*(c]"; *fp; )
               *cp++ = *fp++;
            for (fp = name2; *fp; )
               *cp++ = *fp++;
            for (fp = "\\*(m]"; *fp; )
               *cp++ = *fp++;
            for (fp = name3; *fp; )
               *cp++ = *fp++;
            }
         else {
            for (fp = "\\*(n]"; *fp; )
               *cp++ = *fp++;
            for (fp = name2; *fp; )
               *cp++ = *fp++;
            }
         }
    }
return(cp);
}

/* getfield - get a single field from reference */
   char *getfield(ptr, field, ref)
   char *ptr, field[], ref[];
{  reg	char *p, *q;
   char	temp[100];
   int  n, len, i, getname();

   field[0] = 0;
   if (*ptr == 'A')
      getname(1, field, temp, ref);
   else
      for (p = ref; *p != '\0'; p++)
         if (*p == '%' && *(p+1) == *ptr) {
            for (p = p + 2; isspace(*p); p++)
               ;
            for (q = field; (*p != '\n') && (*p != '\0'); )
               *q++ = *p++;
            *q = 0;
            break;
            }
   n = 0;
   len = strlen(field);
   if (*++ptr == '-') {
      for (ptr++; isdigit(*ptr); ptr++)
         n = 10 * n + (*ptr - '0');
      if (n > len)
         n = 0;
      else
         n = len - n;
      for (i = 0; field[i] = field[i+n]; i++)
         ;
      }
   else if (isdigit(*ptr)) {
      for (; isdigit(*ptr); ptr++)
         n = 10 * n + (*ptr - '0');
      if (n > len)
         n = len;
      field[n] = 0;
      }

   if (*ptr == 'u') {
      ptr++;
      for (p = field; *p; p++)
         if (islower(*p))
            *p = (*p - 'a') + 'A';
      }
   else if (*ptr == 'l') {
      ptr++;
      for (p = field; *p; p++)
         if (isupper(*p))
            *p = (*p - 'A') + 'a';
      }
   return(ptr);
}

/* getname - get the nth name field from reference, breaking into
             first and last names */
   int getname(n, last, first, ref)
   int  n;
   char last[], first[], ref[];
{  reg char *p;
   int  m;

   m = n;
   for (p = ref; *p; p++)
      if (*p == '%' & *(p+1) == 'A') {
         n--;
         if (n == 0) {
            for (p = p + 2; *p == ' '; p++) ;
            breakname(p, first, last) ;
            return(true);
            }
         }

   if (n == m)          /* no authors, try editors */
      for (p = ref; *p; p++)
         if (*p == '%' & *(p+1) == 'E') {
            n--;
            if (n == 0) {
               for (p = p + 2; *p == ' '; p++) ;
               breakname(p, first, last) ;
               return(true);
               }
            }

   if (n == m) {        /* no editors, either, try institution */
      first[0] = last[0] = '\0';
      getfield("I", last, ref);
      if (last[0] != '\0')
         return(true);
      }

   return(false);
}

/* disambiguate - compare adjacent citation strings, and if equal, add
                  single character disambiguators */
   disambiguate()
{  reg int i, j;
	char adstr;

   for (i = 0; i < numrefs-1; i = j) {
      j = i + 1;
      if (strcmp(refinfo[i].ri_cite, refinfo[j].ri_cite)==0) {
         adstr = 'a';
         for(j = i+1;
	     j<numrefs && strcmp(refinfo[i].ri_cite,refinfo[j].ri_cite) == 0;
	     j++) {
            adstr = 'a' + (j-i);
	    refinfo[j].ri_disambig[0] = adstr;
            }
	 refinfo[i].ri_disambig[0] = 'a';
         }
     }
  for (i = 0; i < numrefs; i++){
	strcat(refinfo[i].ri_cite, refinfo[i].ri_disambig);
  }
}


/* bldname - build a name field
             doing abbreviations, reversals, and caps/small caps
*/
   bldname(first, last, name, reverse)
   char *first, *last, name[];
   int reverse;
{
   char newfirst[120], newlast[120];
   reg char *p, *q, *f, *l;
   char *scopy();
   int  flag;

   if (abbrev) {
      p = first;
      q = newfirst;
      flag = false;
      while (*p) {
         while (*p == ' ')
            p++;
         if (*p == 0)
            break;
         if (isupper(*p)) {
            if (flag)           /* between initial gap */
               q = scopy(q, "\\*(a]");
            flag = true;
            *q++ = *p;
            q = scopy(q, "\\*(p]");
            }
         if (*++p == '.')
            p++;
         else while (*p != 0 && ! isspace(*p))
            p++;
         }
      *q = 0;
      f = newfirst;
      }
   else
      f = first;

   if (capsmcap) {
      p = last;
      q = newlast;
      flag = 0;  /* 1 - printing cap, 2 - printing small */
      while (*p)
         if (islower(*p)) {
            if (flag != 2)
               q = scopy(q, "\\s-2");
            flag = 2;
            *q++ = (*p++ - 'a') + 'A';
            }
         else {
            if (flag == 2)
               q = scopy(q,"\\s+2");
            flag = 1;
            *q++ = *p++;
            }
      if (flag == 2)
         q = scopy(q, "\\s+2");
      *q = 0;
      l = newlast;
      }
   else
      l = last;

   if (f[0] == 0)
      sprintf(name, "%s\n", l);
   else if (reverse)
      sprintf(name, "%s\\*(b]%s\n", l, f);
   else
      sprintf(name, "%s %s\n", f, l);
}

/* prtauth - print author or editor field */
   prtauth(c, line, num, max, ofd, abbrev, capsmcap, numrev)
   char c, *line;
   int  num, max, abbrev, capsmcap, numrev;
   FILE *ofd;
{  char first[LINELENGTH], last[LINELENGTH];

   if (num <= numrev || abbrev || capsmcap) {
      breakname(line, first, last);
      bldname(first, last, line, num <= numrev);
      }
   if (num == 1)
      fprintf(ofd,".ds [%c %s", c, line);
   else if (num < max)
      fprintf(ofd,".as [%c \\*(c]%s", c, line);
   else if (max == 2)
      fprintf(ofd,".as [%c \\*(n]%s", c, line);
   else
      fprintf(ofd,".as [%c \\*(m]%s", c, line);
   if (num == max && index(trailstr, c))
      fprintf(ofd,".ds ]%c %c\n", c, line[strlen(line)-2]);
}

/* doline - actually print out a line of reference information */
   doline(c, line, numauths, maxauths, numeds, maxeds, ofd)
   char c, *line;
   int numauths, maxauths, numeds, maxeds;
   FILE *ofd;
{
   int appending;

   switch(c) {
      case 'A':
          prtauth(c, line, numauths, maxauths, ofd, abbrev, capsmcap, numrev);
          break;

      case 'E':
          prtauth(c, line, numeds, maxeds, ofd, edabbrev, edcapsmcap, ednumrev);
          if (numeds == maxeds)
             fprintf(ofd,".nr [E %d\n", maxeds);
          break;

      case 'P':
          if (index(line, '-'))
             fprintf(ofd,".nr [P 1\n");
          else
             fprintf(ofd,".nr [P 0\n");
          fprintf(ofd,".ds [P %s",line);
          if (index(trailstr, 'P'))
             fprintf(ofd,".ds ]P %c\n",line[strlen(line)-2]);
          break;

      case 'F': break;

      /* these now accumulate their entries */
      /* defined by official bib documentation */
      case 'K': case 'O': case 'W':
      /* not defined by official bib documentation */
      case 'H': case 'L': case 'M': case 'Q': case 'U': case 'X': case 'Y':
      case 'Z':
	 appending = letterSeen[c];
	 letterSeen[c] = true;
	 if (appending)
	    fprintf(ofd, ".as [%c , %s", c, line);
	 else
	    fprintf(ofd, ".ds [%c %s", c, line);
	 if (index(trailstr, c))
	    fprintf(ofd, ".ds ]%c %c\n", c, line[strlen(line) - 2]);
	 break;

      default:
	  if (!isupper(c)) break; /* ignore what you don't understand */
          fprintf(ofd,".ds [%c %s", c, line);
          if (index(trailstr, c))
             fprintf(ofd,".ds ]%c %c\n", c, line[strlen(line)-2]);
          }
}

/* dumpref - dump reference number i */
   dumpref(i, ofd)
   int i;
   FILE *ofd;
{  char ref[REFSIZE], line[REFSIZE];
   reg char *p, *q;
   char *from;
   int numauths, maxauths, numeds, maxeds;
   int j;

   if ( i < 0 ) ref[0] = 0; /* ref not found */
   else {
	   rdref(&refinfo[i], ref);
	   maxauths = maxeds = 0;
	   numauths = numeds = 0;
	   for (j=0; j < 128; j++) letterSeen[j] = 0;
	   for (p = ref; *p; p++)
	      if (*p == '%')
	         if (*(p+1) == 'A') maxauths++;
	         else if (*(p+1) == 'E') maxeds++;
	   fprintf(ofd, ".[-\n");
	   fprintf(ofd, ".ds [F %s\n", refinfo[i].ri_cite);
#ifndef INCORE
	   fseek(rfd, (long)refinfo[i].ri_pos, 0);
	   while (fgets(line, REFSIZE, rfd) != NULL) {
#else INCORE
	   for (q = line, from = refinfo[i].ri_ref; *from; /*VOID*/) { /*} */
		if (*from == '\n'){
			*q++ = '\n';
			*q = 0;
			q = line;
			from++;
		} else {
			*q++ = *from++;
			continue;
		}
#endif INCORE
		switch(line[0]){
		case 0:
			goto doneref;
		case '.':
			fprintf(ofd, "%s", line);
			break;
		case '%':
			switch(line[1]){
			case 'A':	numauths++;	break;
			case 'E':	numeds++;	break;
			}
			for (p = &line[2]; *p == ' '; p++) /*VOID*/;
			doline(line[1], p, numauths, maxauths, numeds, maxeds, ofd);
		}
	   }
	   doneref:;
	   fprintf(ofd,".][\n");
   }
}