![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prefer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / prefer / pref|
Return to prefer.c CVS log | Up to [Research Unix] / researchv10no / cmd / prefer / pref |
1.1 root 1: /*
2: * prefer - bibligraphy formatter
3: *
4: * Marcia Derr
5: * February 26, 1988
6: *
7: * input: (stdin) text containing prefer commands;
8: * output: (stdout) text with formatted citations and reference list
9: */
10:
11:
12:
13: #include <stdio.h>
14: #include <ctype.h>
15: #include <signal.h>
16: #include <sys/types.h>
17: #include <sys/stat.h>
18:
19: #ifdef SVR2 /* for UNIX System V */
20: #include <fcntl.h>
21: #define dup2(fildes, fildes2) close(fildes2);fcntl(fildes, F_DUPFD, fildes2)
22: #endif
23:
24: #include "streams.h"
25: #include "bib.h"
26:
27:
28: /* prefer commands */
29: #define REF_CITE "reference"
30: #define REF_STYLE "reference_style"
31: #define REF_PLACE "reference_placement"
32: #define REF_LIST "reference_list"
33: #define REF_DB "reference_database"
34: #define REF_INCLUDE "reference_include"
35:
36: /* control words to awk */
37: #define LETS_GO "%LETS_GO"
38: #define BEGIN_CITE "%BEGIN_CITE"
39: #define END_CITE "%END_CITE"
40: #define END_LIST "%END_LIST"
41: #define BIBLIO "%BIBLIO"
42: #define WHOLEBIB "%WHOLEBIB"
43: #define DBINCLUDE "%DBINCLUDE"
44: #define TYPE "%type"
45: #define TWOPASS "%TWOPASS\n"
46: #define ALSO "%also"
47: #define ALSOBEGIN "%also_begin"
48: #define ALSOEND "%also_end"
49:
50: #define DSTYLE "att" /* default style */
51: #define STYLEDIR "/styles/" /* style directory */
52: #define AWK "prefawk" /* special awk version */
53:
54: #define PREFERTMP "/tmp/preferXXXXXX"
55: #define MAXTOK 2500
56: #define BAR '|'
57: #define SLASH "/"
58:
59:
60: char stylename[maxstr] = "", /* set by style(), options */
61: awkline[MAXTOK]; /* for passing to/from awk */
62:
63: FILE *readtext, /* input text */
64: *writetext, /* output text */
65: *readbib, /* from awk */
66: *writebib, /* to awk */
67: *savefile; /* save original file when diverting to temp */
68:
69: int nroff = 0; /* nroff/troff flag */
70: int prmult = 0; /* print multiple references */
71: int rp = 0; /* released_paper/tm flag */
72: int sort = 0; /* order flag for reference_list */
73: char sortkey[maxstr] = ""; /* sort keys (eg adt) */
74: int haveeof = 0; /* flag eof in input file */
75:
76: char INDEX[maxstr]; /* name of index file */
77: char *DINPUT = BIBFILE; /* default input file */
78: char *divertname; /* two pass output is diverted here */
79: int pass = 0; /* indicates how many text passes are required */
80:
81: int argc;
82: char **argv;
83:
84: typedef enum {T_OPEN, T_CLOSE, T_COMMAND, T_REFER, T_WORD, T_EOF} TOKEN;
85: typedef enum {NORMAL, END, BIBLIST} bibflag;
86: enum {OK, NONE} awkstate = NONE;
87:
88:
89: char tok[MAXTOK]; /* for get_token */
90: TOKEN type; /* type returned by get_token */
91: char right; /* expected right delimeter */
92:
93: int cleanup();
94: char *strchr();
95: char *libpath();
96: TOKEN get_token();
97: char *mktemp(),
98: *locate(),
99: *gulpnl(),
100: *realloc(),
101: *strtok();
102:
103: #define leftdelim { \
104: if((type = get_token(tok,0)) != T_OPEN) { \
105: token_err(type,"Expecting left delimiter, got %s\n",tok); \
106: } \
107: right = getright(*tok); \
108: }
109:
110: #define rightdelim { \
111: if (type != T_CLOSE) \
112: token_err(type,"Expecting right delimeter, got %s\n",tok); \
113: post_command(); \
114: }
115:
116:
117: #define USAGE "prefer [-p database -s style -n -o key -r] [filename]\n"
118:
119: #ifdef _NFILE
120: #define FILENUM _NFILE
121: #else
122: #define FILENUM 20
123: #endif
124:
125:
126:
127: /*
128: * main - process prefer command line
129: */
130:
131: main(argcount,arglist)
132: int argcount;
133: char **arglist;
134: {
135:
136: /*
137: * set up signals, get options flags, and process command line arguments;
138: * make path names; setup I/O
139: */
140: if(signal(SIGINT, SIG_IGN) != SIG_IGN)
141: signal(SIGINT, cleanup);
142: signal(SIGQUIT, cleanup);
143: argc= argcount-1;
144: argv= arglist+1;
145:
146: strcpy(stylename,DSTYLE);
147: strcpy(INDEX,DINPUT);
148:
149: flags();
150: strcat(INDEX,".i");
151:
152: switch(argc) {
153: case 0:
154: readtext = stdin;
155: break;
156: case 1:
157: if((readtext = fopen(*argv,"r")) == NULL)
158: errexit(1,"error opening textfile %s\n",*argv);
159: break;
160: default:
161: errexit(1,USAGE);
162: }
163: writetext = stdout;
164:
165: /*
166: * now filter text for prefer commands
167: */
168: scan_text();
169: exit(0);
170:
171: }
172:
173:
174: /*
175: * get option flags
176: *
177: * -n set nroff flag (default troff)
178: * -o set sort flag for listing entire bibliographies (default sequence)
179: * -p pathname of database file (default BIBFILE)
180: * -r set rp (released paper) flag (default tm)
181: * -s set style (default att)
182: */
183:
184: # define operand (strlen(*argv+2)==0 ? (argv++,argc--,*argv) : *argv+2)
185:
186: flags()
187: {
188: for (; argc>0 && *argv[0]=='-'; argc--,argv++) {
189: switch ((*argv)[1]) {
190: case 'c':
191: case 'l': fprintf(stderr,USAGE);
192: break;
193: case 'm': prmult = 1;
194: break;
195: case 'n': nroff = 1;
196: break;
197: case 'o': sort = 1;
198: strcpy(sortkey,operand);
199: break;
200: case 'p': strcpy(INDEX,operand);
201: break;
202: case 'r': rp = 1;
203: break;
204: case 's': strcpy(stylename,operand);
205: break;
206: default: errexit(1, USAGE);
207: }
208: }
209: }
210:
211:
212: /*
213: * scan_text
214: *
215: * filter text for prefer commands (beginning with '|') and pass
216: * these off to do_command
217: */
218:
219: scan_text()
220: {
221: register int c, lastc;
222: char space[maxstr];
223:
224: lastc = 0;
225: for(;;) {
226:
227: /*
228: * if EOF, put out last saved character and space;
229: * finish processing references; close awk
230: */
231: if((c = gobble(space)) == EOF) {
232: if(lastc) putc(lastc,writetext);
233: lastc = 0;
234: if(*space) fputs(space, writetext);
235: if(awkstate == OK) {
236: biblio(END);
237: continue;
238: }
239: break;
240: }
241:
242: /*
243: * if a '|' then call do_command to process it
244: */
245: if(c == BAR) {
246:
247: /* checkfor preceding punctuation */
248:
249: if(lastc == 0134 && !*space) { /* backslash */
250: putc(lastc,writetext);
251: lastc = c;
252: continue;
253: }
254: if(!ismypunct(lastc)) {
255: if(lastc) {
256: putc(lastc,writetext);
257: lastc = 0;
258: }
259: }
260: do_command(lastc,space);
261: lastc = 0;
262: continue;
263: }
264:
265: if(lastc) putc(lastc,writetext);
266: if(*space) fputs(space,writetext);
267: lastc = c;
268: }
269: if(awkstate != NONE)
270: awkclose(readbib,writebib);
271: }
272:
273:
274: /*
275: * parse and execute prefer commands:
276: * |reference(...)
277: * |reference_style(..)
278: * |reference_database(...)
279: * |reference_list(...)
280: * |reference_placement
281: */
282:
283: do_command(ppunc,white)
284: int ppunc; /* punctuation preceding command */
285: char *white; /* white space preceding command */
286: {
287: register int cite_list, /* flag "in a citation list" */
288: c; /* for reading characters */
289: char space[maxstr]; /* gobbled space goes here */
290:
291: /*
292: * '|' has already been read; now read command and dispatch
293: */
294: cite_list = 0;
295: for(;;) {
296:
297: /*
298: * if space after BAR; finish citation list put out white space and punc
299: */
300: c=gobble(space);
301: if(*space) {
302: if(cite_list) {
303: end_citations(ppunc);
304: }
305: else {
306: if(ppunc) putc(ppunc,writetext);
307: if(*white) fputs(white,writetext);
308: }
309: putc(BAR,writetext);
310: fputs(space,writetext);
311: if(c != EOF) ungetc(c,readtext);
312: return;
313: }
314: /*
315: * at EOF, put out any citation list
316: */
317: if(c == EOF) {
318: if(cite_list) {
319: end_citations(ppunc);
320: cite_list == 0;
321: }
322: putc(BAR,writetext);
323: return;
324: }
325: else
326: ungetc(c,readtext);
327:
328:
329: /*
330: * process one or more citations
331: */
332: get_token(tok,0);
333: if(strcmp(tok,REF_CITE) == 0) {
334: *white = NULL;
335: citation();
336: cite_list = 1;
337: if((c = gobble(white)) == BAR)
338: continue;
339: else if (*white || !ismypunct(c)) {
340: end_citations(ppunc);
341: if(*white) fputs(white,writetext);
342: if(c != EOF) ungetc(c,readtext);
343: }
344: else {
345: if(ppunc) putc(ppunc,writetext);
346: end_citations(c);
347: }
348: return;
349: }
350:
351: /*
352: * end a list of citations or if no citation, put out punctuation
353: * and white space
354: */
355: if(cite_list) end_citations(ppunc);
356: else if (ppunc) putc(ppunc,writetext);
357: if (*white) {
358: fputs(white,writetext);
359: }
360:
361:
362: /*
363: * process style, placement, list, or db commands
364: */
365: if(strcmp(tok,REF_STYLE) == 0) {
366: style();
367: return;
368: }
369:
370: else if(strcmp(tok,REF_PLACE) == 0) {
371: if(awkstate == OK) biblio(NORMAL);
372: if(pass != 2) post_command();
373: return;
374: }
375:
376: else if(strcmp(tok,REF_LIST) == 0) {
377: bib_list();
378: return;
379: }
380:
381: else if(strcmp(tok,REF_INCLUDE) == 0) {
382: dbinclude();
383: return;
384: }
385:
386: else if(strcmp(tok,REF_DB) == 0) {
387: database();
388: return;
389: }
390:
391: /*
392: * no command so, put out bar and token
393: */
394: else {
395: putc(BAR,writetext);
396: fputs(tok,writetext);
397: return;
398: }
399: }
400:
401: }
402:
403:
404: /*
405: * ismypunct - test for puctuation
406: */
407:
408: ismypunct(c)
409: int c;
410: {
411: switch(c) {
412: case '.':
413: case ',':
414: case ';':
415: case ':':
416: case '?':
417: case '!':
418: case '"':
419: case '\'':
420: case '(':
421: return(1);
422: default:
423: return(0);
424: }
425: }
426:
427:
428: /*
429: * getright - given right delimeter, return left
430: */
431:
432: getright(left)
433: char left;
434: {
435: switch(left) {
436: case '(':
437: return(')');
438: case '{':
439: return('}');
440: case '[':
441: return(']');
442: case '<':
443: return('>');
444: }
445: return(0);
446: }
447:
448:
449: /*
450: * gobble - gobble up space to the the next non-space character
451: * return space and char
452: */
453:
454: gobble(space)
455: char *space; /* gobbled space returned here */
456: {
457: register int c; /* non-space character returned here */
458: register char *t;
459:
460: t = space;
461: while(isspace(c = mygetc(readtext))) {
462: *t++ = c;
463: }
464: *t = '\0';
465: return(c);
466: }
467:
468: /*
469: * gulp string up thru newline
470: */
471:
472: char *
473: gulpnl(space)
474: char *space;
475: {
476: register char *w;
477: for(w=space; *w;) {
478: if(*w++ == '\n')
479: break;
480: }
481: return(w);
482: }
483:
484:
485: post_command()
486: {
487: register int c; /* non-space character returned here */
488: while((c = mygetc(readtext)) != EOF) {
489: if (c == '\n')
490: break;
491: else if(!isspace(c)) {
492: errexit(1,"prefer command must end with newline\n");
493: }
494: }
495: }
496:
497: /*
498: * token
499: *
500: * tokenizer - returns:
501: * T_COMMAND anything after a |
502: * T_REFER a line starting with % to next % or right delim
503: * T_WORDS anthing
504: * T_OPEN left delimeter
505: * T_CLOSE right delimeter
506: * T_WORD anything else (non-space)
507: */
508:
509: TOKEN
510: get_token(value,right)
511: char *value; /* token value */
512: char right; /* expected right delimeter */
513: {
514: register int c; /* current character */
515: register char *v; /* current position in *value */
516: /* state of tokenizer */
517:
518: enum {BEGIN, ANYTHING, REFER, COMMAND, WORD, ENDREFER, CONTINUE} state;
519:
520:
521: if(right == 0) state = BEGIN;
522: else state = ANYTHING;
523: v = value;
524:
525: while((c = mygetc(readtext)) != EOF) {
526: switch(state) {
527:
528: case BEGIN:
529: switch(c) {
530: case '|':
531: *v = '\0';
532: ungetc(c,readtext);
533: return(T_COMMAND);
534: case '(':
535: case '[':
536: case '{':
537: case '<':
538: *v++ = c;
539: *v = '\0';
540: return(T_OPEN);
541: case ' ':
542: case '\n':
543: case '\t':
544: continue;
545: default:
546: *v++ = c;
547: state = COMMAND;
548: continue;
549: }
550:
551: case ANYTHING:
552: switch(c) {
553: case ' ':
554: case '\n':
555: case '\t':
556: continue;
557: case '%':
558: *v++ = c;
559: state = REFER;
560: continue;
561: case ')':
562: case ']':
563: case '}':
564: case '>':
565: if(c == right) {
566: *v++ = c;
567: *v = '\0';
568: return(T_CLOSE);
569: }
570: default:
571: *v++ = c;
572: state = WORD;
573: continue;
574: }
575:
576:
577: case COMMAND:
578: switch(c) {
579: case '|':
580: case ' ':
581: case '\n':
582: case '\t':
583: case '(':
584: case '[':
585: case '{':
586: case '<':
587: *v = '\0';
588: ungetc(c,readtext);
589: return(T_COMMAND);
590: default:
591: *v++ = c;
592: continue;
593: }
594:
595:
596: case WORD:
597: switch(c) {
598: case ' ':
599: case '\n':
600: case '\t':
601: case '%':
602: *v = '\0';
603: ungetc(c,readtext);
604: return(T_WORD);
605: case ')':
606: case ']':
607: case '}':
608: case '>':
609: if(c == right) {
610: *v = '\0';
611: ungetc(c,readtext);
612: return(T_WORD);
613: }
614: default:
615: *v++ = c;
616: continue;
617: }
618:
619:
620: case REFER:
621: switch(c) {
622: case '\n':
623: state = ENDREFER;
624: continue;
625: case '\\':
626: state = CONTINUE;
627: continue;
628: case ')':
629: case ']':
630: case '}':
631: case '>':
632: if(c == right) {
633: *v++ = '\n';
634: *v = '\0';
635: ungetc(c,readtext);
636: return(T_REFER);
637: }
638: default:
639: *v++ = c;
640: continue;
641: }
642:
643: case CONTINUE:
644: state = REFER;
645: if(c != '\n') {
646: *v++ = '\\';
647: *v++ = c;
648: }
649: continue;
650:
651:
652: case ENDREFER:
653: ungetc(c,readtext);
654: if(c == '%') {
655: *v++ = '\n';
656: *v = '\0';
657: return(T_REFER);
658: }
659: if(!isspace(c)) *v++ = ' ';
660: state = REFER;
661: continue;
662: }
663: }
664: haveeof++;
665: return(T_EOF);
666: }
667:
668:
669: /*
670: * token_err - print error message and exit
671: */
672:
673: token_err(type,s,tok)
674: TOKEN type; /* token type in error */
675: char *s, /* error message */
676: *tok; /* error token */
677: {
678: if(type == T_EOF)
679: errexit(1, "Unexpected EOF\n");
680: else
681: errexit(1,s,tok);
682: }
683:
684:
685: /*
686: * start_awk
687: * open awk and handshake to determine one pass or two
688: * (listing an entire bibliography is always one pass)
689: */
690:
691: start_awk(bflag)
692: bibflag bflag; /* flag complete bibliography listing (as
693: to normal citations and reference list */
694: {
695: char awkcmd[maxstr]; /* line to send to awk */
696: struct stat buf; /* for stating style file */
697:
698: /*
699: * open up awk style script
700: * checking to see style is one of the standards or user supplied
701: */
702:
703: strcpy(awkcmd,stylename);
704: if(stat(awkcmd,&buf)) {
705: strcpy(awkcmd,libpath(PLIB));
706: strcat(awkcmd,STYLEDIR);
707: strcat(awkcmd,stylename);
708: }
709: awkopen(awkcmd,&readbib,&writebib);
710:
711:
712: /*
713: * handshake, sending appropriate flags
714: */
715: fputs(LETS_GO,writebib);
716: if(nroff)
717: fputs(" nroff",writebib);
718: else
719: fputs(" troff",writebib);
720: if(rp)
721: fputs(" rp",writebib);
722: else
723: fputs(" tm",writebib);
724: putc('\n',writebib);
725: fflush(writebib);
726:
727: /*
728: * read back flag from awk that tells 1 pass or 2;
729: * divert text to temp file if two pass
730: */
731: if(fgets(awkcmd,maxstr,readbib) == NULL)
732: errexit(1,"start_awk: EOF or error from awk\n");
733: if(strcmp(awkcmd,TWOPASS) == 0) {
734: if(bflag != BIBLIST) {
735: pass = 1;
736: savefile = writetext;
737: divertname = mktemp(PREFERTMP);
738: writetext = fopen(divertname,"w");
739: }
740: }
741: else pass = 0;
742: awkstate = OK;
743: }
744:
745:
746: /*
747: * citation - process |reference():
748: * use search keys to lookup a complete reference in a bibliographic
749: * database; supplement citation with additional %refer lines;
750: * send all this to an awk for formatting
751: */
752:
753: citation()
754: {
755: char keys[MAXTOK]; /* store keys here */
756: int missing; /* missing flag */
757:
758: /*
759: * signal start of citation to awk
760: */
761: if(awkstate != OK) start_awk(NORMAL);
762: missing = 0;
763: if(pass != 2) {
764: fputs(BEGIN_CITE,writebib);
765: putc('\n',writebib);
766: }
767:
768: /*
769: * after left delmeter, get keys and search for corresponding reference
770: */
771: leftdelim;
772: *keys = '\0';
773: while((type = get_token(tok,right)) == T_WORD ) {
774: strcat(keys,tok);
775: strcat(keys," ");
776: }
777: if(*keys != '\0') {
778: missing = getref(keys);
779: }
780:
781: /*
782: * send %lines to awk to supplement citation
783: */
784: if(type == T_REFER) {
785: refline();
786: while((type = get_token(tok,right)) == T_REFER) {
787: refline();
788: }
789: }
790:
791: /*
792: * get right delimeter and signal the end of citation
793: */
794: if (type != T_CLOSE)
795: token_err(type,"Expecting right delimeter, got %s\n",tok);
796:
797: fputs(END_CITE,writebib);
798: if (pass == 2)
799: putc('2',writebib);
800: putc('\n',writebib);
801: fflush(writebib);
802:
803: /* if two pass, write marker in diverted text */
804:
805: if(pass == 1 && missing == 0)
806: fprintf(writetext,"|%s[]",REF_CITE);
807: }
808:
809:
810: /*
811: * pass a %refline to awk, processing %also lines appropriately
812: */
813:
814: refline()
815: {
816: if(strncmp(ALSOBEGIN,tok,strlen(ALSOBEGIN)) == 0) {
817: fputs(tok,writebib);
818: while((type = get_token(tok,right)) == T_REFER) {
819: if(strncmp(ALSOEND,tok,strlen(ALSOEND)) == 0) {
820: fputs(tok,writebib);
821: fflush(writebib);
822: break;
823: }
824: else if(strncmp(ALSO,tok,strlen(ALSO)) == 0)
825: seealso(tok);
826: else fputs(tok,writebib);
827: }
828: }
829: else if(strncmp(ALSO,tok,strlen(ALSO)) == 0) {
830: fputs(ALSOBEGIN,writebib);
831: putc('\n',writebib);
832: seealso(tok);
833: fputs(ALSOEND,writebib);
834: putc('\n',writebib);
835: fflush(writebib);
836: }
837: else
838: fputs(tok,writebib);
839: }
840:
841:
842: /*
843: * get reference corresponding to keywords and send it to awk
844: */
845:
846: int
847: getref(keys)
848: char *keys;
849: {
850: char *ref; /* points to complete reference */
851:
852: if((ref = locate(keys, INDEX)) == NULL) {
853: fprintf(stderr,"Can't open database for %s\n",keys);
854: fprintf(writebib,"%s not_found\n",TYPE);
855: return(1);
856: }
857: if(*ref != NULL) {
858: if(multiple(ref)) {
859: fprintf(stderr,"multiple references for %s\n",keys);
860: }
861: refwrite(ref);
862: free(ref);
863: return(0);
864:
865: }
866: else {
867: fprintf(stderr,"no reference found for %s\n",keys);
868: fprintf(writebib,"%s not_found\n",TYPE);
869: free(ref);
870: return(1);
871: }
872: }
873:
874:
875: /*
876: * check for multiple new references signalled by two newlines in a row
877: */
878:
879: multiple(ref)
880: char *ref;
881: {
882: register char *s;
883:
884: for(s = ref; *s; s++) {
885: if (*s == '\n') {
886: if(strncmp(s,"\n\n%",3) == 0) {
887: if(prmult) fprintf(stderr, "multiple references>>%s<<\n", ref);
888: *(++s) = '\0';
889: return(1);
890: }
891: }
892: }
893: return(0);
894: }
895:
896: /*
897: * refwrite - write out a single reference to awk
898: */
899:
900:
901: refwrite(ref)
902: char *ref;
903: {
904: register char *s, c;
905: char *t, sav;
906: int also;
907:
908: also = 0;
909: for(s = ref; *s; s++) {
910: if(*s == '\n') {
911: c = *(s+1);
912: if((c != '%') && c) {
913: if(!isspace(c)) {
914: fputc(' ',writebib);
915: continue;
916: }
917: continue;
918: }
919: }
920: if(*s == '%') {
921: if(strncmp(ALSOBEGIN,s,strlen(ALSOBEGIN)) == 0)
922: also++;
923: else if(strncmp(ALSOEND,s,strlen(ALSOEND)) == 0)
924: also--;
925: else if(strncmp(ALSO,s,strlen(ALSO)) == 0) {
926: for(t = s+1; *t && *t != '%'; ) {
927: if(*t++ == '\n')
928: if(*t == '\n')
929: break;
930: }
931: sav = *t;
932: *t = '\0';
933: if(also == 0) {
934: fputs(ALSOBEGIN,writebib);
935: putc('\n',writebib);
936: }
937: seealso(s);
938: if(also == 0) {
939: fputs(ALSOEND,writebib);
940: putc('\n',writebib);
941: }
942: fflush(writebib);
943: *t = sav;
944: s = t-1;
945: continue;
946: }
947: }
948: putc(*s,writebib);
949: }
950: }
951:
952:
953:
954: /*
955: * seealso - hunt for keywords in the "see also list"
956: */
957:
958: seealso(tok)
959: register char *tok;
960: {
961: char key[MAXTOK];
962: register char *k;
963:
964: *key = '\0';
965: if(k = strtok(tok+strlen(ALSO)+1," \t\n")) {
966: strcpy(key,k);
967: strcat(key," ");
968: while(k = strtok((char *)0," \t\n")) {
969: strcat(key,k);
970: strcat(key," ");
971: }
972: if(*key != '\0') {
973: getref(key);
974: }
975: }
976:
977: }
978:
979:
980:
981: /*
982: * end_citations - end a list of citations: read back citation
983: * list from awk
984: */
985:
986: end_citations(punc)
987: int punc; /* punctuation following or preceeding citation list */
988: {
989: register int l, k, j;
990:
991: fputs(END_LIST,writebib);
992: if(pass == 1)
993: putc('1',writebib);
994: if(punc)
995: fprintf(writebib," %c",(char)punc);
996: putc('\n',writebib);
997: fflush(writebib);
998:
999: while(fgets(awkline,MAXTOK,readbib)) {
1000: l = strlen(awkline);
1001: if(l >= (j=strlen(END_LIST)+1)) {
1002: k = l-j;
1003: if(strncmp(END_LIST,&awkline[k],j-1) == 0) {
1004: if(k != 0) {
1005: awkline[k] = '\0';
1006: fputs(awkline,writetext);
1007: }
1008: return;
1009: }
1010: }
1011: fputs(awkline,writetext);
1012: }
1013: errexit(1,"end_citations: EOF or error from awk\n");
1014: }
1015:
1016:
1017: /*
1018: * style - process |reference_style()
1019: * select a reference formatting style and set style flags
1020: */
1021:
1022: style()
1023: {
1024:
1025: /*
1026: * get left delimeter, then style name and options, then right delimeter
1027: */
1028: leftdelim;
1029: if ((type = get_token(tok,right)) == T_WORD) {
1030: if(strcmp(tok,"same")) {
1031: strcpy(stylename,tok);
1032: }
1033: while ((type = get_token(tok,right)) == T_WORD) {
1034: if(strcmp(tok,"nroff") == 0) {
1035: nroff = 1;
1036: }
1037: else if(strcmp(tok,"troff") == 0) {
1038: nroff = 0;
1039: }
1040: else if(strcmp(tok,"rp") == 0) {
1041: rp = 1;
1042: }
1043: else if(strcmp(tok,"tm") == 0) {
1044: rp = 0;
1045: }
1046: else if(strcmp(tok,"sequence") == 0) {
1047: sort = 0;
1048: }
1049: else if(strcmp(tok,"sort") == 0) {
1050: sort = 1;
1051: strcpy(sortkey,tok);
1052: }
1053: else {
1054: sort = 1;
1055: strcpy(sortkey,tok);
1056: }
1057: }
1058: }
1059: else {
1060: token_err(type,"Expecting style name, got %s\n", tok);
1061: }
1062:
1063: rightdelim;
1064:
1065: /*
1066: * finish previous citations before switching styles
1067: */
1068: if(awkstate == OK)
1069: biblio(END);
1070: }
1071:
1072:
1073: /*
1074: * database - process |reference_database
1075: * select a new bibliographic database
1076: */
1077:
1078: database()
1079: {
1080:
1081: /*
1082: * after left delimeter, get name of database, then right delim
1083: */
1084: leftdelim;
1085: if ((type = get_token(tok,right)) != T_WORD) {
1086: token_err(type,"Expecting name of database file, got %s\n",tok);
1087: }
1088: strcpy(INDEX,tok);
1089: strcat(INDEX,".i");
1090: type = get_token(tok,right);
1091: rightdelim;
1092:
1093: }
1094:
1095:
1096: /*
1097: * bib_list - process |reference_list()
1098: * format a bibliographic database
1099: * first finish processing for previous citations
1100: */
1101:
1102: bib_list()
1103: {
1104: static char dbstr[MAXTOK]; /* names of one or more bibs */
1105:
1106: /*
1107: * after left delimeter get bibliography name (can skip on second pass),
1108: * then right delimeter
1109: */
1110: leftdelim;
1111: if(pass != 2) {
1112: *dbstr = '\0';
1113: while ((type = get_token(tok,right)) == T_WORD) {
1114: strcat(dbstr,tok);
1115: strcat(dbstr," ");
1116: }
1117: }
1118: else type = get_token(tok,right);
1119: rightdelim;
1120:
1121: /*
1122: * format any previous citations then put out complete bibliography
1123: * (unless the second pass has just begun)
1124: */
1125: if(awkstate == OK) {
1126: biblio(BIBLIST);
1127: if(pass != 2) printbib(dbstr);
1128: }
1129: else {
1130: printbib(dbstr);
1131: }
1132: }
1133:
1134:
1135: /*
1136: * biblio - process reference_placement OR
1137: * finish processing citations before EOF, style change, or list command
1138: */
1139:
1140: biblio(bflag)
1141: bibflag bflag;
1142: {
1143:
1144: /*
1145: * signal bibliography to awk
1146: */
1147: fputs(BIBLIO,writebib);
1148: if(pass == 1)
1149: putc('1',writebib);
1150: if(bflag == END || bflag == BIBLIST)
1151: fputs(" no_bib",writebib);
1152: putc('\n',writebib);
1153: fflush(writebib);
1154:
1155: switch(pass) {
1156:
1157: /*
1158: * write out bib mark to diverted text, close, and reopen
1159: */
1160: case 1:
1161: pass = 2;
1162: if(bflag != END) {
1163: putc(BAR,writetext);
1164: if(bflag == BIBLIST)
1165: fprintf(writetext,"%s<>",REF_LIST);
1166: else
1167: fputs(REF_PLACE,writetext);
1168: putc('\n',writetext);
1169: }
1170: fclose(writetext);
1171: writetext = savefile;
1172: savefile = readtext;
1173: readtext = fopen(divertname,"r");
1174: haveeof = 0;
1175: return;
1176:
1177: /*
1178: * close and unlink text and resume reading in original file
1179: */
1180: case 2:
1181: fclose(readtext);
1182: unlink(divertname);
1183: readtext = savefile;
1184: haveeof = 0;
1185: pass = 0;
1186:
1187: /*
1188: * get formatted bibliography from awk
1189: */
1190: case 0:
1191: while(fgets(awkline,MAXTOK,readbib)) {
1192: if(strcmp("%END_BIB\n",awkline) == 0) {
1193: awkclose(readbib,writebib);
1194: return;
1195: }
1196: fputs(awkline,writetext);
1197: }
1198: errexit(1,"biblio: EOF or error from awk\n");
1199: }
1200: }
1201:
1202:
1203: /*
1204: * refread - read a single reference from a bibliography file
1205: */
1206: char *
1207: refread(bfile)
1208: FILE *bfile;
1209: {
1210: static char *buf = NULL;
1211: static unsigned size;
1212: register char *bp;
1213: int c, nextc;
1214:
1215: if(buf == NULL) {
1216: if((buf = malloc(MAXTOK)) == NULL)
1217: errexit(1, "malloc error in refread\n");
1218: size = MAXTOK;
1219: }
1220: bp = buf;
1221: while(isspace(c = getc(bfile))) {
1222: }
1223: if(c == EOF)
1224: return(NULL);
1225: *bp++ = c;
1226: while(c = getc(bfile)) {
1227: if(bp-buf == size-1) {
1228: if((buf = realloc(buf,size+MAXTOK)) == NULL)
1229: errexit(1, "malloc error in refread\n");
1230: bp = buf+size-1;
1231: size += MAXTOK;
1232: }
1233: if(c == EOF)
1234: break;
1235: *bp++ = c;
1236: if(c == '\n') {
1237: if((nextc = getc(bfile)) == '\n') {
1238: ungetc(nextc,bfile);
1239: break;
1240: }
1241: ungetc(nextc,bfile);
1242: }
1243: }
1244:
1245: if(bp == buf)
1246: return(NULL);
1247: if(*(bp-1) != '\n')
1248: *bp++ = '\n';
1249: *bp = '\0';
1250: return(buf);
1251: }
1252:
1253:
1254: /*
1255: * printbib - list one or more bibliographic databases
1256: */
1257: printbib(bibstr)
1258: char *bibstr; /* name of database */
1259: {
1260: register char *bp, *bn; /* ptrs to bibstr */
1261: FILE *bib; /* file ptr to database */
1262: register char *ref; /* points to a complete reference */
1263:
1264: /*
1265: * start awk, signalling that this is an entire bib (as opposed to citations)
1266: */
1267: start_awk(BIBLIST);
1268:
1269: /*
1270: * for each database; open the file, read each reference,
1271: * sending BEGIN and END markers
1272: */
1273: for(bp = bibstr; *bp; bp = bn) {
1274: if((bn = strchr(bp,' ')) != NULL)
1275: *bn++ = '\0';
1276: else break;
1277: if((bib = fopen(bp,"r")) == NULL) {
1278: fprintf(stderr,"cannot open database file %s\n",bp);
1279: continue;
1280: }
1281:
1282: strcpy(INDEX,bp);
1283: strcat(INDEX,".i");
1284:
1285: while(ref = refread(bib)) {
1286: fputs(BEGIN_CITE,writebib);
1287: putc('\n',writebib);
1288: refwrite(ref);
1289: fputs(END_CITE,writebib);
1290: putc('\n',writebib);
1291: }
1292: fflush(writebib);
1293: fclose(bib);
1294: }
1295: fflush(writebib);
1296:
1297: /*
1298: * signal awk to format the bibliography, read it back, and print it out
1299: */
1300: fputs(WHOLEBIB,writebib);
1301: if(sort) {
1302: putc(' ',writebib);
1303: fputs(sortkey,writebib);
1304: }
1305: putc('\n',writebib);
1306: fflush(writebib);
1307:
1308: while(fgets(awkline,MAXTOK,readbib)) {
1309: if(strcmp("%END_BIB\n",awkline) == 0) {
1310: awkclose(readbib,writebib);
1311: return;
1312: }
1313: fputs(awkline,writetext);
1314: }
1315: errexit(1,"wholebib: EOF or error from awk\n");
1316: }
1317:
1318:
1319: /*
1320: * dbinclude - include entries from one or more bibliography databases
1321: * in the reference section without citing in the text
1322: */
1323: dbinclude()
1324: {
1325: static char dbstr[MAXTOK]; /* names of one or more bibs */
1326: register char *bp, *bn; /* ptrs to bibstr */
1327: FILE *bib; /* file ptr to database */
1328: register char *ref; /* points to a complete reference */
1329: char saveindex[maxstr]; /* for saving name of current index */
1330: int includecnt; /* count number of included biblio entries */
1331:
1332: /*
1333: * after left delimeter get bibliography name (or include count on second pass),
1334: * then right delimeter
1335: */
1336: leftdelim;
1337: *dbstr = '\0';
1338: while ((type = get_token(tok,right)) == T_WORD) {
1339: strcat(dbstr,tok);
1340: strcat(dbstr," ");
1341: }
1342: rightdelim;
1343:
1344: if(pass != 2) {
1345:
1346: includecnt = 0;
1347: strcpy(saveindex,INDEX); /* save the current INDEX and start awk */
1348: if(awkstate != OK) start_awk(NORMAL);
1349: /*
1350: * for each database; open the file, read each reference,
1351: * sending BEGIN and END markers
1352: */
1353: for(bp = dbstr; *bp; bp = bn) {
1354: if((bn = strchr(bp,' ')) != NULL)
1355: *bn++ = '\0';
1356: else break;
1357: if((bib = fopen(bp,"r")) == NULL) {
1358: fprintf(stderr,"cannot open database file %s\n",bp);
1359: continue;
1360: }
1361:
1362: strcpy(INDEX,bp);
1363: strcat(INDEX,".i");
1364:
1365: while(ref = refread(bib)) {
1366: fputs(BEGIN_CITE,writebib);
1367: putc('\n',writebib);
1368: refwrite(ref);
1369: fputs("%no_cite\n",writebib);
1370: fputs(END_CITE,writebib);
1371: putc('\n',writebib);
1372: includecnt++;
1373: }
1374: fflush(writebib);
1375: fclose(bib);
1376: }
1377: end_citations('\0');
1378: strcpy(INDEX,saveindex);
1379: if(pass == 1) {
1380: fprintf(writetext,"|%s[%d]\n",REF_INCLUDE,includecnt);
1381: }
1382: }
1383: else {
1384: fputs(DBINCLUDE,writebib);
1385: putc(' ',writebib);
1386: fputs(dbstr,writebib); /* number of includes */
1387: putc('\n',writebib);
1388: fflush(writebib);
1389: }
1390: }
1391:
1392:
1393: mygetc(file)
1394: FILE *file;
1395: {
1396: int c;
1397:
1398: if(haveeof)
1399: return(EOF);
1400: else
1401: if((c = getc(file)) == EOF)
1402: haveeof++;
1403: return(c);
1404: }
1405:
1406: /*
1407: * errexit - print error message to stderr, unlink temporary file, exit
1408: */
1409:
1410: errexit(n,s1,s2,s3)
1411: int n;
1412: char *s1;
1413: {
1414: fprintf(stderr,s1,s2,s3);
1415: unlink(divertname);
1416: if(awkstate != NONE)
1417: awkclose(readbib,writebib);
1418: exit(n);
1419: }
1420:
1421:
1422: /*
1423: * awkopen - open up pipes to awk process
1424: */
1425:
1426: #define RDR 0
1427: #define WTR 1
1428:
1429: awkopen(awkfile,readawk,writeawk)
1430: char *awkfile;
1431: FILE **readawk,**writeawk;
1432: {
1433: int
1434: i, /* temp for closing fd's not used */
1435: fromawk[2], /* pipe file descriptors from awk */
1436: toawk[2],
1437: pid /* pipe file descriptors to awk */
1438: ;
1439: char temp[maxstr];
1440:
1441: /*
1442: * *** take care of forming pipes ***
1443: */
1444: if (pipe(fromawk) < 0)
1445: errexit(1, "can't open pipe from awk\n");
1446: if (pipe(toawk) < 0)
1447: errexit(1, "can't open pipe to awk\n");
1448:
1449: /*
1450: * *** make awk child ***
1451: */
1452: if ((pid = fork()) == 0) {
1453: close(fromawk[RDR]);
1454: dup2(fromawk[WTR], 1);
1455: close(toawk[WTR]);
1456: dup2(toawk[RDR], 0);
1457: for (i=3; i<FILENUM; i++)
1458: close(i);
1459:
1460: strcpy(temp,libpath(PLIB));
1461: strcat(temp,SLASH);
1462: strcat(temp,AWK);
1463: /*
1464: execlp(temp, AWK, "-R", awkfile, 0);
1465: */
1466: execlp(temp, AWK, "-f", awkfile, 0);
1467: errexit(1, "could not exec awk with script %s\n",awkfile);
1468: }
1469: if (pid == -1)
1470: errexit(1, "could not fork awk\n");
1471:
1472: /*
1473: * *** make out stream pointers ***
1474: */
1475: close(fromawk[WTR]);
1476: *readawk = fdopen(fromawk[RDR], "r");
1477: close(toawk[RDR]);
1478: *writeawk = fdopen(toawk[WTR], "w");
1479:
1480: }
1481:
1482:
1483: /*
1484: * awkclose - close pipes to awk
1485: */
1486:
1487: awkclose(read,write)
1488: FILE *read, *write;
1489: {
1490: fclose(write);
1491: fclose(read);
1492: awkstate = NONE;
1493: }
1494:
1495:
1496: /*
1497: * cleanup = after signal, get rid of temp file and close awk
1498: */
1499:
1500: cleanup()
1501: {
1502: signal(SIGINT, SIG_IGN);
1503: signal(SIGQUIT, SIG_IGN);
1504: unlink(divertname);
1505: if(awkstate != NONE)
1506: awkclose(readbib,writebib);
1507: exit(1);
1508: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.