summaryrefslogtreecommitdiff
path: root/biblio/tib/src/tibargs.c
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
committerNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
commite0c6872cf40896c7be36b11dcc744620f10adf1d (patch)
tree60335e10d2f4354b0674ec22d7b53f0f8abee672 /biblio/tib/src/tibargs.c
Initial commit
Diffstat (limited to 'biblio/tib/src/tibargs.c')
-rw-r--r--biblio/tib/src/tibargs.c1876
1 files changed, 1876 insertions, 0 deletions
diff --git a/biblio/tib/src/tibargs.c b/biblio/tib/src/tibargs.c
new file mode 100644
index 0000000000..2d367df10e
--- /dev/null
+++ b/biblio/tib/src/tibargs.c
@@ -0,0 +1,1876 @@
+/*
+ tibargs
+
+ read argument strings for tib and tiblist
+ do name formatting, printing lines, other actions common to both
+
+ */
+#include <stdio.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "tib.h"
+
+/* 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 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 sort = false; /* sort references ? (default no) */
+ int foot = false; /* footnoted references ? (default endnotes) */
+ int c0 = false; /* references in text ? (default no) */
+ int hyphen = false; /* hypenate contiguous references */
+ int ordcite = true; /* order multiple citations */
+ int specflag = false; /* use special flags */
+ int loccit = false; /* use ibid and loccit in footnotes */
+ int onepage = false; /* print only first page of reference */
+ int underline = false; /* underline multiple references */
+ int silent = false; /* run silently */
+ int stndout = false; /* output on stdout */
+ int inputflag = false; /* process input/include files */
+ char sortstr[80] = "1"; /* sorting template */
+ char trailstr[80] = ""; /* trailing characters to output */
+ char pfile[120]; /* private file name */
+ char dirname[120] =""; /* private directory name */
+ int personal = false; /* personal file given ? (default no) */
+ char citetemplate[80] = "1"; /* citation template */
+ char *words[MAXDEFS]; /* defined words */
+ char *defs[MAXDEFS]; /* defined word definitions */
+ long int defpos[MAXDEFS]; /* position of defined words */
+ long int link[MAXDEFS]; /* link for linking defined words on input */
+ long int jtop = 0; /* entry for linked list */
+ long int wordtop = -1; /* top of defined words array */
+ int locflag[MAXREFS]; /* loc cit ? */
+ int ibidflag[MAXREFS]; /* ibid ? */
+ char dirsp2[]=DIRSEP; /* directory separator character */
+ char optch2[]=OPTCH; /* option character on program calls */
+ char suffix[5] = ".tex"; /* for appending to file names */
+ int startflag = 1; /* starting count of Flags */
+
+/* where output goes */
+ extern FILE *tfd;
+/* reference file information */
+ extern long int refspos[];
+ extern int unlmark[];
+ extern char reffile[];
+ extern FILE *rfd;
+ extern char *citestr[];
+ extern int numrefs;
+
+/* doargs - read command argument line for both tib and tiblist
+ 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 bibfnamet[120];
+ int pipeflag = false;
+ int fileflag = false;
+ char *p, *q, *walloc();
+ FILE *fd, *np;
+ char headerline[240], fname[240];
+ char *tfgets(), *ptmac, *getenv();
+
+ if (silent == false)
+ fprintf(stderr, "Processing format commands ...\n");
+ numfiles = 0;
+ style = true;
+ ptmac = getenv("TMACLIB");
+ if (ptmac == NULL)
+ ptmac = TMACLIB;
+ words[0] = walloc("TMACLIB");
+ strcpy(headerline,ptmac);
+ strcat(headerline,dirsp2);
+ defs[0] = walloc(headerline);
+ wordtop++;
+ link[0] = -1;
+ fprintf(tfd, "%cmessage {REFERENCE FORMATTING FILES:}\n", '\\');
+ fprintf(tfd, "%cdef%cTMACLIB{%s%c}\n", '\\', '\\', ptmac, dirsp2[0]);
+ fprintf(tfd, "%cinput %cTMACLIB Macros.ttx\n", '\\', '\\');
+
+ for (i = 1; i < argc; i++)
+ if (argv[i][0] == optch2[0] && argv[i][1] == 'd') {
+ if (argv[i][2])
+ p = &argv[i][2];
+ else { /* take next arg */
+ i++;
+ if (i == argc) {
+ fprintf(stderr,"command line: illegal switch %s\n", argv[i-1]);
+ clnup();
+ exit(1);
+ }
+ p = argv[i];
+ }
+ strcpy(dirname,p);
+ break;
+ }
+
+ for (i = 1; i < argc; i++)
+ if (argv[i][0] == optch2[0]) {
+ switch(argv[i][1]) {
+
+ case 'd': if (argv[i][2])
+ p = &argv[i][2];
+ else { /* take next arg */
+ i++;
+ if (i == argc) {
+ fprintf(stderr,
+ "command line: illegal switch %s\n", argv[i-1]);
+ clnup();
+ exit(1);
+ }
+ p = argv[i];
+ }
+ strcpy(dirname,p);
+ break;
+
+ case 'j': inputflag = true;
+ break;
+
+ case 'n': if (argv[i][2])
+ startflag = atoi(&argv[i][2]);
+ else { /* take next arg */
+ i++;
+ if (i == argc) {
+ fprintf(stderr,
+ "command line: illegal switch %s\n", argv[i-1]);
+ clnup();
+ exit(1);
+ }
+ startflag = atoi(argv[i]);
+ }
+ break;
+
+ case 'p': if (argv[i][2])
+ p = &argv[i][2];
+ else { /* take next arg */
+ i++;
+ if (i == argc) {
+ fprintf(stderr,
+ "command line: illegal switch %s\n", argv[i-1]);
+ clnup();
+ exit(1);
+ }
+ p = argv[i];
+ }
+ strcpy(pfile, p);
+ personal = true;
+ for (p = fname, q = pfile; ; q++)
+ if (*q == ',' || *q == 0) {
+ *p = 0;
+ np = fopen( fname, "r");
+ if (np == NULL) {
+ fprintf(stderr, "Can't open index %s\n",fname);
+ clnup();
+ exit(1);
+ }
+ else {
+ tfgets(headerline,240,np);
+ fclose(np);
+ chkindex(fname, headerline, true);
+ }
+ if (*q == 0)
+ break;
+ p = fname;
+ }
+ else *p++ = *q;
+ break;
+
+ case 's': style = false; /*fall through*/
+ case 'i': if (argv[i][2])
+ p = &argv[i][2];
+ else { /* take next arg */
+ i++;
+ if (i == argc) {
+ fprintf(stderr,
+ "command line: illegal switch %s\n", argv[i-1]);
+ clnup();
+ exit(1);
+ }
+ p = argv[i];
+ }
+ incfile(p);
+ break;
+
+ case 'x': stndout = true;
+ break;
+
+ case 'z': silent = true;
+ break;
+
+ case '|': pipeflag = true;
+ stndout = true;
+ break;
+
+ default: fprintf(stderr, "command line: invalid switch %s\n",
+ argv[i]);
+ clnup();
+ exit(1);
+ }
+ }
+ else { /* file name */
+ numfiles++;
+ fileflag = true;
+ if (style) {
+ style = false;
+ incfile( defstyle );
+ }
+ strcpy(bibfname, argv[i]);
+ fd = fopen(argv[i], "r");
+ if (fd == NULL) {
+ strcat(bibfname,suffix);
+ fd=fopen(bibfname, "r");
+ if (fd == NULL) {
+ fprintf(stderr, "can't open %s or %s\n", argv[i], bibfname);
+ clnup();
+ exit(1);
+ }
+ }
+ if (stndout == false && silent == false) {
+ fprintf(stderr, "Reading input document file %s and looking up references ...\n", bibfname);
+ }
+ rdtext(fd);
+ fclose(fd);
+ }
+ if (style) incfile( defstyle );
+ if (fileflag == false) /* no input file on command line */
+ if (pipeflag == true) {
+ strcpy(bibfname, "<stdin>");
+ rdtext(stdin);
+ numfiles++;
+ }
+ else {
+ fprintf(stderr, "Enter input file: ");
+ scanf("%s", bibfnamet);
+ numfiles++;
+ strcpy(bibfname, bibfnamet);
+ fd = fopen(bibfnamet, "r");
+ if (fd == NULL) {
+ strcat(bibfname, ".tex");
+ fd=fopen(bibfname, "r");
+ if (fd == NULL) {
+ fprintf(stderr, "can't open %s or %s\n",
+ bibfnamet, bibfname);
+ clnup();
+ exit(1);
+ }
+ }
+ if (stndout == false && silent == false) {
+ fprintf(stderr, "Reading input document file %s and looking up references ...\n", bibfname);
+ }
+ rdtext(fd);
+ fclose(fd);
+ }
+ return(numfiles);
+}
+
+/* chkindex - check if index is up to date */
+ int chkindex(indx, header, pflag)
+ char *indx;
+ char header[240];
+ int pflag;
+{ char *c, *q, *p;
+ char indx0[240], indx00[80], *indx1, indx11[240];
+ char *rindex();
+ struct stat buf;
+ FILE *np;
+ int i, j, qflag;
+ time_t timefile, timeindx;
+
+ stat(indx, &buf);
+ timeindx = buf.st_mtime;
+ strcpy (indx0,indx);
+ c = rindex(indx0, dirsp2[0]);
+ if (c == NULL)
+ indx00[0] = '\0';
+ else {
+ *++c = '\0';
+ strcpy (indx00, indx0);
+ }
+ strcpy (indx0,indx00);
+ qflag = true;
+ for (q = header ; *q;) {
+ for (;*q == ' ';q++);
+ if (*q == '\0') break;
+ for (indx1 = q; *q && *q != ' '; q++);
+ if (*q)
+ *q = '\0';
+ else
+ qflag = false;
+ if (*indx1 != dirsp2[0]) {
+ strcat (indx0,indx1);
+ strcpy (indx11,indx0);
+ }
+ np = fopen(indx11,"r");
+ if (np == NULL) {
+ fprintf(stderr,"Cannot locate reference file %s\n", indx11);
+ clnup();
+ exit(1);
+ }
+ strcpy (indx0, indx00);
+ stat(indx11, &buf);
+ timefile = buf.st_mtime;
+ if (qflag == true)
+ *q = ' ';
+ if (timeindx < timefile) {
+ fprintf(stderr,"Index %s not up to date\n", indx);
+ if (pflag)
+ fprintf(stderr,"Use tibdex (in appropriate directory) with reference file(s)%s\n",header);
+ else
+ fprintf(stderr," Use: tibdex%s\n",header);
+ clnup();
+ exit(1);
+ }
+ }
+ }
+
+/* outfname - make output file name */
+ char *outfname(mp)
+ char *mp;
+{ char *q;
+
+ for (q=mp; *q; q++);
+ if (*--q == 'x')
+ if (*--q == 'e')
+ if (*--q == 't')
+ if (*--q == '.')
+ *q='\0';
+ strcat (mp, "-t.tex");
+ return (mp);
+}
+
+/* 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, j, k, getwrd();
+ int located, j1;
+ char *ptmac, *getenv();
+
+ ptmac = getenv("TMACLIB");
+ if (ptmac == NULL)
+ ptmac = TMACLIB;
+ strcpy(bibfname, np);
+ fd = fopen(np, "r");
+ if (fd == NULL && *np != dirsp2[0]) {
+ strcpy(name, np);
+ strcat(name, ".tib");
+ strcpy(bibfname, name);
+ fd = fopen(name, "r");
+ }
+ if (fd == NULL && *np != dirsp2[0])
+ if (dirname[0] != '\0') {
+ strcpy(name, dirname);
+ strcat(name, dirsp2);
+ strcat(name, np);
+ strcpy(bibfname, name);
+ fd = fopen(name, "r");
+ }
+ if (fd == NULL && *np != dirsp2[0])
+ if (dirname[0] != '\0') {
+ strcpy(name, dirname);
+ strcat(name, dirsp2);
+ strcat(name, np);
+ strcat(name, ".tib");
+ strcpy(bibfname, name);
+ fd = fopen(name, "r");
+ }
+ if (fd == NULL && *np != dirsp2[0]) {
+ strcpy(name, ptmac);
+ strcat(name, dirsp2);
+ strcat(name, np);
+ strcpy(bibfname, name);
+ fd = fopen(name, "r");
+ }
+ if (fd == NULL && *np != dirsp2[0]) {
+ strcpy(name, ptmac);
+ strcat(name, dirsp2);
+ strcat(name, np);
+ strcat(name, ".tib");
+ strcpy(bibfname, name);
+ fd = fopen(name, "r");
+ }
+ if (fd == NULL) {
+ bibwarning("%s: can't open\n", np);
+ clnup();
+ exit(1);
+ }
+
+ /* now go off and process file */
+ fprintf(tfd, "%cmessage {(%s}\n", '\\', np);
+ biblineno = 1;
+ while (tfgets(line, LINELENGTH, fd) != NULL) {
+ biblineno++;
+ switch(line[0]) {
+
+ case '#': break;
+
+ case 'A': for (p = &line[1]; *p && *p != ' '; p++) {
+ if (*p == 'A')
+ abbrev = true;
+ else if (*p == 'X')
+ capsmcap = true;
+ else if (*p == 'R') {
+ if (isdigit(*(p+1)))
+ numrev = atoi(p+1);
+ else
+ numrev = 1000;
+ }
+ }
+ break;
+
+ case 'C': for (p = &line[1]; *p == ' '; p++) ;
+ strcpy(citetemplate, p);
+ for (p=citetemplate; *p && *p != ' '; p++);
+ *p=0;
+ if (citetemplate[0] == '0') c0 = true;
+ break;
+
+ case 'D': if ((k = getwrd(line, 1, word)) == 0)
+ error("word expected in definition");
+
+/* this creates a linked list for use in sortdefs and expnd2
+ but it is fortran style, not good c style -- fix later */
+
+ j=jtop;
+ for (located = false; located == false; ) {
+ i=strcmp(word, words[jtop]);
+ if (i == 0) {
+ located = true;
+ break;
+ }
+ if (i > 0) {
+ wordtop++;
+ if (wordtop > MAXDEFS)
+ error("too many definitions:");
+ link[wordtop] = jtop;
+ jtop = wordtop;
+ j = jtop;
+ words[wordtop] = walloc(word);
+ located = true;
+ break;
+ }
+ while (link[j] >= 0) {
+ j1 = link[j];
+ i = strcmp(word, words[j1]);
+ if (i == 0) {
+ j = j1;
+ located = true;
+ break;
+ }
+ if (i > 0) {
+ wordtop++;
+ if (wordtop > MAXDEFS)
+ error("too many definitions:");
+ link[wordtop] = j1;
+ link[j] = wordtop;
+ j = wordtop;
+ words[wordtop] = walloc(word);
+ located = true;
+ break;
+ }
+ j = j1;
+ }
+ if (located == false) {
+ wordtop++;
+ if (wordtop > MAXDEFS)
+ error("too many definitions:");
+ link[wordtop] = -1;
+ link[j] = wordtop;
+ j = wordtop;
+ words[wordtop] = walloc(word);
+ located = true;
+ break;
+ }
+ }
+ for (p = &line[k]; *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);
+ }
+ defs[j] = walloc(dline);
+ break;
+
+ case 'E': for (p = &line[1]; *p && *p != ' '; p++) {
+ if (*p == 'A')
+ edabbrev = true;
+ else if (*p == 'X')
+ edcapsmcap = true;
+ else if (*p == 'R') {
+ if (isdigit(*(p+1)))
+ ednumrev = atoi(p+1);
+ else
+ ednumrev = 1000;
+ }
+ }
+ break;
+
+ case 'f': foot = true;
+ hyphen = false;
+ break;
+
+ case 'F': specflag = true;
+ break;
+
+ case 'H': hyphen = ordcite = true;
+ break;
+
+ case 'I': for (p = &line[1]; *p == ' '; p++);
+ expnd1(p);
+ incfile(p);
+ break;
+
+ case 'L': loccit = true;
+ break;
+
+ case 'N': for (p = &line[1]; *p == ' '; p++);
+ if (*p == 'A')
+ abbrev = false;
+ else if (*p == 'F')
+ specflag = false;
+ else if (*p == 'H')
+ hyphen = false;
+ else if (*p == 'O')
+ ordcite = false;
+ else if (*p == 'R')
+ numrev = 0;
+ else if (*p == 'S')
+ sort = false;
+ else if (*p == 'X')
+ capsmcap = false;
+ break;
+ case 'O': ordcite = true;
+ break;
+
+ case 'P': onepage = true;
+ break;
+
+ case 'S': sort = true;
+ for (p = &line[1]; *p == ' '; p++) ;
+ strcpy(sortstr, p);
+ for (p=sortstr; *p && *p != ' '; p++);
+ *p=0;
+ break;
+
+ case 'T': for (p = &line[1]; *p == ' '; p++) ;
+ strcpy(trailstr, p);
+ for (p=trailstr; *p && *p != ' '; p++);
+ *p=0;
+ break;
+
+ case 'U': underline = true;
+ break;
+
+ default: fprintf(tfd, "%s\n", line);
+ while (fgets(line, LINELENGTH, fd) != NULL)
+ fputs(line, tfd);
+ fprintf(tfd, "%cmessage {)}", '\\');
+ return;
+ }
+
+ }
+ /* close up */
+ fprintf(tfd, "%cmessage{)}", '\\');
+ fclose(fd);
+}
+
+/* bibwarning - print out a warning message */
+ bibwarning(msg, arg)
+ char *msg, *arg;
+{
+ fprintf(stderr, "`%s', line %d: ", bibfname, biblineno);
+ fprintf(stderr, msg, arg);
+}
+
+/* error - report unrecoverable error message */
+ error(str)
+ char str[];
+{
+ bibwarning("%s\n", str);
+ clnup();
+ exit(1);
+}
+
+#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");
+ }
+}
+#endif
+
+
+/* tfgets - fgets which trims off newline */
+ char *tfgets(line, n, ptr)
+ char line[];
+ int n;
+ FILE *ptr;
+{ 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)
+ char in[], out[];
+ int i;
+{ int j;
+
+ j = 0;
+ while (in[i] == ' ' || in[i] == '\n' || in[i] == '\t')
+ i++;
+ if (in[i])
+ while (in[i] && in[i] != ' ' && in[i] != '\t' && in[i] != '\n')
+ 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 */
+int iswordc(c)
+char c;
+{
+ if (isalnum(c) || c == '&' || c == '_')
+ return(true);
+ return(false);
+}
+
+/* expnd1 - expand reference, replacing defined words, scrunching spaces */
+ expnd1(line)
+ char *line;
+{ char line2[REFSIZE], word[LINELENGTH], *p, *q, *w;
+ int replaced, i;
+
+ replaced = true;
+ while (replaced) {
+ replaced = false;
+ p = line;
+ q = line2;
+ while (*p) {
+ if (isalnum(*p)) {
+ for (w = word; *p && iswordc(*p); )
+ *w++ = *p++;
+ *w = 0;
+ for (i = 0; i <= wordtop; i++)
+ if (strcmp(word, words[i]) == 0) {
+ strcpy(word, defs[i]);
+ replaced = true;
+ break;
+ }
+ for (w = word; *w; )
+ *q++ = *w++;
+ }
+ else
+ *q++ = *p++;
+ }
+ *q = 0;
+ p = line;
+ q = line2;
+ while (*q != 0) {
+ if (*q != ' ')
+ *p++ = *q++;
+ else
+ q++;
+ }
+ *p = 0;
+ }
+}
+
+/* expnd2 - expand reference, replacing defined words */
+ expnd2(line)
+ char *line;
+{ char line2[REFSIZE], word[LINELENGTH], *p, *q, *w;
+ int replaced, toolong, i;
+
+ toolong = false; /* flag to indicate reference is too long */
+ replaced = true;
+ while (replaced) {
+ replaced = false;
+ p = line;
+ q = line2;
+ while (*p) {
+ if (*p != '|')
+ if (q - line2 >= REFSIZE-1){
+ toolong = true; /* reference entry is too long */
+ *(q-1) = '\n'; /* make entry end with \n\0 */
+ break;
+ } else
+ *q++ = *p++;
+ else {
+ *p++;
+ for (w = word; *p && *p != '|'; *w++ = *p++);
+ *w = 0;
+ if (locdef(word) == false)
+ fprintf(stderr,"word %s not defined in definition list\n",
+ word);
+ else
+ replaced = true;
+ if (*p == '|')
+ p++;
+ for (w = word; *w; *q++ = *w++)
+ if (q - line2 >= REFSIZE-1){
+ toolong = true; /* reference entry is too long */
+ *(q-1) = '\n'; /* make entry end with \n\0 */
+ break;
+ }
+ }
+ }
+ *q = 0;
+ p = line;
+ q = line2;
+ while (*p++ = *q++);
+ }
+ if(toolong && silent == false) { /* print truncation warning */
+ fprintf(stderr,
+ "Truncated following reference after expanding defined words: \n");
+ fprintf(stderr,"-------------\n%s\n-------------\n",line);
+ }
+}
+
+/* locdef - locate a definition */
+ int locdef(word)
+ char *word;
+{ long int lower, upper, mid, i;
+ int strcmp();
+ char *w, *w1;
+
+ lower = 0;
+ upper = wordtop;
+ if (strcmp(word, words[defpos[lower]]) == 0) {
+ for (w = word, w1 = defs[defpos[lower]]; *w1; *w++ = *w1++);
+ *w = 0;
+ return(true);
+ }
+ if (strcmp(word, words[defpos[upper]]) == 0) {
+ for (w = word, w1 = defs[defpos[upper]]; *w1; *w++ = *w1++);
+ *w = 0;
+ return(true);
+ }
+ while (lower+1 < upper) {
+ mid = (lower + upper)/2;
+ i = strcmp(word, words[defpos[mid]]);
+ if (i == 0) {
+ for (w = word, w1 = defs[defpos[mid]]; *w1; *w++ = *w1++);
+ *w = 0;
+ return(true);
+ }
+ if (i > 0)
+ lower = mid;
+ else
+ upper = mid;
+ }
+ return (false);
+}
+
+/* rdref - read text for an already cited reference */
+ rdref(i, ref)
+ long int i;
+ char ref[REFSIZE];
+{
+ ref[0] = 0;
+#ifdef READWRITE
+ fixrfd( READ ); /* fix access mode of rfd, if nec. */
+#endif
+ fseek(rfd, i, 0);
+ fread(ref, 1, REFSIZE, rfd);
+}
+
+/* breakname - break a name into first and last name */
+ breakname(line, first, last)
+ char line[], first[], last[];
+{ char *p, *q, *r, *t, *f;
+
+ 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 == '}') {
+ while (*q != '{') {
+ q--;
+ if (q == line) {
+ fprintf (stderr, "bad brackets in string %s in references\n",
+ line);
+ clnup();
+ exit(1);
+ }
+ }
+ }
+ 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)
+ char str1[], str2[];
+{ int i, j;
+ 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)
+ char *p, *q;
+{
+ while (*p++ = *q++)
+ ;
+ return(--p);
+}
+
+/* makecites - make citation strings */
+ makecites(citestr)
+ char *citestr[];
+{ char ref[REFSIZE], tempcite[100], *malloc();
+ int i;
+
+ for (i = 0; i <= numrefs; i++) {
+ rdref(refspos[i], ref);
+ bldcite(tempcite, i, ref);
+ citestr[i] = malloc(2 + strlen(tempcite)); /* leave room for disambig */
+ if (citestr[i] == NULL)
+ error("out of storage");
+ strcpy(citestr[i], tempcite);
+ }
+}
+
+/* sortdefs - make array of pointers to defined words */
+ sortdefs()
+{ long int i, j;
+
+ i = wordtop;
+ for (j = jtop; j >= 0; j = link[j]) {
+ defpos[i] = j;
+ i--;
+ }
+}
+
+/* rcomp1 - revised reference comparison routine for qsort utility */
+ int rcomp1(ap, bp)
+ long int *ap, *bp;
+{ char ref1[REFSIZE], ref2[REFSIZE], field1[MAXFIELD], field2[MAXFIELD];
+ char alpha1[REFSIZE], alpha2[REFSIZE];
+ char *p, *q, *getfield();
+ int neg, res;
+ int n, m1, m2, num;
+ int getname();
+ char last1[MAXFIELD], last2[MAXFIELD], first1[MAXFIELD], first2[MAXFIELD];
+ int alphabits();
+ char *fstcap();
+
+ rdref(*ap, ref1);
+ rdref(*bp, ref2);
+ for (p = sortstr, q=p; *p ; p=q) {
+ if (*p == '-') {
+ p++;
+ neg = true;
+ }
+ else
+ neg = false;
+ res=0;
+ if (*p == 'A') {
+ p++;
+ if (isdigit(*p))
+ for (num=0; isdigit(*p); p++)
+ num=10*num+(*p-'0');
+ else
+ num=100;
+ q=p;
+ for (n=1; n <= num; n++) {
+ m1=getname (n, last1, first1, ref1);
+ m2=getname (n, last2, first2, ref2);
+ if (m1 == 0 && m2 == 0)
+ break;
+ alphabits(alpha1, last1);
+ alphabits(alpha2, last2);
+/* res = strcmp (fstcap(alphabits(last1)), fstcap(alphabits(last2)));
+ alpha11 = fstcap(alphastring1);
+ alpha21 = fstcap(alphastring2);*/
+ res = strcmp (fstcap(alpha1), fstcap(alpha2));
+ if (res) break;
+ alphabits(alpha1, first1);
+ alphabits(alpha2, first2);
+ res = strcmp (fstcap(alpha1), fstcap(alpha2));
+ if (res != 0) break;
+ }
+ }
+ else {
+ q++;
+ getfield(p, field1, ref1);
+ getfield(p, field2, ref2);
+ 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);
+}
+
+/* alphabits - reduce string to alpha characters */
+ alphabits(stringout, stringin)
+ char *stringin, *stringout;
+{ char *p, *q;
+
+ q = stringout;
+ p = stringin;
+ while (*p) {
+ if (isalpha(*p) || isspace(*p))
+ *q++ = *p++;
+ else if (*p == '{') {
+ for (; *p && *p != '}'; p++);
+ if (*p == 0) {
+ fprintf(stderr, "bad brackets in string %s in references\n",
+ stringin);
+ clnup();
+ exit(1);
+ }
+ else {
+ for (p--; isalpha(*p); p--);
+ for (p++; isalpha(*p); *q++ = *p++);
+ }
+ }
+ else p++;
+ }
+ *q = 0;
+}
+
+/* fstcap - find first capital letter in string */
+ char *fstcap(string)
+ char *string;
+{ char *ptr;
+
+ for(ptr=string; *ptr && (isupper(*ptr) == 0); ptr++);
+ return (ptr);
+}
+
+/* capbrackets - find if string in brackets is capital, also capitalize it */
+ capbrackets(stringout, stringin)
+ char *stringout, *stringin;
+{ char *p, *q;
+ int cap;
+
+ cap = false;
+ q = stringout;
+ p = stringin;
+ for (; *p && *p != '}'; *q++ = *p++);
+ if (*p == 0) {
+ fprintf(stderr, "bad brackets in string %s in references\n",
+ stringin);
+ clnup();
+ exit(1);
+ }
+ *q++ = '}';
+ *q = 0;
+ q--;
+ for (q--; isalpha(*q); q--) {
+ if (isupper (*q))
+ cap = true;
+ else {
+ cap = false;
+ *q = (*q - 'a') + 'A';
+ }
+ }
+ return (cap);
+}
+
+/* undrline - underline successive identical authors */
+ undrline()
+{ char line[REFSIZE], line1[REFSIZE], last[REFSIZE], first[REFSIZE];
+ char ref[REFSIZE];
+ int m, i;
+
+ line1[0] = 0;
+ for (m=numrefs; m >= 0; m--) {
+ rdref(refspos[m], ref);
+ line[0] = 0;
+ for (i=1; getname(i, last, first, ref); i++) {
+ strcat(line, last);
+ strcat(line, first);
+ }
+ if (strcmp(line, line1) == 0)
+ unlmark[m] = true;
+ else
+ unlmark[m] = false;
+ strcpy(line1, line);
+ }
+}
+
+
+/* bldcite - build a single citation string */
+ bldcite(cp, i, ref)
+ char *cp, ref[];
+ int i;
+{ char *p, *q, c, *fp, field[REFSIZE], *getfield(), *aabet(), *nmdt();
+
+ getfield("F", field, ref);
+ if (field[0] != 0 && specflag)
+ 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;
+ cp=scopy(cp, "\\Citebreak ");
+ for (fp = field; *fp; )
+ *cp++ = *fp++;
+ }
+ }
+ else if (c == '0') { /* empty citation */
+ *cp = '\0';
+ }
+ else if (c == '1') { /* numeric order */
+ sprintf(field, "%d", startflag + i);
+ for (fp = field; *fp; )
+ *cp++ = *fp++;
+ }
+ else if (c == '2') /* alternate alphabetic */
+ cp = aabet(cp, ref);
+ else if (c == '3') /* names */
+ cp = nmdt(cp, ref);
+/* else if (c == '4') here is how to add new styles */
+/* else if (c == '{') {
+ 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 */
+ char *aabet(cp, ref)
+ char *cp, ref[];
+{ char field[REFSIZE], temp[100], *np, *fp;
+ char string11[80], string12[80], string13[80], string2[80], string3[80];
+ char bracketstring[80];
+ int getname(), i;
+
+ if (getname(1, field, temp, ref)) {
+ fp = field;
+ for (np = string11; *fp; fp++) {
+ if (isupper(*fp)) {
+ *np++ = *fp;
+ break;
+ }
+ else if (*fp == '{') {
+ if (capbrackets(bracketstring, fp) == 0)
+ for (; *fp != '}'; fp++);
+ else {
+ for (; *fp != '}'; *np++ = *fp++);
+ *np++ = '}';
+ break;
+ }
+ }
+ }
+ if (*fp) fp++;
+ *np = 0;
+ for (np = string12; *fp && isalpha(*fp) == 0 && *fp != '{';
+ *np++ = *fp++);
+ if (*fp != '{')
+ *np++ = *fp;
+ else {
+ capbrackets(bracketstring, fp);
+ for (; *fp != '}'; *np++ = *fp++);
+ *np++ = '}';
+ }
+ if (*fp) fp++;
+ *np = 0;
+ for (np = string13; *fp && isalpha(*fp) == 0 && *fp != '{';
+ *np++ = *fp++);
+ if (*fp != '{')
+ *np++ = *fp;
+ else {
+ capbrackets(bracketstring, fp);
+ for (; *fp != '}'; *np++ = *fp++);
+ *np++ = '}';
+ }
+ *np = 0;
+ }
+ if (getname(2, field, temp, ref) == 0) {
+ strcpy (field, string11);
+ strcat (field, string12);
+ strcat (field, string13);
+ }
+ else {
+ fp = field;
+ for (np = string2; *fp; fp++) {
+ if (isupper(*fp)) {
+ *np++ = *fp;
+ break;
+ }
+ if (*fp == '{') {
+ if (capbrackets(bracketstring, fp) == 0)
+ for (; *fp != '}'; fp++);
+ else {
+ for (; *fp != '}'; *np++ = *fp++);
+ *np++ = '}';
+ break;
+ }
+ }
+ }
+ *np = 0;
+ if (getname(3, field, temp, ref) == 0) {
+ strcpy (field, string11);
+ strcat (field, string12);
+ strcat (field, string2);
+ }
+ else {
+ fp = field;
+ for (np = string3; *fp; fp++) {
+ if (isupper(*fp)) {
+ *np++ = *fp;
+ break;
+ }
+ if (*fp == '{') {
+ if (capbrackets(bracketstring, fp) == 0)
+ for (; *fp != '}'; fp++);
+ else {
+ for (; *fp != '}'; *np++ = *fp++);
+ *np++ = '}';
+ break;
+ }
+ }
+ }
+ *np = 0;
+ strcpy (field, string11);
+ strcat (field, string2);
+ strcat (field, string3);
+ }
+ }
+ for (i=0; field[i]; i++)
+ *cp++ = field[i];
+ return (cp);
+}
+
+/* names style
+ 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 *nmdt(cp, ref)
+ char *cp, ref[];
+{ char name1[100], name2[100], name3[100], temp[100], *fp;
+ int getname();
+
+ if (getname(1, name1, temp, ref)) {
+ for (fp = name1; *fp; )
+ *cp++ = *fp++;
+ if (getname(4, name3, temp, ref)) {
+ for (fp = " et al."; *fp; )
+ *cp++ = *fp++;
+ }
+ else if (getname(2, name2, temp, ref)) {
+ if (getname(3, name3, temp, ref)) {
+ for (fp = "\\Namecomma "; *fp; )
+ *cp++ = *fp++;
+ for (fp = name2; *fp; )
+ *cp++ = *fp++;
+ for (fp = "\\Nameandd "; *fp; )
+ *cp++ = *fp++;
+ for (fp = name3; *fp; )
+ *cp++ = *fp++;
+ }
+ else {
+ for (fp = "\\Nameand "; *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[];
+{ char *p, *q, temp[100];
+ int n, len, i, getname();
+
+ field[0] = 0;
+ if (*ptr == 'A')
+ getname(1, field, temp, ref);
+ else
+ for (p = ref; *p; p++)
+ if (*p == '%' && *(p+1) == *ptr) {
+ for (p = p + 2; *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[];
+{ char *p;
+ int m;
+
+ last[0]='\0';
+ first[0]='\0';
+ 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 && n == 1) { /* 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()
+{ int i, j;
+ char adstr[2];
+
+ for (i = 0; i < numrefs; i = j) {
+ j = i + 1;
+ if (strcmp(citestr[i], citestr[j])==0) {
+ adstr[0] = 'a'; adstr[1] = 0;
+ for (j = i+1; strcmp(citestr[i], citestr[j]) == 0; j++) {
+ adstr[0] = 'a' + (j-i);
+ strcat(citestr[j], adstr);
+ if (j == numrefs)
+ break;
+ }
+ adstr[0] = 'a';
+ strcat(citestr[i], adstr);
+ }
+ }
+}
+
+
+/* bldname - build a name field
+ doing abbreviations, reversals, and caps/small caps
+*/
+ bldnm1(first, last, name, reverse)
+ char *first, *last, name[];
+ int reverse;
+{
+ char newfirst[120], newlast[120], *p, *q, *f, *l, *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, "\\Initgap ");
+ flag = true;
+ *q++ = *p;
+ q = scopy(q, "\\Initper ");
+ }
+ 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, "\\bgroup\\Smallcapsfont ");
+ flag = 2;
+ *q++ = (*p++ - 'a') + 'A';
+ }
+ else {
+ if (flag == 2)
+ q = scopy(q, "\\egroup ");
+ flag = 1;
+ *q++ = *p++;
+ }
+ if (flag == 2)
+ q = scopy(q, "\\egroup ");
+ *q = 0;
+ l = newlast;
+ }
+ else
+ l = last;
+
+ if (f[0] == 0)
+ sprintf(name, "%s\n", l);
+ else if (reverse)
+ sprintf(name, "%s%cRevcomma %s\n", l, '\\', f);
+ else
+ sprintf(name, "%s %s\n", f, l);
+}
+
+/* capssmallcaps - put field in capssmallcaps */
+ capssmallcaps(stringout, stringin)
+ char *stringout, *stringin;
+{ char *p, *q, *scopy();
+ int flag, bflag;
+ char bracketfield[REFSIZE];
+
+ p = stringin;
+ q = stringout;
+ *q = 0;
+ flag = 0; /* 1 - printing cap, 2 - printing small */
+ while (*p) {
+ if (*p == '\\')
+ *p++;
+ if (*p == ' ') {
+ if (flag == 2)
+ q = scopy(q, "\\egroup{}");
+ flag = 1;
+/* *q++ = '\\';*/
+ *q++ = ' ';
+ p++;
+ }
+ if (*p == '~') {
+ if (flag == 2)
+ q = scopy(q, "\\egroup{}");
+ flag = 1;
+ *q++ = *p++;
+ }
+ if (*p == '{')
+ bflag = capbrackets(bracketfield, p);
+ else
+ bflag = 1;
+ if (islower(*p) || bflag == 0) {
+ if (flag != 2)
+ q = scopy(q, "\\bgroup\\Smallcapsfont ");
+ flag = 2;
+ if (*p == '{') {
+ q = scopy(q, bracketfield);
+ for (; *p != '}'; p++);
+ p++;
+ }
+ else
+ *q++ = (*p++ - 'a') + 'A';
+ }
+ else {
+ if (flag == 2)
+ q = scopy(q, "\\egroup{}");
+ flag = 1;
+ if (*p == '{') {
+ q = scopy(q, bracketfield);
+ for (; *p != '}'; p++);
+ p++;
+ }
+ else
+ *q++ = *p++;
+ }
+ }
+ if (flag == 2)
+ q = scopy(q, "\\egroup{}");
+ *q = 0;
+}
+
+ bldname(first, last, name, reverse, capsmcap)
+ char *first, *last, name[];
+ int reverse, capsmcap;
+{
+ char newfirst[120], newlast[120], *p, *q, *f, *f1, *l, *scopy();
+ char newnewfirst[120];
+ char bracketfield[20];
+ int flag;
+ int hflag, bflag;
+
+ if (abbrev) {
+ p = first;
+ q = newfirst;
+ flag = false;
+ hflag = false;
+ bflag = false;
+ while (*p) {
+ while (*p == ' ')
+ p++;
+ if (*p == '{')
+ bflag = capbrackets(bracketfield, p);
+ if (isupper(*p) || bflag) {
+ if (flag && hflag) /* between initial gap */
+ q = scopy(q, "\\Initgap ");
+ flag = true;
+ if (bflag) {
+ for (; *p != '}'; *q++ = *p++);
+ bflag = false;
+ }
+ *q++ = *p;
+ for (p++;; p++) {
+ if (isupper(*p)) {
+ hflag = true;
+ break;
+ }
+ else if (*p == '-' || *p == '\'') {
+ hflag = false;
+ *q++ = *p++;
+ break;
+ }
+ else if (*p == '.' ) {
+ hflag = true;
+ q = scopy(q, "\\Initper ");
+ p++;
+ break;
+ }
+ else if (*p == ' ' ) {
+ hflag = true;
+ q = scopy(q, "\\Initper ");
+ p++;
+ break;
+ }
+ else if (*p == '~') {
+ hflag = true;
+ q = scopy(q, "\\Initper ");
+ p++;
+ break;
+ }
+ else if (*p == 0) {
+ q = scopy(q, "\\Initper ");
+ break;
+ }
+ else if (*p == '{') {
+ bflag = capbrackets(bracketfield, p);
+ if (bflag) break;
+ else
+ for (; *p != '}'; p++);
+ }
+ }
+ }
+ else
+ *q++ = *p++;
+ }
+ *q = 0;
+ f1 = newfirst;
+ }
+ else
+ f1 = first;
+
+ if (capsmcap) {
+ capssmallcaps(newlast,last);
+ l = newlast;
+ if (abbrev == 0) {
+ capssmallcaps(newnewfirst,f1);
+ f = newnewfirst;
+ }
+ else
+ f = f1;
+ }
+ else {
+ f = f1;
+ l = last;
+ }
+ if (f[0] == 0)
+ sprintf(name, "%s\n", l);
+ else if (reverse)
+ sprintf(name, "%s%cRevcomma %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];
+ char *s1;
+
+ if (num <= numrev || abbrev || capsmcap) {
+ breakname(line, first, last);
+ bldname(first, last, line, num <= numrev, capsmcap);
+ }
+ for (s1=line;*s1!='\0';s1++) if (*s1=='\n') *s1='\0';
+ if (num == 1) {
+ fprintf(ofd, "}%c\n%cdef%c%ctest{ }", '\%', '\\', '\\', c);
+ if (index(trailstr, c))
+ fprintf(ofd, "%cdef%c%ctrail{%c}",
+ '\\', '\\', c, line[strlen(line)-2]);
+ fprintf(ofd, "%cdef%c%cstr{%s",
+ '\\', '\\', c, line);
+ }
+ else if (num < max)
+ fprintf(ofd, "%c\n %c%ccomma %s", '\%', '\\', c, line);
+ else if (max == 2)
+ fprintf(ofd, "%c\n %c%cand %s", '\%', '\\', c, line);
+ else
+ fprintf(ofd, "%c\n %c%candd %s", '\%', '\\', c, line);
+}
+
+/* doline - actually print out a line of reference information */
+ doline(c, line, numauths, maxauths, numeds, maxeds,
+ numrevs, maxrevs, numtrans, maxtrans, ofd)
+ char c, *line;
+ int numauths, maxauths, numeds, maxeds;
+ int numrevs, maxrevs, numtrans, maxtrans;
+ FILE *ofd;
+{
+ char *s1;
+ char *dbldash();
+ char line1[REFSIZE];
+
+ switch(c) {
+ case '\\':
+ case '\%':
+ for (s1=line;*s1!='\0';s1++)
+ if (*s1=='\n') *s1='\0';
+ fprintf(ofd, "}%c\n%c%s{", '\%', c , line);
+ break;
+
+ case 'A':
+ prtauth(c, line, numauths, maxauths, ofd, abbrev, capsmcap, numrev);
+ break;
+
+ case 'E':
+ if (maxauths)
+ prtauth(c, line, numeds, maxeds, ofd, edabbrev, edcapsmcap,
+ ednumrev);
+ else
+ prtauth(c, line, numeds, maxeds, ofd, abbrev, capsmcap, numrev);
+ break;
+
+ case 'a':
+ prtauth(c, line, numtrans, maxtrans, ofd, edabbrev, edcapsmcap,
+ ednumrev);
+ break;
+
+ case 'e':
+ prtauth(c, line, numrevs, maxrevs, ofd, edabbrev, edcapsmcap,
+ ednumrev);
+ break;
+
+ case 'P':
+ case 'p':
+ fprintf(ofd, "}%c\n%cdef%c%ctest{ }", '\%', '\\', '\\', c);
+ if (onepage) {
+ opage(line);
+ fprintf(ofd, "%cdef%c%ccnt{}", '\\', '\\', c);
+ }
+ else {
+ if (index (line, '-')) {
+ line = dbldash(line);
+ fprintf(ofd, "%cdef%c%ccnt{ }", '\\', '\\', c);
+ }
+ else
+ fprintf(ofd, "%cdef%c%ccnt{}", '\\', '\\', c);
+ }
+ if (index(trailstr, c))
+ fprintf(ofd, "%cdef%c%ctrail{%c}%c\n", '\\', '\\', c,
+ line[strlen(line)-2], '\%');
+ for (s1 = line; *s1 != '\0'; s1++)
+ if (*s1=='\n') *s1='\0';
+ fprintf(ofd, "%cdef%c%cstr{%s", '\\', '\\', c,
+ line);
+ break;
+
+ case 'F':
+ case 'K': break;
+
+ case 'I':
+ if (numauths == 0 && numeds == 0 && capsmcap) {
+ capssmallcaps(line1, line);
+ strcpy(line, line1);
+ }
+
+ default:
+ fprintf(ofd, "}%c\n%cdef%c%ctest{ }", '\%', '\\', '\\', c);
+ if (index(trailstr, c))
+ fprintf(ofd, "%cdef%c%ctrail{%c}", '\\', '\\', c,
+ line[strlen(line)-2]);
+ for (s1=line;*s1!='\0';s1++)
+ if (*s1=='\n') *s1='\0';
+ fprintf(ofd, "%cdef%c%cstr{%s",
+ '\\', '\\', c, line);
+ }
+}
+
+/* dbldash - double the hyphen in the P field (see below)*/
+ char *dbldash(line)
+ char *line;
+{ char *p;
+ char newline[120];
+
+ for (p = newline; *line && *line != '-'; *p++ = *line++);
+ if (*line == 0) return (line);
+ if (*++line != '-')
+ *p++ = '-';
+ *p++ = '-';
+ for (*p = *line; *line; *p++ = *line++);
+ *p='\0';
+ return (newline);
+}
+
+/* following works on some machines where above fails
+char *dbldash(line)
+char *line;
+{ char *p;
+ static char newline[120];
+
+ for (p = newline; *p = *line; ++p, ++line)
+ if (line[0] == '-' && line[1] != '-')
+ *++p = '-';
+ return(newline);
+} */
+
+/* opage - print only first page number */
+ int opage(line)
+ char *line;
+{ char *p;
+
+ for (p = line; *p && *p != '-'; *p++);
+ *p=0;
+}
+
+/* dumpref - dump reference number i */
+ dumpref(i, ofd)
+ int i;
+ FILE *ofd;
+{ char ref[REFSIZE], *p, line[REFSIZE];
+ int numauths, maxauths, numeds, maxeds;
+ int numrevs, maxrevs, numtrans, maxtrans;
+
+ fprintf(ofd, "%cbgroup%cResetstrings%c\n", '\\', '\\' , '\%');
+ rdref(refspos[i], ref);
+ maxauths = maxeds = maxrevs = maxtrans = 0;
+ numauths = numeds = numrevs = numtrans = 0;
+ for (p = ref; *p; p++)
+ if (*p == '%')
+ if (*(p+1) == 'A') maxauths++;
+ else if (*(p+1) == 'E') maxeds++;
+ else if (*(p+1) == 'a') maxtrans++;
+ else if (*(p+1) == 'e') maxrevs++;
+ if (loccit) {
+ if (locflag[i])
+ fprintf(ofd, "%cdef%cLoccittest{ }", '\\', '\\');
+ else
+ fprintf(ofd, "%cdef%cLoccittest{}", '\\', '\\');
+ if (ibidflag[i])
+ fprintf(ofd, "%cdef%cIbidtest{ }", '\\', '\\');
+ else
+ fprintf(ofd, "%cdef%cIbidtest{}", '\\', '\\');
+ }
+ else
+ fprintf(ofd, "%cdef%cLoccittest{}", '\\', '\\');
+ if (abbrev)
+ fprintf(ofd, "%cdef%cAbbtest{ }", '\\', '\\');
+ else
+ fprintf(ofd, "%cdef%cAbbtest{}", '\\', '\\');
+ if (capsmcap)
+ fprintf(ofd, "%cdef%cCapssmallcapstest{ }", '\\', '\\');
+ else
+ fprintf(ofd, "%cdef%cCapssmallcapstest{}", '\\', '\\');
+ if (edabbrev)
+ fprintf(ofd, "%cdef%cEdabbtest{ }", '\\', '\\');
+ else
+ fprintf(ofd, "%cdef%cEdabbtest{}", '\\', '\\');
+ if (edcapsmcap)
+ fprintf(ofd, "%cdef%cEdcapsmallcapstest{ }", '\\', '\\');
+ else
+ fprintf(ofd, "%cdef%cEdcapsmallcapstest{}", '\\', '\\');
+ if (underline)
+ fprintf(ofd, "%cdef%cUnderlinetest{ }%c\n", '\\', '\\', '\%');
+ else
+ fprintf(ofd, "%cdef%cUnderlinetest{}%c\n", '\\', '\\', '\%');
+ fprintf(ofd, "%cdef%cNoArev{%d}%cdef%cNoErev{%d}%cdef%cAcnt{%d}",
+ '\\', '\\', numrev, '\\', '\\', ednumrev, '\\', '\\', maxauths);
+ fprintf(ofd, "%cdef%cEcnt{%d}%cdef%cacnt{%d}%cdef%cecnt{%d}%c\n",
+ '\\', '\\', maxeds, '\\', '\\',
+ maxtrans, '\\', '\\', maxrevs, '\%');
+ fprintf(ofd, "%cdef%cFtest{ }", '\\', '\\');
+ if (index(trailstr, 'F'))
+ fprintf(ofd, "%cdef%c%ctrail{%c}", '\\', '\\', 'F',
+ citestr[i][strlen(citestr[i])-1]);
+ fprintf(ofd, "%cdef%cFstr{%s", '\\', '\\',
+ citestr[i]);
+ fseek(rfd, (long) refspos[i], 0);
+ while (fgets(line, REFSIZE, rfd) != NULL) {
+ if (line[0] == 0) break;
+ else if (line[0] == '%') {
+ for (p = &line[2]; *p == ' '; p++);
+ if (line[1] == 'A') numauths++;
+ else if (line[1] == 'E') numeds++;
+ else if (line[1] == 'a') numtrans++;
+ else if (line[1] == 'e') numrevs++;
+
+ doline(line[1], p, numauths, maxauths, numeds, maxeds,
+ numrevs, maxrevs, numtrans, maxtrans, ofd);
+ }
+ else if (line[0] == '\\')
+ fprintf(ofd, "}%c\n%s{", '\%', line);
+ else fprintf(ofd, "%s", line);
+ }
+ if (underline && unlmark[i-1]) {
+ if (maxauths) fprintf (ofd, "}%c\n%cdef%cAstr{%cUnderlinemark", '\%',
+ '\\', '\\', '\\');
+ else if (maxeds) fprintf (ofd, "}%c\n%cdef%cEstr{%cUnderlinemark", '\%',
+ '\\', '\\', '\\');
+ else fprintf (ofd, "}%c\n%cdef%cIstr{%cUnderlinemark", '\%', '\\',
+ '\\', '\\');
+ }
+ fprintf(ofd, "}%c\n%cRefformat%cegroup%c\n", '\%', '\\', '\\', '\%');
+ if ((!foot) && (!c0)) fprintf(ofd, "\n");
+}