/contrib/groff/src/preproc/refer/refer.cpp
C++ | 1242 lines | 1159 code | 49 blank | 34 comment | 402 complexity | 869a4955fe18e747a2b03997d9f74efe MD5 | raw file
1// -*- C++ -*- 2/* Copyright (C) 1989-1992, 2000, 2001, 2002, 2004 3 Free Software Foundation, Inc. 4 Written by James Clark (jjc@jclark.com) 5 6This file is part of groff. 7 8groff is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13groff is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License along 19with groff; see the file COPYING. If not, write to the Free Software 20Foundation, 51 Franklin St - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22#include "refer.h" 23#include "refid.h" 24#include "ref.h" 25#include "token.h" 26#include "search.h" 27#include "command.h" 28 29extern "C" const char *Version_string; 30 31const char PRE_LABEL_MARKER = '\013'; 32const char POST_LABEL_MARKER = '\014'; 33const char LABEL_MARKER = '\015'; // label_type is added on 34 35#define FORCE_LEFT_BRACKET 04 36#define FORCE_RIGHT_BRACKET 010 37 38static FILE *outfp = stdout; 39 40string capitalize_fields; 41string reverse_fields; 42string abbreviate_fields; 43string period_before_last_name = ". "; 44string period_before_initial = "."; 45string period_before_hyphen = ""; 46string period_before_other = ". "; 47string sort_fields; 48int annotation_field = -1; 49string annotation_macro; 50string discard_fields = "XYZ"; 51string pre_label = "\\*([."; 52string post_label = "\\*(.]"; 53string sep_label = ", "; 54int accumulate = 0; 55int move_punctuation = 0; 56int abbreviate_label_ranges = 0; 57string label_range_indicator; 58int label_in_text = 1; 59int label_in_reference = 1; 60int date_as_label = 0; 61int sort_adjacent_labels = 0; 62// Join exactly two authors with this. 63string join_authors_exactly_two = " and "; 64// When there are more than two authors join the last two with this. 65string join_authors_last_two = ", and "; 66// Otherwise join authors with this. 67string join_authors_default = ", "; 68string separate_label_second_parts = ", "; 69// Use this string to represent that there are other authors. 70string et_al = " et al"; 71// Use et al only if it can replace at least this many authors. 72int et_al_min_elide = 2; 73// Use et al only if the total number of authors is at least this. 74int et_al_min_total = 3; 75 76 77int compatible_flag = 0; 78 79int short_label_flag = 0; 80 81static int recognize_R1_R2 = 1; 82 83search_list database_list; 84int search_default = 1; 85static int default_database_loaded = 0; 86 87static reference **citation = 0; 88static int ncitations = 0; 89static int citation_max = 0; 90 91static reference **reference_hash_table = 0; 92static int hash_table_size; 93static int nreferences = 0; 94 95static int need_syncing = 0; 96string pending_line; 97string pending_lf_lines; 98 99static void output_pending_line(); 100static unsigned immediately_handle_reference(const string &); 101static void immediately_output_references(); 102static unsigned store_reference(const string &); 103static void divert_to_temporary_file(); 104static reference *make_reference(const string &, unsigned *); 105static void usage(FILE *stream); 106static void do_file(const char *); 107static void split_punct(string &line, string &punct); 108static void output_citation_group(reference **v, int n, label_type, FILE *fp); 109static void possibly_load_default_database(); 110 111int main(int argc, char **argv) 112{ 113 program_name = argv[0]; 114 static char stderr_buf[BUFSIZ]; 115 setbuf(stderr, stderr_buf); 116 outfp = stdout; 117 int finished_options = 0; 118 int bib_flag = 0; 119 int done_spec = 0; 120 121 for (--argc, ++argv; 122 !finished_options && argc > 0 && argv[0][0] == '-' 123 && argv[0][1] != '\0'; 124 argv++, argc--) { 125 const char *opt = argv[0] + 1; 126 while (opt != 0 && *opt != '\0') { 127 switch (*opt) { 128 case 'C': 129 compatible_flag = 1; 130 opt++; 131 break; 132 case 'B': 133 bib_flag = 1; 134 label_in_reference = 0; 135 label_in_text = 0; 136 ++opt; 137 if (*opt == '\0') { 138 annotation_field = 'X'; 139 annotation_macro = "AP"; 140 } 141 else if (csalnum(opt[0]) && opt[1] == '.' && opt[2] != '\0') { 142 annotation_field = opt[0]; 143 annotation_macro = opt + 2; 144 } 145 opt = 0; 146 break; 147 case 'P': 148 move_punctuation = 1; 149 opt++; 150 break; 151 case 'R': 152 recognize_R1_R2 = 0; 153 opt++; 154 break; 155 case 'S': 156 // Not a very useful spec. 157 set_label_spec("(A.n|Q)', '(D.y|D)"); 158 done_spec = 1; 159 pre_label = " ("; 160 post_label = ")"; 161 sep_label = "; "; 162 opt++; 163 break; 164 case 'V': 165 verify_flag = 1; 166 opt++; 167 break; 168 case 'f': 169 { 170 const char *num = 0; 171 if (*++opt == '\0') { 172 if (argc > 1) { 173 num = *++argv; 174 --argc; 175 } 176 else { 177 error("option `f' requires an argument"); 178 usage(stderr); 179 exit(1); 180 } 181 } 182 else { 183 num = opt; 184 opt = 0; 185 } 186 const char *ptr; 187 for (ptr = num; *ptr; ptr++) 188 if (!csdigit(*ptr)) { 189 error("bad character `%1' in argument to -f option", *ptr); 190 break; 191 } 192 if (*ptr == '\0') { 193 string spec; 194 spec = '%'; 195 spec += num; 196 spec += '\0'; 197 set_label_spec(spec.contents()); 198 done_spec = 1; 199 } 200 break; 201 } 202 case 'b': 203 label_in_text = 0; 204 label_in_reference = 0; 205 opt++; 206 break; 207 case 'e': 208 accumulate = 1; 209 opt++; 210 break; 211 case 'c': 212 capitalize_fields = ++opt; 213 opt = 0; 214 break; 215 case 'k': 216 { 217 char buf[5]; 218 if (csalpha(*++opt)) 219 buf[0] = *opt++; 220 else { 221 if (*opt != '\0') 222 error("bad field name `%1'", *opt++); 223 buf[0] = 'L'; 224 } 225 buf[1] = '~'; 226 buf[2] = '%'; 227 buf[3] = 'a'; 228 buf[4] = '\0'; 229 set_label_spec(buf); 230 done_spec = 1; 231 } 232 break; 233 case 'a': 234 { 235 const char *ptr; 236 for (ptr = ++opt; *ptr; ptr++) 237 if (!csdigit(*ptr)) { 238 error("argument to `a' option not a number"); 239 break; 240 } 241 if (*ptr == '\0') { 242 reverse_fields = 'A'; 243 reverse_fields += opt; 244 } 245 opt = 0; 246 } 247 break; 248 case 'i': 249 linear_ignore_fields = ++opt; 250 opt = 0; 251 break; 252 case 'l': 253 { 254 char buf[INT_DIGITS*2 + 11]; // A.n+2D.y-3%a 255 strcpy(buf, "A.n"); 256 if (*++opt != '\0' && *opt != ',') { 257 char *ptr; 258 long n = strtol(opt, &ptr, 10); 259 if (n == 0 && ptr == opt) { 260 error("bad integer `%1' in `l' option", opt); 261 opt = 0; 262 break; 263 } 264 if (n < 0) 265 n = 0; 266 opt = ptr; 267 sprintf(strchr(buf, '\0'), "+%ld", n); 268 } 269 strcat(buf, "D.y"); 270 if (*opt == ',') 271 opt++; 272 if (*opt != '\0') { 273 char *ptr; 274 long n = strtol(opt, &ptr, 10); 275 if (n == 0 && ptr == opt) { 276 error("bad integer `%1' in `l' option", opt); 277 opt = 0; 278 break; 279 } 280 if (n < 0) 281 n = 0; 282 sprintf(strchr(buf, '\0'), "-%ld", n); 283 opt = ptr; 284 if (*opt != '\0') 285 error("argument to `l' option not of form `m,n'"); 286 } 287 strcat(buf, "%a"); 288 if (!set_label_spec(buf)) 289 assert(0); 290 done_spec = 1; 291 } 292 break; 293 case 'n': 294 search_default = 0; 295 opt++; 296 break; 297 case 'p': 298 { 299 const char *filename = 0; 300 if (*++opt == '\0') { 301 if (argc > 1) { 302 filename = *++argv; 303 argc--; 304 } 305 else { 306 error("option `p' requires an argument"); 307 usage(stderr); 308 exit(1); 309 } 310 } 311 else { 312 filename = opt; 313 opt = 0; 314 } 315 database_list.add_file(filename); 316 } 317 break; 318 case 's': 319 if (*++opt == '\0') 320 sort_fields = "AD"; 321 else { 322 sort_fields = opt; 323 opt = 0; 324 } 325 accumulate = 1; 326 break; 327 case 't': 328 { 329 char *ptr; 330 long n = strtol(opt, &ptr, 10); 331 if (n == 0 && ptr == opt) { 332 error("bad integer `%1' in `t' option", opt); 333 opt = 0; 334 break; 335 } 336 if (n < 1) 337 n = 1; 338 linear_truncate_len = int(n); 339 opt = ptr; 340 break; 341 } 342 case '-': 343 if (opt[1] == '\0') { 344 finished_options = 1; 345 opt++; 346 break; 347 } 348 if (strcmp(opt,"-version")==0) { 349 case 'v': 350 printf("GNU refer (groff) version %s\n", Version_string); 351 exit(0); 352 break; 353 } 354 if (strcmp(opt,"-help")==0) { 355 usage(stdout); 356 exit(0); 357 break; 358 } 359 // fall through 360 default: 361 error("unrecognized option `%1'", *opt); 362 usage(stderr); 363 exit(1); 364 break; 365 } 366 } 367 } 368 if (!done_spec) 369 set_label_spec("%1"); 370 if (argc <= 0) { 371 if (bib_flag) 372 do_bib("-"); 373 else 374 do_file("-"); 375 } 376 else { 377 for (int i = 0; i < argc; i++) { 378 if (bib_flag) 379 do_bib(argv[i]); 380 else 381 do_file(argv[i]); 382 } 383 } 384 if (accumulate) 385 output_references(); 386 if (fflush(stdout) < 0) 387 fatal("output error"); 388 return 0; 389} 390 391static void usage(FILE *stream) 392{ 393 fprintf(stream, 394"usage: %s [-benvCPRS] [-aN] [-cXYZ] [-fN] [-iXYZ] [-kX] [-lM,N] [-p file]\n" 395" [-sXYZ] [-tN] [-BL.M] [files ...]\n", 396 program_name); 397} 398 399static void possibly_load_default_database() 400{ 401 if (search_default && !default_database_loaded) { 402 char *filename = getenv("REFER"); 403 if (filename) 404 database_list.add_file(filename); 405 else 406 database_list.add_file(DEFAULT_INDEX, 1); 407 default_database_loaded = 1; 408 } 409} 410 411static int is_list(const string &str) 412{ 413 const char *start = str.contents(); 414 const char *end = start + str.length(); 415 while (end > start && csspace(end[-1])) 416 end--; 417 while (start < end && csspace(*start)) 418 start++; 419 return end - start == 6 && memcmp(start, "$LIST$", 6) == 0; 420} 421 422static void do_file(const char *filename) 423{ 424 FILE *fp; 425 if (strcmp(filename, "-") == 0) { 426 fp = stdin; 427 } 428 else { 429 errno = 0; 430 fp = fopen(filename, "r"); 431 if (fp == 0) { 432 error("can't open `%1': %2", filename, strerror(errno)); 433 return; 434 } 435 } 436 current_filename = filename; 437 fprintf(outfp, ".lf 1 %s\n", filename); 438 string line; 439 current_lineno = 0; 440 for (;;) { 441 line.clear(); 442 for (;;) { 443 int c = getc(fp); 444 if (c == EOF) { 445 if (line.length() > 0) 446 line += '\n'; 447 break; 448 } 449 if (invalid_input_char(c)) 450 error("invalid input character code %1", c); 451 else { 452 line += c; 453 if (c == '\n') 454 break; 455 } 456 } 457 int len = line.length(); 458 if (len == 0) 459 break; 460 current_lineno++; 461 if (len >= 2 && line[0] == '.' && line[1] == '[') { 462 int start_lineno = current_lineno; 463 int start_of_line = 1; 464 string str; 465 string post; 466 string pre(line.contents() + 2, line.length() - 3); 467 for (;;) { 468 int c = getc(fp); 469 if (c == EOF) { 470 error_with_file_and_line(current_filename, start_lineno, 471 "missing `.]' line"); 472 break; 473 } 474 if (start_of_line) 475 current_lineno++; 476 if (start_of_line && c == '.') { 477 int d = getc(fp); 478 if (d == ']') { 479 while ((d = getc(fp)) != '\n' && d != EOF) { 480 if (invalid_input_char(d)) 481 error("invalid input character code %1", d); 482 else 483 post += d; 484 } 485 break; 486 } 487 if (d != EOF) 488 ungetc(d, fp); 489 } 490 if (invalid_input_char(c)) 491 error("invalid input character code %1", c); 492 else 493 str += c; 494 start_of_line = (c == '\n'); 495 } 496 if (is_list(str)) { 497 output_pending_line(); 498 if (accumulate) 499 output_references(); 500 else 501 error("found `$LIST$' but not accumulating references"); 502 } 503 else { 504 unsigned flags = (accumulate 505 ? store_reference(str) 506 : immediately_handle_reference(str)); 507 if (label_in_text) { 508 if (accumulate && outfp == stdout) 509 divert_to_temporary_file(); 510 if (pending_line.length() == 0) { 511 warning("can't attach citation to previous line"); 512 } 513 else 514 pending_line.set_length(pending_line.length() - 1); 515 string punct; 516 if (move_punctuation) 517 split_punct(pending_line, punct); 518 int have_text = pre.length() > 0 || post.length() > 0; 519 label_type lt = label_type(flags & ~(FORCE_LEFT_BRACKET 520 |FORCE_RIGHT_BRACKET)); 521 if ((flags & FORCE_LEFT_BRACKET) || !have_text) 522 pending_line += PRE_LABEL_MARKER; 523 pending_line += pre; 524 char lm = LABEL_MARKER + (int)lt; 525 pending_line += lm; 526 pending_line += post; 527 if ((flags & FORCE_RIGHT_BRACKET) || !have_text) 528 pending_line += POST_LABEL_MARKER; 529 pending_line += punct; 530 pending_line += '\n'; 531 } 532 } 533 need_syncing = 1; 534 } 535 else if (len >= 4 536 && line[0] == '.' && line[1] == 'l' && line[2] == 'f' 537 && (compatible_flag || line[3] == '\n' || line[3] == ' ')) { 538 pending_lf_lines += line; 539 line += '\0'; 540 if (interpret_lf_args(line.contents() + 3)) 541 current_lineno--; 542 } 543 else if (recognize_R1_R2 544 && len >= 4 545 && line[0] == '.' && line[1] == 'R' && line[2] == '1' 546 && (compatible_flag || line[3] == '\n' || line[3] == ' ')) { 547 line.clear(); 548 int start_of_line = 1; 549 int start_lineno = current_lineno; 550 for (;;) { 551 int c = getc(fp); 552 if (c != EOF && start_of_line) 553 current_lineno++; 554 if (start_of_line && c == '.') { 555 c = getc(fp); 556 if (c == 'R') { 557 c = getc(fp); 558 if (c == '2') { 559 c = getc(fp); 560 if (compatible_flag || c == ' ' || c == '\n' || c == EOF) { 561 while (c != EOF && c != '\n') 562 c = getc(fp); 563 break; 564 } 565 else { 566 line += '.'; 567 line += 'R'; 568 line += '2'; 569 } 570 } 571 else { 572 line += '.'; 573 line += 'R'; 574 } 575 } 576 else 577 line += '.'; 578 } 579 if (c == EOF) { 580 error_with_file_and_line(current_filename, start_lineno, 581 "missing `.R2' line"); 582 break; 583 } 584 if (invalid_input_char(c)) 585 error("invalid input character code %1", int(c)); 586 else { 587 line += c; 588 start_of_line = c == '\n'; 589 } 590 } 591 output_pending_line(); 592 if (accumulate) 593 output_references(); 594 else 595 nreferences = 0; 596 process_commands(line, current_filename, start_lineno + 1); 597 need_syncing = 1; 598 } 599 else { 600 output_pending_line(); 601 pending_line = line; 602 } 603 } 604 need_syncing = 0; 605 output_pending_line(); 606 if (fp != stdin) 607 fclose(fp); 608} 609 610class label_processing_state { 611 enum { 612 NORMAL, 613 PENDING_LABEL, 614 PENDING_LABEL_POST, 615 PENDING_LABEL_POST_PRE, 616 PENDING_POST 617 } state; 618 label_type type; // type of pending labels 619 int count; // number of pending labels 620 reference **rptr; // pointer to next reference 621 int rcount; // number of references left 622 FILE *fp; 623 int handle_pending(int c); 624public: 625 label_processing_state(reference **, int, FILE *); 626 ~label_processing_state(); 627 void process(int c); 628}; 629 630static void output_pending_line() 631{ 632 if (label_in_text && !accumulate && ncitations > 0) { 633 label_processing_state state(citation, ncitations, outfp); 634 int len = pending_line.length(); 635 for (int i = 0; i < len; i++) 636 state.process((unsigned char)(pending_line[i])); 637 } 638 else 639 put_string(pending_line, outfp); 640 pending_line.clear(); 641 if (pending_lf_lines.length() > 0) { 642 put_string(pending_lf_lines, outfp); 643 pending_lf_lines.clear(); 644 } 645 if (!accumulate) 646 immediately_output_references(); 647 if (need_syncing) { 648 fprintf(outfp, ".lf %d %s\n", current_lineno, current_filename); 649 need_syncing = 0; 650 } 651} 652 653static void split_punct(string &line, string &punct) 654{ 655 const char *start = line.contents(); 656 const char *end = start + line.length(); 657 const char *ptr = start; 658 const char *last_token_start = 0; 659 for (;;) { 660 if (ptr >= end) 661 break; 662 last_token_start = ptr; 663 if (*ptr == PRE_LABEL_MARKER || *ptr == POST_LABEL_MARKER 664 || (*ptr >= LABEL_MARKER && *ptr < LABEL_MARKER + N_LABEL_TYPES)) 665 ptr++; 666 else if (!get_token(&ptr, end)) 667 break; 668 } 669 if (last_token_start) { 670 const token_info *ti = lookup_token(last_token_start, end); 671 if (ti->is_punct()) { 672 punct.append(last_token_start, end - last_token_start); 673 line.set_length(last_token_start - start); 674 } 675 } 676} 677 678static void divert_to_temporary_file() 679{ 680 outfp = xtmpfile(); 681} 682 683static void store_citation(reference *ref) 684{ 685 if (ncitations >= citation_max) { 686 if (citation == 0) 687 citation = new reference*[citation_max = 100]; 688 else { 689 reference **old_citation = citation; 690 citation_max *= 2; 691 citation = new reference *[citation_max]; 692 memcpy(citation, old_citation, ncitations*sizeof(reference *)); 693 a_delete old_citation; 694 } 695 } 696 citation[ncitations++] = ref; 697} 698 699static unsigned store_reference(const string &str) 700{ 701 if (reference_hash_table == 0) { 702 reference_hash_table = new reference *[17]; 703 hash_table_size = 17; 704 for (int i = 0; i < hash_table_size; i++) 705 reference_hash_table[i] = 0; 706 } 707 unsigned flags; 708 reference *ref = make_reference(str, &flags); 709 ref->compute_hash_code(); 710 unsigned h = ref->hash(); 711 reference **ptr; 712 for (ptr = reference_hash_table + (h % hash_table_size); 713 *ptr != 0; 714 ((ptr == reference_hash_table) 715 ? (ptr = reference_hash_table + hash_table_size - 1) 716 : --ptr)) 717 if (same_reference(**ptr, *ref)) 718 break; 719 if (*ptr != 0) { 720 if (ref->is_merged()) 721 warning("fields ignored because reference already used"); 722 delete ref; 723 ref = *ptr; 724 } 725 else { 726 *ptr = ref; 727 ref->set_number(nreferences); 728 nreferences++; 729 ref->pre_compute_label(); 730 ref->compute_sort_key(); 731 if (nreferences*2 >= hash_table_size) { 732 // Rehash it. 733 reference **old_table = reference_hash_table; 734 int old_size = hash_table_size; 735 hash_table_size = next_size(hash_table_size); 736 reference_hash_table = new reference*[hash_table_size]; 737 int i; 738 for (i = 0; i < hash_table_size; i++) 739 reference_hash_table[i] = 0; 740 for (i = 0; i < old_size; i++) 741 if (old_table[i]) { 742 reference **p; 743 for (p = (reference_hash_table 744 + (old_table[i]->hash() % hash_table_size)); 745 *p; 746 ((p == reference_hash_table) 747 ? (p = reference_hash_table + hash_table_size - 1) 748 : --p)) 749 ; 750 *p = old_table[i]; 751 } 752 a_delete old_table; 753 } 754 } 755 if (label_in_text) 756 store_citation(ref); 757 return flags; 758} 759 760unsigned immediately_handle_reference(const string &str) 761{ 762 unsigned flags; 763 reference *ref = make_reference(str, &flags); 764 ref->set_number(nreferences); 765 if (label_in_text || label_in_reference) { 766 ref->pre_compute_label(); 767 ref->immediate_compute_label(); 768 } 769 nreferences++; 770 store_citation(ref); 771 return flags; 772} 773 774static void immediately_output_references() 775{ 776 for (int i = 0; i < ncitations; i++) { 777 reference *ref = citation[i]; 778 if (label_in_reference) { 779 fputs(".ds [F ", outfp); 780 const string &label = ref->get_label(NORMAL_LABEL); 781 if (label.length() > 0 782 && (label[0] == ' ' || label[0] == '\\' || label[0] == '"')) 783 putc('"', outfp); 784 put_string(label, outfp); 785 putc('\n', outfp); 786 } 787 ref->output(outfp); 788 delete ref; 789 } 790 ncitations = 0; 791} 792 793static void output_citation_group(reference **v, int n, label_type type, 794 FILE *fp) 795{ 796 if (sort_adjacent_labels) { 797 // Do an insertion sort. Usually n will be very small. 798 for (int i = 1; i < n; i++) { 799 int num = v[i]->get_number(); 800 reference *temp = v[i]; 801 int j; 802 for (j = i - 1; j >= 0 && v[j]->get_number() > num; j--) 803 v[j + 1] = v[j]; 804 v[j + 1] = temp; 805 } 806 } 807 // This messes up if !accumulate. 808 if (accumulate && n > 1) { 809 // remove duplicates 810 int j = 1; 811 for (int i = 1; i < n; i++) 812 if (v[i]->get_label(type) != v[i - 1]->get_label(type)) 813 v[j++] = v[i]; 814 n = j; 815 } 816 string merged_label; 817 for (int i = 0; i < n; i++) { 818 int nmerged = v[i]->merge_labels(v + i + 1, n - i - 1, type, merged_label); 819 if (nmerged > 0) { 820 put_string(merged_label, fp); 821 i += nmerged; 822 } 823 else 824 put_string(v[i]->get_label(type), fp); 825 if (i < n - 1) 826 put_string(sep_label, fp); 827 } 828} 829 830 831label_processing_state::label_processing_state(reference **p, int n, FILE *f) 832: state(NORMAL), count(0), rptr(p), rcount(n), fp(f) 833{ 834} 835 836label_processing_state::~label_processing_state() 837{ 838 int handled = handle_pending(EOF); 839 assert(!handled); 840 assert(rcount == 0); 841} 842 843int label_processing_state::handle_pending(int c) 844{ 845 switch (state) { 846 case NORMAL: 847 break; 848 case PENDING_LABEL: 849 if (c == POST_LABEL_MARKER) { 850 state = PENDING_LABEL_POST; 851 return 1; 852 } 853 else { 854 output_citation_group(rptr, count, type, fp); 855 rptr += count ; 856 rcount -= count; 857 state = NORMAL; 858 } 859 break; 860 case PENDING_LABEL_POST: 861 if (c == PRE_LABEL_MARKER) { 862 state = PENDING_LABEL_POST_PRE; 863 return 1; 864 } 865 else { 866 output_citation_group(rptr, count, type, fp); 867 rptr += count; 868 rcount -= count; 869 put_string(post_label, fp); 870 state = NORMAL; 871 } 872 break; 873 case PENDING_LABEL_POST_PRE: 874 if (c >= LABEL_MARKER 875 && c < LABEL_MARKER + N_LABEL_TYPES 876 && c - LABEL_MARKER == type) { 877 count += 1; 878 state = PENDING_LABEL; 879 return 1; 880 } 881 else { 882 output_citation_group(rptr, count, type, fp); 883 rptr += count; 884 rcount -= count; 885 put_string(sep_label, fp); 886 state = NORMAL; 887 } 888 break; 889 case PENDING_POST: 890 if (c == PRE_LABEL_MARKER) { 891 put_string(sep_label, fp); 892 state = NORMAL; 893 return 1; 894 } 895 else { 896 put_string(post_label, fp); 897 state = NORMAL; 898 } 899 break; 900 } 901 return 0; 902} 903 904void label_processing_state::process(int c) 905{ 906 if (handle_pending(c)) 907 return; 908 assert(state == NORMAL); 909 switch (c) { 910 case PRE_LABEL_MARKER: 911 put_string(pre_label, fp); 912 state = NORMAL; 913 break; 914 case POST_LABEL_MARKER: 915 state = PENDING_POST; 916 break; 917 case LABEL_MARKER: 918 case LABEL_MARKER + 1: 919 count = 1; 920 state = PENDING_LABEL; 921 type = label_type(c - LABEL_MARKER); 922 break; 923 default: 924 state = NORMAL; 925 putc(c, fp); 926 break; 927 } 928} 929 930extern "C" { 931 932int rcompare(const void *p1, const void *p2) 933{ 934 return compare_reference(**(reference **)p1, **(reference **)p2); 935} 936 937} 938 939void output_references() 940{ 941 assert(accumulate); 942 if (!hash_table_size) { 943 error("nothing to reference (probably `bibliography' before `sort')"); 944 accumulate = 0; 945 nreferences = 0; 946 return; 947 } 948 if (nreferences > 0) { 949 int j = 0; 950 int i; 951 for (i = 0; i < hash_table_size; i++) 952 if (reference_hash_table[i] != 0) 953 reference_hash_table[j++] = reference_hash_table[i]; 954 assert(j == nreferences); 955 for (; j < hash_table_size; j++) 956 reference_hash_table[j] = 0; 957 qsort(reference_hash_table, nreferences, sizeof(reference*), rcompare); 958 for (i = 0; i < nreferences; i++) 959 reference_hash_table[i]->set_number(i); 960 compute_labels(reference_hash_table, nreferences); 961 } 962 if (outfp != stdout) { 963 rewind(outfp); 964 { 965 label_processing_state state(citation, ncitations, stdout); 966 int c; 967 while ((c = getc(outfp)) != EOF) 968 state.process(c); 969 } 970 ncitations = 0; 971 fclose(outfp); 972 outfp = stdout; 973 } 974 if (nreferences > 0) { 975 fputs(".]<\n", outfp); 976 for (int i = 0; i < nreferences; i++) { 977 if (sort_fields.length() > 0) 978 reference_hash_table[i]->print_sort_key_comment(outfp); 979 if (label_in_reference) { 980 fputs(".ds [F ", outfp); 981 const string &label = reference_hash_table[i]->get_label(NORMAL_LABEL); 982 if (label.length() > 0 983 && (label[0] == ' ' || label[0] == '\\' || label[0] == '"')) 984 putc('"', outfp); 985 put_string(label, outfp); 986 putc('\n', outfp); 987 } 988 reference_hash_table[i]->output(outfp); 989 delete reference_hash_table[i]; 990 reference_hash_table[i] = 0; 991 } 992 fputs(".]>\n", outfp); 993 nreferences = 0; 994 } 995 clear_labels(); 996} 997 998static reference *find_reference(const char *query, int query_len) 999{ 1000 // This is so that error messages look better. 1001 while (query_len > 0 && csspace(query[query_len - 1])) 1002 query_len--; 1003 string str; 1004 for (int i = 0; i < query_len; i++) 1005 str += query[i] == '\n' ? ' ' : query[i]; 1006 str += '\0'; 1007 possibly_load_default_database(); 1008 search_list_iterator iter(&database_list, str.contents()); 1009 reference_id rid; 1010 const char *start; 1011 int len; 1012 if (!iter.next(&start, &len, &rid)) { 1013 error("no matches for `%1'", str.contents()); 1014 return 0; 1015 } 1016 const char *end = start + len; 1017 while (start < end) { 1018 if (*start == '%') 1019 break; 1020 while (start < end && *start++ != '\n') 1021 ; 1022 } 1023 if (start >= end) { 1024 error("found a reference for `%1' but it didn't contain any fields", 1025 str.contents()); 1026 return 0; 1027 } 1028 reference *result = new reference(start, end - start, &rid); 1029 if (iter.next(&start, &len, &rid)) 1030 warning("multiple matches for `%1'", str.contents()); 1031 return result; 1032} 1033 1034static reference *make_reference(const string &str, unsigned *flagsp) 1035{ 1036 const char *start = str.contents(); 1037 const char *end = start + str.length(); 1038 const char *ptr = start; 1039 while (ptr < end) { 1040 if (*ptr == '%') 1041 break; 1042 while (ptr < end && *ptr++ != '\n') 1043 ; 1044 } 1045 *flagsp = 0; 1046 for (; start < ptr; start++) { 1047 if (*start == '#') 1048 *flagsp = (SHORT_LABEL | (*flagsp & (FORCE_RIGHT_BRACKET 1049 | FORCE_LEFT_BRACKET))); 1050 else if (*start == '[') 1051 *flagsp |= FORCE_LEFT_BRACKET; 1052 else if (*start == ']') 1053 *flagsp |= FORCE_RIGHT_BRACKET; 1054 else if (!csspace(*start)) 1055 break; 1056 } 1057 if (start >= end) { 1058 error("empty reference"); 1059 return new reference; 1060 } 1061 reference *database_ref = 0; 1062 if (start < ptr) 1063 database_ref = find_reference(start, ptr - start); 1064 reference *inline_ref = 0; 1065 if (ptr < end) 1066 inline_ref = new reference(ptr, end - ptr); 1067 if (inline_ref) { 1068 if (database_ref) { 1069 database_ref->merge(*inline_ref); 1070 delete inline_ref; 1071 return database_ref; 1072 } 1073 else 1074 return inline_ref; 1075 } 1076 else if (database_ref) 1077 return database_ref; 1078 else 1079 return new reference; 1080} 1081 1082static void do_ref(const string &str) 1083{ 1084 if (accumulate) 1085 (void)store_reference(str); 1086 else { 1087 (void)immediately_handle_reference(str); 1088 immediately_output_references(); 1089 } 1090} 1091 1092static void trim_blanks(string &str) 1093{ 1094 const char *start = str.contents(); 1095 const char *end = start + str.length(); 1096 while (end > start && end[-1] != '\n' && csspace(end[-1])) 1097 --end; 1098 str.set_length(end - start); 1099} 1100 1101void do_bib(const char *filename) 1102{ 1103 FILE *fp; 1104 if (strcmp(filename, "-") == 0) 1105 fp = stdin; 1106 else { 1107 errno = 0; 1108 fp = fopen(filename, "r"); 1109 if (fp == 0) { 1110 error("can't open `%1': %2", filename, strerror(errno)); 1111 return; 1112 } 1113 current_filename = filename; 1114 } 1115 enum { 1116 START, MIDDLE, BODY, BODY_START, BODY_BLANK, BODY_DOT 1117 } state = START; 1118 string body; 1119 for (;;) { 1120 int c = getc(fp); 1121 if (c == EOF) 1122 break; 1123 if (invalid_input_char(c)) { 1124 error("invalid input character code %1", c); 1125 continue; 1126 } 1127 switch (state) { 1128 case START: 1129 if (c == '%') { 1130 body = c; 1131 state = BODY; 1132 } 1133 else if (c != '\n') 1134 state = MIDDLE; 1135 break; 1136 case MIDDLE: 1137 if (c == '\n') 1138 state = START; 1139 break; 1140 case BODY: 1141 body += c; 1142 if (c == '\n') 1143 state = BODY_START; 1144 break; 1145 case BODY_START: 1146 if (c == '\n') { 1147 do_ref(body); 1148 state = START; 1149 } 1150 else if (c == '.') 1151 state = BODY_DOT; 1152 else if (csspace(c)) { 1153 state = BODY_BLANK; 1154 body += c; 1155 } 1156 else { 1157 body += c; 1158 state = BODY; 1159 } 1160 break; 1161 case BODY_BLANK: 1162 if (c == '\n') { 1163 trim_blanks(body); 1164 do_ref(body); 1165 state = START; 1166 } 1167 else if (csspace(c)) 1168 body += c; 1169 else { 1170 body += c; 1171 state = BODY; 1172 } 1173 break; 1174 case BODY_DOT: 1175 if (c == ']') { 1176 do_ref(body); 1177 state = MIDDLE; 1178 } 1179 else { 1180 body += '.'; 1181 body += c; 1182 state = c == '\n' ? BODY_START : BODY; 1183 } 1184 break; 1185 default: 1186 assert(0); 1187 } 1188 if (c == '\n') 1189 current_lineno++; 1190 } 1191 switch (state) { 1192 case START: 1193 case MIDDLE: 1194 break; 1195 case BODY: 1196 body += '\n'; 1197 do_ref(body); 1198 break; 1199 case BODY_DOT: 1200 case BODY_START: 1201 do_ref(body); 1202 break; 1203 case BODY_BLANK: 1204 trim_blanks(body); 1205 do_ref(body); 1206 break; 1207 } 1208 fclose(fp); 1209} 1210 1211// from the Dragon Book 1212 1213unsigned hash_string(const char *s, int len) 1214{ 1215 const char *end = s + len; 1216 unsigned h = 0, g; 1217 while (s < end) { 1218 h <<= 4; 1219 h += *s++; 1220 if ((g = h & 0xf0000000) != 0) { 1221 h ^= g >> 24; 1222 h ^= g; 1223 } 1224 } 1225 return h; 1226} 1227 1228int next_size(int n) 1229{ 1230 static const int table_sizes[] = { 1231 101, 503, 1009, 2003, 3001, 4001, 5003, 10007, 20011, 40009, 1232 80021, 160001, 500009, 1000003, 2000003, 4000037, 8000009, 1233 16000057, 32000011, 64000031, 128000003, 0 1234 }; 1235 1236 const int *p; 1237 for (p = table_sizes; *p <= n && *p != 0; p++) 1238 ; 1239 assert(*p != 0); 1240 return *p; 1241} 1242