diff options
author | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
---|---|---|
committer | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
commit | e0c6872cf40896c7be36b11dcc744620f10adf1d (patch) | |
tree | 60335e10d2f4354b0674ec22d7b53f0f8abee672 /biblio/tib/src/tibargs.c |
Initial commit
Diffstat (limited to 'biblio/tib/src/tibargs.c')
-rw-r--r-- | biblio/tib/src/tibargs.c | 1876 |
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"); +} |