Annotation of OpenXM/src/asir-doc/jtexindex/C/texindex.c, Revision 1.1
1.1 ! noro 1: /* Prepare TeX index dribble output into an actual index.
! 2:
! 3: Version 1.45
! 4:
! 5: Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
! 6:
! 7: This program is free software; you can redistribute it and/or modify
! 8: it under the terms of the GNU General Public License as published by
! 9: the Free Software Foundation; either version 2, or (at your option)
! 10: any later version.
! 11:
! 12: This program is distributed in the hope that it will be useful,
! 13: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 15: GNU General Public License for more details.
! 16:
! 17: You should have received a copy of the GNU General Public License
! 18: along with this program; if not, write to the Free Software
! 19: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307. */
! 20:
! 21: /*
! 22: 95.10.18 modified by Nobuyosi KAMEI <CXK03514@niftyserve.or.jp>
! 23: 日本語EUCが処理できるようにした。
! 24: 95.10.19 modified by K. Handa <handa@etl.go.jp>
! 25: \initial{...} の出力を調整。
! 26: */
! 27:
! 28:
! 29: #include <stdio.h>
! 30: #include <ctype.h>
! 31: #include <errno.h>
! 32: #include <assert.h>
! 33: #include "getopt.h"
! 34:
! 35: #define TEXINDEX_VERSION_STRING "GNU Texindex 2.0 for Texinfo release 3.4"
! 36: #define TEXINDEX_MODIFICATION_STRING "(modified for Japanese EUC encoding)"
! 37:
! 38: #if defined (emacs)
! 39: # include "../src/config.h"
! 40: /* Some s/os.h files redefine these. */
! 41: # undef read
! 42: # undef close
! 43: # undef write
! 44: # undef open
! 45: #endif
! 46:
! 47: #if defined (HAVE_STRING_H)
! 48: # include <string.h>
! 49: #endif /* HAVE_STRING_H */
! 50:
! 51: #if !defined (HAVE_STRCHR)
! 52: char *strrchr ();
! 53: #endif /* !HAVE_STRCHR */
! 54:
! 55: #if defined (STDC_HEADERS)
! 56: # include <stdlib.h>
! 57: #else /* !STDC_HEADERS */
! 58: char *getenv (), *malloc (), *realloc ();
! 59: #endif /* !STDC_HEADERS */
! 60:
! 61: #if defined (HAVE_UNISTD_H)
! 62: # include <unistd.h>
! 63: #else /* !HAVE_UNISTD_H */
! 64: off_t lseek ();
! 65: #endif /* !HAVE_UNISTD_H */
! 66:
! 67: #if !defined (HAVE_MEMSET)
! 68: #undef memset
! 69: #define memset(ptr, ignore, count) bzero (ptr, count)
! 70: #endif
! 71:
! 72:
! 73: char *mktemp ();
! 74:
! 75: #if defined (VMS)
! 76: # include <file.h>
! 77: # define TI_NO_ERROR ((1 << 28) | 1)
! 78: # define TI_FATAL_ERROR ((1 << 28) | 4)
! 79: # define unlink delete
! 80: #else /* !VMS */
! 81: # if defined (HAVE_SYS_FCNTL_H)
! 82: # include <sys/types.h>
! 83: # include <sys/fcntl.h>
! 84: # endif /* HAVE_SYS_FCNTL_H */
! 85:
! 86: # if defined (_AIX) || !defined (_POSIX_VERSION)
! 87: # include <sys/file.h>
! 88: # else /* !AIX && _POSIX_VERSION */
! 89: # if !defined (HAVE_SYS_FCNTL_H)
! 90: # include <fcntl.h>
! 91: # endif /* !HAVE_FCNTL_H */
! 92: # endif /* !_AIX && _POSIX_VERSION */
! 93: # define TI_NO_ERROR 0
! 94: # define TI_FATAL_ERROR 1
! 95: #endif /* !VMS */
! 96:
! 97: #if !defined (SEEK_SET)
! 98: # define SEEK_SET 0
! 99: # define SEEK_CUR 1
! 100: # define SEEK_END 2
! 101: #endif /* !SEEK_SET */
! 102:
! 103: #if !defined (errno)
! 104: extern int errno;
! 105: #endif
! 106: char *strerror ();
! 107:
! 108: /* When sorting in core, this structure describes one line
! 109: and the position and length of its first keyfield. */
! 110: struct lineinfo
! 111: {
! 112: u_short *text; /* The actual text of the line. */
! 113: union {
! 114: u_short *text; /* The start of the key (for textual comparison). */
! 115: long number; /* The numeric value (for numeric comparison). */
! 116: } key;
! 117: long keylen; /* Length of KEY field. */
! 118: };
! 119:
! 120: /* This structure describes a field to use as a sort key. */
! 121: struct keyfield
! 122: {
! 123: int startwords; /* Number of words to skip. */
! 124: int startchars; /* Number of additional chars to skip. */
! 125: int endwords; /* Number of words to ignore at end. */
! 126: int endchars; /* Ditto for characters of last word. */
! 127: char ignore_blanks; /* Non-zero means ignore spaces and tabs. */
! 128: char fold_case; /* Non-zero means case doesn't matter. */
! 129: char reverse; /* Non-zero means compare in reverse order. */
! 130: char numeric; /* Non-zeros means field is ASCII numeric. */
! 131: char positional; /* Sort according to file position. */
! 132: char braced; /* Count balanced-braced groupings as fields. */
! 133: };
! 134:
! 135: /* Vector of keyfields to use. */
! 136: struct keyfield keyfields[3];
! 137:
! 138: /* Number of keyfields stored in that vector. */
! 139: int num_keyfields = 3;
! 140:
! 141: /* Vector of input file names, terminated with a null pointer. */
! 142: char **infiles;
! 143:
! 144: /* Vector of corresponding output file names, or NULL, meaning default it
! 145: (add an `s' to the end). */
! 146: char **outfiles;
! 147:
! 148: /* Length of `infiles'. */
! 149: int num_infiles;
! 150:
! 151: /* Pointer to the array of pointers to lines being sorted. */
! 152: u_short **linearray;
! 153:
! 154: /* The allocated length of `linearray'. */
! 155: long nlines;
! 156:
! 157: /* Directory to use for temporary files. On Unix, it ends with a slash. */
! 158: char *tempdir;
! 159:
! 160: /* Start of filename to use for temporary files. */
! 161: char *tempbase;
! 162:
! 163: /* Number of last temporary file. */
! 164: int tempcount;
! 165:
! 166: /* Number of last temporary file already deleted.
! 167: Temporary files are deleted by `flush_tempfiles' in order of creation. */
! 168: int last_deleted_tempcount;
! 169:
! 170: /* During in-core sort, this points to the base of the data block
! 171: which contains all the lines of data. */
! 172: u_short *text_base;
! 173:
! 174: /* Additional command switches .*/
! 175:
! 176: /* Nonzero means do not delete tempfiles -- for debugging. */
! 177: int keep_tempfiles;
! 178:
! 179: /* The name this program was run with. */
! 180: char *program_name;
! 181:
! 182: /* 仮名文字の母音テーブル */
! 183: int Vowel_Table[0x60];
! 184:
! 185: /* Forward declarations of functions in this file. */
! 186:
! 187: void decode_command ();
! 188: void sort_in_core ();
! 189: void sort_offline ();
! 190: u_short **parsefile ();
! 191: u_short *find_field ();
! 192: u_short *find_pos ();
! 193: long find_value ();
! 194: u_short *find_braced_pos (u_short *str, int words, int chars, int ignore_blanks);
! 195: u_short *find_braced_end ();
! 196: void writelines (u_short **linearray, int nlines, FILE *ostream);
! 197: int compare_field ();
! 198: int compare_full ();
! 199: long readline ();
! 200: int merge_files ();
! 201: int merge_direct ();
! 202: void pfatal_with_name ();
! 203: void fatal ();
! 204: void error ();
! 205: void *xmalloc (), *xrealloc ();
! 206: char *concat ();
! 207: char *maketempname ();
! 208: void flush_tempfiles ();
! 209: char *tempcopy ();
! 210: static void memory_error();
! 211: static int wstrncmp(const u_short *s1, const u_short *s2, size_t n);
! 212: static int wfwrite(u_short *ptr, size_t size, size_t nmemb, FILE*stream);
! 213: static int wtoc(char *cptr, u_short const *ptr, int len);
! 214: static int Vowel_of(int c);
! 215: static void init_Vowel_Table(void);
! 216:
! 217: #define EUC_BYTE(c) (0x00A1 <= c && c <= 0x00FE)
! 218: #define G1_CHAR(c) (c & 0xFF00)
! 219:
! 220: #define MAX_IN_CORE_SORT 500000
! 221:
! 222: void
! 223: main (argc, argv)
! 224: int argc;
! 225: char **argv;
! 226: {
! 227: int i;
! 228:
! 229: tempcount = 0;
! 230: last_deleted_tempcount = 0;
! 231:
! 232: program_name = strrchr (argv[0], '/');
! 233: if (program_name != (char *)NULL)
! 234: program_name++;
! 235: else
! 236: program_name = argv[0];
! 237:
! 238: /* Describe the kind of sorting to do. */
! 239: /* The first keyfield uses the first braced field and folds case. */
! 240: keyfields[0].braced = 1;
! 241: keyfields[0].fold_case = 1;
! 242: keyfields[0].endwords = -1;
! 243: keyfields[0].endchars = -1;
! 244:
! 245: /* The second keyfield uses the second braced field, numerically. */
! 246: keyfields[1].braced = 1;
! 247: keyfields[1].numeric = 1;
! 248: keyfields[1].startwords = 1;
! 249: keyfields[1].endwords = -1;
! 250: keyfields[1].endchars = -1;
! 251:
! 252: /* The third keyfield (which is ignored while discarding duplicates)
! 253: compares the whole line. */
! 254: keyfields[2].endwords = -1;
! 255: keyfields[2].endchars = -1;
! 256:
! 257: decode_command (argc, argv);
! 258:
! 259: tempbase = mktemp (concat ("txiXXXXXX", "", ""));
! 260:
! 261: /* Process input files completely, one by one. */
! 262:
! 263: for (i = 0; i < num_infiles; i++)
! 264: {
! 265: int desc;
! 266: long ptr;
! 267: char *outfile;
! 268:
! 269: desc = open (infiles[i], O_RDONLY, 0);
! 270: if (desc < 0)
! 271: pfatal_with_name (infiles[i]);
! 272: lseek (desc, (off_t) 0, SEEK_END);
! 273: ptr = (long) lseek (desc, (off_t) 0, SEEK_CUR);
! 274:
! 275: close (desc);
! 276:
! 277: outfile = outfiles[i];
! 278: if (!outfile)
! 279: {
! 280: outfile = concat (infiles[i], "s", "");
! 281: }
! 282:
! 283: if (ptr < MAX_IN_CORE_SORT)
! 284: /* Sort a small amount of data. */
! 285: sort_in_core (infiles[i], ptr, outfile);
! 286: else
! 287: sort_offline (infiles[i], ptr, outfile);
! 288: }
! 289:
! 290: flush_tempfiles (tempcount);
! 291: exit (TI_NO_ERROR);
! 292: }
! 293:
! 294: typedef struct
! 295: {
! 296: char *long_name;
! 297: char *short_name;
! 298: int *variable_ref;
! 299: int variable_value;
! 300: char *arg_name;
! 301: char *doc_string;
! 302: } TEXINDEX_OPTION;
! 303:
! 304: TEXINDEX_OPTION texindex_options[] = {
! 305: { "--keep", "-k", &keep_tempfiles, 1, (char *)NULL,
! 306: "Keep temporary files around after processing" },
! 307: { "--no-keep", 0, &keep_tempfiles, 0, (char *)NULL,
! 308: "Do not keep temporary files around after processing (default)" },
! 309: { "--output", "-o", (int *)NULL, 0, "FILE",
! 310: "Send output to FILE" },
! 311: { "--version", (char *)NULL, (int *)NULL, 0, (char *)NULL,
! 312: "Show version information" },
! 313: { "--help", "-h", (int *)NULL, 0, (char *)NULL, "Produce this listing" },
! 314: { (char *)NULL, (char *)NULL, (int *)NULL, 0, (char *)NULL }
! 315: };
! 316:
! 317: void
! 318: usage (result_value)
! 319: int result_value;
! 320: {
! 321: register int i;
! 322:
! 323: fprintf (stderr, "Usage: %s [OPTIONS] FILE...\n", program_name);
! 324: fprintf (stderr, " Generate a permuted index for the TeX files given.\n");
! 325: fprintf (stderr, " Usually FILE... is `foo.??' for the source file `foo.tex'.\n");
! 326: fprintf (stderr, " The OPTIONS are:\n");
! 327:
! 328: for (i = 0; texindex_options[i].long_name; i++)
! 329: {
! 330: fprintf (stderr, " %s %s",
! 331: texindex_options[i].long_name,
! 332: texindex_options[i].arg_name ?
! 333: texindex_options[i].arg_name : "");
! 334:
! 335: if (texindex_options[i].short_name)
! 336: fprintf (stderr, " \n or %s %s",
! 337: texindex_options[i].short_name,
! 338: texindex_options[i].arg_name ?
! 339: texindex_options[i].arg_name : "");
! 340: fprintf (stderr, "\t%s\n", texindex_options[i].doc_string);
! 341: }
! 342: exit (result_value);
! 343: }
! 344:
! 345: /* Decode the command line arguments to set the parameter variables
! 346: and set up the vector of keyfields and the vector of input files. */
! 347:
! 348: void
! 349: decode_command (argc, argv)
! 350: int argc;
! 351: char **argv;
! 352: {
! 353: int arg_index = 1;
! 354: char **ip;
! 355: char **op;
! 356:
! 357: /* Store default values into parameter variables. */
! 358:
! 359: tempdir = getenv ("TMPDIR");
! 360: #ifdef VMS
! 361: if (tempdir == NULL)
! 362: tempdir = "sys$scratch:";
! 363: #else
! 364: if (tempdir == NULL)
! 365: tempdir = "/tmp/";
! 366: else
! 367: tempdir = concat (tempdir, "/", "");
! 368: #endif
! 369:
! 370: keep_tempfiles = 0;
! 371:
! 372: /* Allocate ARGC input files, which must be enough. */
! 373:
! 374: infiles = (char **) xmalloc (argc * sizeof (char *));
! 375: outfiles = (char **) xmalloc (argc * sizeof (char *));
! 376: ip = infiles;
! 377: op = outfiles;
! 378:
! 379: while (arg_index < argc)
! 380: {
! 381: char *arg = argv[arg_index++];
! 382:
! 383: if (*arg == '-')
! 384: {
! 385: if (strcmp (arg, "--version") == 0)
! 386: {
! 387: fprintf (stderr, "%s", TEXINDEX_VERSION_STRING);
! 388: #ifdef TEXINDEX_MODIFICATION_STRING
! 389: fprintf (stderr, " %s", TEXINDEX_MODIFICATION_STRING);
! 390: #endif
! 391: fprintf (stderr, "\n");
! 392: exit (0);
! 393: }
! 394: else if ((strcmp (arg, "--keep") == 0) ||
! 395: (strcmp (arg, "-k") == 0))
! 396: {
! 397: keep_tempfiles = 1;
! 398: }
! 399: else if ((strcmp (arg, "--help") == 0) ||
! 400: (strcmp (arg, "-h") == 0))
! 401: {
! 402: usage (0);
! 403: }
! 404: else if ((strcmp (arg, "--output") == 0) ||
! 405: (strcmp (arg, "-o") == 0))
! 406: {
! 407: if (argv[arg_index] != (char *)NULL)
! 408: {
! 409: arg_index++;
! 410: if (op > outfiles)
! 411: *(op - 1) = argv[arg_index];
! 412: }
! 413: else
! 414: usage (1);
! 415: }
! 416: else
! 417: usage (1);
! 418: }
! 419: else
! 420: {
! 421: *ip++ = arg;
! 422: *op++ = (char *)NULL;
! 423: }
! 424: }
! 425:
! 426: /* Record number of keyfields and terminate list of filenames. */
! 427: num_infiles = ip - infiles;
! 428: *ip = (char *)NULL;
! 429: if (num_infiles == 0)
! 430: usage (1);
! 431: }
! 432:
! 433: /* Return a name for a temporary file. */
! 434:
! 435: char *
! 436: maketempname (count)
! 437: int count;
! 438: {
! 439: char tempsuffix[10];
! 440: sprintf (tempsuffix, "%d", count);
! 441: return concat (tempdir, tempbase, tempsuffix);
! 442: }
! 443:
! 444: /* Delete all temporary files up to TO_COUNT. */
! 445:
! 446: void
! 447: flush_tempfiles (to_count)
! 448: int to_count;
! 449: {
! 450: if (keep_tempfiles)
! 451: return;
! 452: while (last_deleted_tempcount < to_count)
! 453: unlink (maketempname (++last_deleted_tempcount));
! 454: }
! 455:
! 456: /* Copy the input file open on IDESC into a temporary file
! 457: and return the temporary file name. */
! 458:
! 459: #define BUFSIZE 1024
! 460:
! 461: char *
! 462: tempcopy (idesc)
! 463: int idesc;
! 464: {
! 465: char *outfile = maketempname (++tempcount);
! 466: int odesc;
! 467: char buffer[BUFSIZE];
! 468:
! 469: odesc = open (outfile, O_WRONLY | O_CREAT, 0666);
! 470:
! 471: if (odesc < 0)
! 472: pfatal_with_name (outfile);
! 473:
! 474: while (1)
! 475: {
! 476: int nread = read (idesc, buffer, BUFSIZE);
! 477: write (odesc, buffer, nread);
! 478: if (!nread)
! 479: break;
! 480: }
! 481:
! 482: close (odesc);
! 483:
! 484: return outfile;
! 485: }
! 486:
! 487: /* Compare LINE1 and LINE2 according to the specified set of keyfields. */
! 488:
! 489: int
! 490: compare_full (line1, line2)
! 491: u_short **line1, **line2;
! 492: {
! 493: int i;
! 494:
! 495: /* Compare using the first keyfield;
! 496: if that does not distinguish the lines, try the second keyfield;
! 497: and so on. */
! 498:
! 499: for (i = 0; i < num_keyfields; i++)
! 500: {
! 501: long length1, length2;
! 502: u_short *start1 = find_field (&keyfields[i], *line1, &length1);
! 503: u_short *start2 = find_field (&keyfields[i], *line2, &length2);
! 504: int tem = compare_field (&keyfields[i], start1, length1, *line1 - text_base,
! 505: start2, length2, *line2 - text_base);
! 506: if (tem)
! 507: {
! 508: if (keyfields[i].reverse)
! 509: return -tem;
! 510: return tem;
! 511: }
! 512: }
! 513:
! 514: return 0; /* Lines match exactly. */
! 515: }
! 516:
! 517: /* Compare LINE1 and LINE2, described by structures
! 518: in which the first keyfield is identified in advance.
! 519: For positional sorting, assumes that the order of the lines in core
! 520: reflects their nominal order. */
! 521:
! 522: int
! 523: compare_prepared (line1, line2)
! 524: struct lineinfo *line1, *line2;
! 525: {
! 526: int i;
! 527: int tem;
! 528: u_short *text1, *text2;
! 529:
! 530: /* Compare using the first keyfield, which has been found for us already. */
! 531: if (keyfields->positional)
! 532: {
! 533: if (line1->text - text_base > line2->text - text_base)
! 534: tem = 1;
! 535: else
! 536: tem = -1;
! 537: }
! 538: else if (keyfields->numeric)
! 539: tem = line1->key.number - line2->key.number;
! 540: else
! 541: tem = compare_field (keyfields, line1->key.text, line1->keylen, 0,
! 542: line2->key.text, line2->keylen, 0);
! 543: if (tem)
! 544: {
! 545: if (keyfields->reverse)
! 546: return -tem;
! 547: return tem;
! 548: }
! 549:
! 550: text1 = line1->text;
! 551: text2 = line2->text;
! 552:
! 553: /* Compare using the second keyfield;
! 554: if that does not distinguish the lines, try the third keyfield;
! 555: and so on. */
! 556:
! 557: for (i = 1; i < num_keyfields; i++)
! 558: {
! 559: long length1, length2;
! 560: u_short *start1 = find_field (&keyfields[i], text1, &length1);
! 561: u_short *start2 = find_field (&keyfields[i], text2, &length2);
! 562: int tem = compare_field (&keyfields[i], start1, length1, text1 - text_base,
! 563: start2, length2, text2 - text_base);
! 564: if (tem)
! 565: {
! 566: if (keyfields[i].reverse)
! 567: return -tem;
! 568: return tem;
! 569: }
! 570: }
! 571:
! 572: return 0; /* Lines match exactly. */
! 573: }
! 574:
! 575: /* Like compare_full but more general.
! 576: You can pass any strings, and you can say how many keyfields to use.
! 577: POS1 and POS2 should indicate the nominal positional ordering of
! 578: the two lines in the input. */
! 579:
! 580: int
! 581: compare_general (str1, str2, pos1, pos2, use_keyfields)
! 582: u_short *str1, *str2;
! 583: long pos1, pos2;
! 584: int use_keyfields;
! 585: {
! 586: int i;
! 587:
! 588: /* Compare using the first keyfield;
! 589: if that does not distinguish the lines, try the second keyfield;
! 590: and so on. */
! 591:
! 592: for (i = 0; i < use_keyfields; i++)
! 593: {
! 594: long length1, length2;
! 595: u_short *start1 = find_field (&keyfields[i], str1, &length1);
! 596: u_short *start2 = find_field (&keyfields[i], str2, &length2);
! 597: int tem = compare_field (&keyfields[i], start1, length1, pos1,
! 598: start2, length2, pos2);
! 599: if (tem)
! 600: {
! 601: if (keyfields[i].reverse)
! 602: return -tem;
! 603: return tem;
! 604: }
! 605: }
! 606:
! 607: return 0; /* Lines match exactly. */
! 608: }
! 609:
! 610: /* Find the start and length of a field in STR according to KEYFIELD.
! 611: A pointer to the starting character is returned, and the length
! 612: is stored into the int that LENGTHPTR points to. */
! 613:
! 614: u_short *
! 615: find_field (keyfield, str, lengthptr)
! 616: struct keyfield *keyfield;
! 617: u_short *str;
! 618: long *lengthptr;
! 619: {
! 620: u_short *start;
! 621: u_short *end;
! 622: u_short *(*fun) ();
! 623:
! 624: if (keyfield->braced)
! 625: fun = find_braced_pos;
! 626: else
! 627: fun = find_pos;
! 628:
! 629: start = (*fun) (str, keyfield->startwords, keyfield->startchars,
! 630: keyfield->ignore_blanks);
! 631: if (keyfield->endwords < 0)
! 632: {
! 633: if (keyfield->braced)
! 634: end = find_braced_end (start);
! 635: else
! 636: {
! 637: end = start;
! 638: while (*end && *end != '\n')
! 639: end++;
! 640: }
! 641: }
! 642: else
! 643: {
! 644: end = (*fun) (str, keyfield->endwords, keyfield->endchars, 0);
! 645: if (end - str < start - str)
! 646: end = start;
! 647: }
! 648: *lengthptr = end - start;
! 649: return start;
! 650: }
! 651:
! 652: /* Return a pointer to a specified place within STR,
! 653: skipping (from the beginning) WORDS words and then CHARS chars.
! 654: If IGNORE_BLANKS is nonzero, we skip all blanks
! 655: after finding the specified word. */
! 656:
! 657: u_short *
! 658: find_pos (str, words, chars, ignore_blanks)
! 659: u_short *str;
! 660: int words, chars;
! 661: int ignore_blanks;
! 662: {
! 663: int i;
! 664: u_short *p = str;
! 665:
! 666: for (i = 0; i < words; i++)
! 667: {
! 668: u_short c;
! 669: /* Find next bunch of nonblanks and skip them. */
! 670: while ((c = *p) == ' ' || c == '\t')
! 671: p++;
! 672: while ((c = *p) && c != '\n' && !(c == ' ' || c == '\t'))
! 673: p++;
! 674: if (!*p || *p == '\n')
! 675: return p;
! 676: }
! 677:
! 678: while (*p == ' ' || *p == '\t')
! 679: p++;
! 680:
! 681: for (i = 0; i < chars; i++)
! 682: {
! 683: if (!*p || *p == '\n')
! 684: break;
! 685: p++;
! 686: }
! 687: return p;
! 688: }
! 689:
! 690: /* Like find_pos but assumes that each field is surrounded by braces
! 691: and that braces within fields are balanced. */
! 692:
! 693: u_short *
! 694: find_braced_pos (str, words, chars, ignore_blanks)
! 695: u_short *str;
! 696: int words, chars;
! 697: int ignore_blanks;
! 698: {
! 699: int i;
! 700: int bracelevel;
! 701: u_short *p = str;
! 702: u_short c;
! 703:
! 704: for (i = 0; i < words; i++)
! 705: {
! 706: bracelevel = 1;
! 707: while ((c = *p++) != '{' && c != '\n' && c)
! 708: /* Do nothing. */ ;
! 709: if (c != '{')
! 710: return p - 1;
! 711: while (bracelevel)
! 712: {
! 713: c = *p++;
! 714: if (c == '{')
! 715: bracelevel++;
! 716: if (c == '}')
! 717: bracelevel--;
! 718: if (c == 0 || c == '\n')
! 719: return p - 1;
! 720: }
! 721: }
! 722:
! 723: while ((c = *p++) != '{' && c != '\n' && c)
! 724: /* Do nothing. */ ;
! 725:
! 726: if (c != '{')
! 727: return p - 1;
! 728:
! 729: if (ignore_blanks)
! 730: while ((c = *p) == ' ' || c == '\t')
! 731: p++;
! 732:
! 733: for (i = 0; i < chars; i++)
! 734: {
! 735: if (!*p || *p == '\n')
! 736: break;
! 737: p++;
! 738: }
! 739: return p;
! 740: }
! 741:
! 742: /* Find the end of the balanced-brace field which starts at STR.
! 743: The position returned is just before the closing brace. */
! 744:
! 745: u_short *
! 746: find_braced_end (str)
! 747: u_short *str;
! 748: {
! 749: int bracelevel;
! 750: u_short *p = str;
! 751: u_short c;
! 752:
! 753: bracelevel = 1;
! 754: while (bracelevel)
! 755: {
! 756: c = *p++;
! 757: if (c == '{')
! 758: bracelevel++;
! 759: if (c == '}')
! 760: bracelevel--;
! 761: if (c == 0 || c == '\n')
! 762: return p - 1;
! 763: }
! 764: return p - 1;
! 765: }
! 766:
! 767: long
! 768: find_value (start, length)
! 769: u_short *start;
! 770: long length;
! 771: {
! 772: long val;
! 773:
! 774: while (length != 0L)
! 775: {
! 776: if (isdigit (*start))
! 777: break;
! 778: length--;
! 779: start++;
! 780: }
! 781:
! 782: val = 0;
! 783: while(isdigit(*start) && length > 0L)
! 784: {
! 785: val = val*10 + *start;
! 786: start++;
! 787: length--;
! 788: }
! 789:
! 790: return val;
! 791: }
! 792:
! 793: /* Vector used to translate characters for comparison.
! 794: This is how we make all alphanumerics follow all else,
! 795: and ignore case in the first sorting. */
! 796: int char_order[0x8000];
! 797:
! 798: void
! 799: init_char_order (void)
! 800: {
! 801: int i;
! 802:
! 803: for (i = 1; i < 0x8000; i++)
! 804: char_order[i] = i;
! 805:
! 806: for (i = '0'; i <= '9'; i++)
! 807: char_order[i] += 512;
! 808:
! 809: for (i = 'a'; i <= 'z'; i++)
! 810: {
! 811: char_order[i] = 512 + i;
! 812: char_order[i + 'A' - 'a'] = 512 + i;
! 813: }
! 814:
! 815: /* 以下のシンボルは無視 (i.e. char_order[XXX] = 0) */
! 816: for (i = 0x2121; i <= 0x2132; i++) /* 全角空白 〜 ＿ */
! 817: char_order[i] = 0;
! 818: for (i = 0x213D; i <= 0x215B; i++) /* − 〜 】 */
! 819: char_order[i] = 0;
! 820:
! 821: /* 促音、拗音、濁音、半濁音、片仮名/平仮名の処理 */
! 822: /* 1. 平仮名と片仮名、同じに扱う */
! 823: /* ぁ/ァ(2421/2521)〜ん/ン(2473/2573) */
! 824: for (i = 0x2421; i < 0x2474; i++)
! 825: char_order[i + 0x100] = i;
! 826:
! 827: /* 2. 促音、拗音、濁音、半濁音、類 */
! 828: /* ぁ〜ぉ → あ〜お */
! 829: for (i = 0x2421; i < 0x242B; i += 2)
! 830: char_order[i] = char_order[i + 0x100] = i+1;
! 831: /* が〜ぢ → か〜ち */
! 832: for (i = 0x242C; i < 0x2443; i += 2)
! 833: char_order[i] = char_order[i + 0x100] = i-1;
! 834: /* っ */
! 835: char_order[0x2443] = char_order[0x2543] = 0x2443+1;
! 836: /* づ〜ど → つ〜と */
! 837: for (i = 0x2445; i < 0x244A; i += 2)
! 838: char_order[i] = char_order[i + 0x100] = i-1;
! 839: /* ばぱ〜ぼぽ → は〜ほ */
! 840: for (i = 0x2450; i < 0x245E; i += 3)
! 841: {
! 842: char_order[i] = char_order[i + 0x100] = i-1;
! 843: char_order[i+1] = char_order[i+1 + 0x100] = i-1;
! 844: }
! 845: /* ゃ〜ょ → や〜よ */
! 846: for (i = 0x2463; i < 0x2469; i += 2)
! 847: char_order[i] = char_order[i + 0x100] = i+1;
! 848: /* ゎ → わ */
! 849: char_order[0x246E] = char_order[0x256E] = 0x246E +1;
! 850:
! 851: /* 3. 特殊片仮名の扱い */
! 852: char_order[0x2574] = 0x2426; /* ヴ → う */
! 853: char_order[0x2575] = 0x242B; /* ヵ → か */
! 854: char_order[0x2576] = 0x2431; /* ヶ → け */
! 855:
! 856: /* JISX0208のアルファベット、数字 */
! 857: for (i = 0x2330; i <= 0x2339; i++) /* ０〜９ -> 0-9 */
! 858: char_order[i] = i - 0x2330 + 512;
! 859: for (i = 0x2341; i <= 0x235A; i++) /* Ａ〜Ｚ、ａ〜ｚ -> A-Z */
! 860: char_order[i] = char_order[i + (0x2361 - 0x2341)]
! 861: = 512 + (i - 0x2341) + 'a';
! 862:
! 863: /* 長音処理は比較ルーチンで行なう */
! 864:
! 865: init_Vowel_Table();
! 866: }
! 867:
! 868: /* Compare two fields (each specified as a start pointer and a character count)
! 869: according to KEYFIELD.
! 870: The sign of the value reports the relation between the fields. */
! 871:
! 872: int
! 873: compare_field (keyfield, start1, length1, pos1, start2, length2, pos2)
! 874: struct keyfield *keyfield;
! 875: u_short *start1;
! 876: long length1;
! 877: long pos1;
! 878: u_short *start2;
! 879: long length2;
! 880: long pos2;
! 881: {
! 882: if (keyfields->positional)
! 883: {
! 884: if (pos1 > pos2)
! 885: return 1;
! 886: else
! 887: return -1;
! 888: }
! 889: if (keyfield->numeric)
! 890: {
! 891: long value = find_value (start1, length1) - find_value (start2, length2);
! 892: if (value > 0)
! 893: return 1;
! 894: if (value < 0)
! 895: return -1;
! 896: return 0;
! 897: }
! 898: else
! 899: {
! 900: /* lexical ってか? */
! 901: u_short *p1 = start1;
! 902: u_short *p2 = start2;
! 903: u_short *e1 = start1 + length1;
! 904: u_short *e2 = start2 + length2;
! 905: u_short lastchar1 = 0, lastchar2 = 0;
! 906: int c1, c2;
! 907:
! 908: do
! 909: {
! 910: int co1, co2;
! 911:
! 912: /* char_order[X] が 0 のもの（シンボル）は無視する */
! 913: c1 = c2 = 0;
! 914: while (p1 < e1)
! 915: {
! 916: if (char_order[c1 = *p1++]) break;
! 917: c1 = 0;
! 918: }
! 919: while (p2 < e2)
! 920: {
! 921: if (char_order[c2 = *p2++]) break;
! 922: c2 = 0;
! 923: }
! 924:
! 925: /* 長音処理 */
! 926: if (c1 == 0x213C) /* ー */
! 927: c1 = Vowel_of(lastchar1);
! 928: if (c2 == 0x213C) /* ー */
! 929: c2 = Vowel_of(lastchar2);
! 930: co1 = char_order[c1];
! 931: co2 = char_order[c2];
! 932:
! 933: if (co1 != co2)
! 934: return co1 - co2;
! 935: else
! 936: lastchar1 = c1, lastchar2 = c2;
! 937:
! 938: } while(c1);
! 939:
! 940: /* Strings are equal except possibly for case. */
! 941: p1 = start1;
! 942: p2 = start2;
! 943: while (1)
! 944: {
! 945: int c1, c2;
! 946:
! 947: if (p1 == e1)
! 948: c1 = 0;
! 949: else
! 950: c1 = *p1++;
! 951: if (p2 == e2)
! 952: c2 = 0;
! 953: else
! 954: c2 = *p2++;
! 955:
! 956: if (c1 != c2)
! 957: /* Reverse sign here so upper case comes out last. */
! 958: return c2 - c1;
! 959: if (!c1)
! 960: break;
! 961: }
! 962:
! 963: return 0;
! 964: }
! 965: }
! 966:
! 967: /* A `struct linebuffer' is a structure which holds a line of text.
! 968: `readline' reads a line from a stream into a linebuffer
! 969: and works regardless of the length of the line. */
! 970:
! 971: struct linebuffer
! 972: {
! 973: long size;
! 974: u_short *buffer;
! 975: };
! 976:
! 977: /* Initialize LINEBUFFER for use. */
! 978:
! 979: void
! 980: initbuffer (linebuffer)
! 981: struct linebuffer *linebuffer;
! 982: {
! 983: linebuffer->size = 200;
! 984: linebuffer->buffer = (u_short *) xmalloc (200*sizeof(u_short));
! 985: }
! 986:
! 987: /* Read a line of text from STREAM into LINEBUFFER.
! 988: Return the length of the line. */
! 989:
! 990: long
! 991: readline (linebuffer, stream)
! 992: struct linebuffer *linebuffer;
! 993: FILE *stream;
! 994: {
! 995: u_short *buffer = linebuffer->buffer;
! 996: u_short *p = linebuffer->buffer;
! 997: u_short *end = p + linebuffer->size;
! 998:
! 999: while (1)
! 1000: {
! 1001: int c = getc (stream);
! 1002: if (p == end)
! 1003: {
! 1004: buffer =
! 1005: (u_short *) xrealloc (buffer,
! 1006: (linebuffer->size *= 2)*sizeof(u_short));
! 1007: p += buffer - linebuffer->buffer;
! 1008: end += buffer - linebuffer->buffer;
! 1009: linebuffer->buffer = buffer;
! 1010: }
! 1011: if (c < 0 || c == '\n')
! 1012: {
! 1013: *p = 0;
! 1014: break;
! 1015: }
! 1016: *p++ = c;
! 1017: }
! 1018:
! 1019: return p - buffer;
! 1020: }
! 1021:
! 1022: /* Sort an input file too big to sort in core. */
! 1023:
! 1024: void
! 1025: sort_offline (infile, nfiles, total, outfile)
! 1026: char *infile;
! 1027: int nfiles;
! 1028: long total;
! 1029: char *outfile;
! 1030: {
! 1031: /* More than enough. */
! 1032: int ntemps = 2 * (total + MAX_IN_CORE_SORT - 1) / MAX_IN_CORE_SORT;
! 1033: char **tempfiles = (char **) xmalloc (ntemps * sizeof (char *));
! 1034: FILE *istream = fopen (infile, "r");
! 1035: int i;
! 1036: struct linebuffer lb;
! 1037: long linelength;
! 1038: int failure = 0;
! 1039:
! 1040: initbuffer (&lb);
! 1041:
! 1042: /* Read in one line of input data. */
! 1043:
! 1044: linelength = readline (&lb, istream);
! 1045:
! 1046: if (lb.buffer[0] != '\\' && lb.buffer[0] != '@')
! 1047: {
! 1048: error ("%s: not a texinfo index file", infile);
! 1049: return;
! 1050: }
! 1051:
! 1052: /* Split up the input into `ntemps' temporary files, or maybe fewer,
! 1053: and put the new files' names into `tempfiles' */
! 1054:
! 1055: for (i = 0; i < ntemps; i++)
! 1056: {
! 1057: char *outname = maketempname (++tempcount);
! 1058: FILE *ostream = fopen (outname, "w");
! 1059: long tempsize = 0;
! 1060:
! 1061: if (!ostream)
! 1062: pfatal_with_name (outname);
! 1063: tempfiles[i] = outname;
! 1064:
! 1065: /* Copy lines into this temp file as long as it does not make file
! 1066: "too big" or until there are no more lines. */
! 1067:
! 1068: while (tempsize + linelength + 1 <= MAX_IN_CORE_SORT)
! 1069: {
! 1070: tempsize += linelength + 1;
! 1071: {
! 1072: u_short *tp;
! 1073:
! 1074: for (tp = lb.buffer; *tp; tp++)
! 1075: putc(*tp, ostream);
! 1076: }
! 1077: putc ('\n', ostream);
! 1078:
! 1079: /* Read another line of input data. */
! 1080:
! 1081: linelength = readline (&lb, istream);
! 1082: if (!linelength && feof (istream))
! 1083: break;
! 1084:
! 1085: if (lb.buffer[0] != '\\' && lb.buffer[0] != '@')
! 1086: {
! 1087: error ("%s: not a texinfo index file", infile);
! 1088: failure = 1;
! 1089: goto fail;
! 1090: }
! 1091: }
! 1092: fclose (ostream);
! 1093: if (feof (istream))
! 1094: break;
! 1095: }
! 1096:
! 1097: free (lb.buffer);
! 1098:
! 1099: fail:
! 1100: /* Record number of temp files we actually needed. */
! 1101:
! 1102: ntemps = i;
! 1103:
! 1104: /* Sort each tempfile into another tempfile.
! 1105: Delete the first set of tempfiles and put the names of the second
! 1106: into `tempfiles'. */
! 1107:
! 1108: for (i = 0; i < ntemps; i++)
! 1109: {
! 1110: char *newtemp = maketempname (++tempcount);
! 1111: sort_in_core (&tempfiles[i], MAX_IN_CORE_SORT, newtemp);
! 1112: if (!keep_tempfiles)
! 1113: unlink (tempfiles[i]);
! 1114: tempfiles[i] = newtemp;
! 1115: }
! 1116:
! 1117: if (failure)
! 1118: return;
! 1119:
! 1120: /* Merge the tempfiles together and indexify. */
! 1121:
! 1122: merge_files (tempfiles, ntemps, outfile);
! 1123: }
! 1124:
! 1125: /* Sort INFILE, whose size is TOTAL,
! 1126: assuming that is small enough to be done in-core,
! 1127: then indexify it and send the output to OUTFILE (or to stdout). */
! 1128:
! 1129: void
! 1130: sort_in_core (infile, total, outfile)
! 1131: char *infile;
! 1132: long total;
! 1133: char *outfile;
! 1134: {
! 1135: u_short **nextline;
! 1136: u_short *data = (u_short *) xmalloc ((total + 1)*sizeof(u_short));
! 1137: u_short *file_data;
! 1138: long file_size;
! 1139: int i;
! 1140: FILE *ostream = stdout;
! 1141: struct lineinfo *lineinfo;
! 1142: FILE *ifp;
! 1143: int c;
! 1144:
! 1145: /* Read the contents of the file into the moby array `data'. */
! 1146: ifp = fopen(infile, "r");
! 1147: if (!ifp)
! 1148: fatal ("failure reopening %s", infile);
! 1149: memset(data, 0, (total + 1)*sizeof(u_short)); /* zero clear */
! 1150: for (i = 0, c = fgetc(ifp); c != EOF; c = fgetc(ifp), i++)
! 1151: {
! 1152: if (EUC_BYTE(c))
! 1153: {
! 1154: data[i] = (c & 0x007F) << 8;
! 1155: c = fgetc(ifp) & 0x007F;
! 1156: }
! 1157: data[i] += c;
! 1158: }
! 1159: file_size = i;
! 1160: file_data = data;
! 1161: data[file_size] = 0;
! 1162:
! 1163: fclose(ifp);
! 1164:
! 1165: if (file_size > 0 && data[0] != '\\' && data[0] != '@')
! 1166: {
! 1167: error ("%s: not a texinfo index file", infile);
! 1168: return;
! 1169: }
! 1170:
! 1171: init_char_order ();
! 1172:
! 1173: /* Sort routines want to know this address. */
! 1174:
! 1175: text_base = data;
! 1176:
! 1177: /* Create the array of pointers to lines, with a default size
! 1178: frequently enough. */
! 1179:
! 1180: nlines = total / 50;
! 1181: if (!nlines)
! 1182: nlines = 2;
! 1183: linearray = (u_short **) xmalloc (nlines * sizeof (u_short *));
! 1184:
! 1185: /* `nextline' points to the next free slot in this array.
! 1186: `nlines' is the allocated size. */
! 1187:
! 1188: nextline = linearray;
! 1189:
! 1190: /* Parse the input file's data, and make entries for the lines. */
! 1191:
! 1192: nextline = parsefile (nextline, file_data, file_size);
! 1193:
! 1194: if (nextline == 0)
! 1195: {
! 1196: error ("%s: not a texinfo index file", infile);
! 1197: return;
! 1198: }
! 1199:
! 1200: /* Sort the lines. */
! 1201:
! 1202: /* If we have enough space, find the first keyfield of each line in advance.
! 1203: Make a `struct lineinfo' for each line, which records the keyfield
! 1204: as well as the line, and sort them. */
! 1205:
! 1206: lineinfo = (struct lineinfo *) malloc ((nextline - linearray) * sizeof (struct lineinfo));
! 1207:
! 1208: if (lineinfo)
! 1209: {
! 1210: struct lineinfo *lp;
! 1211: u_short **p;
! 1212:
! 1213: for (lp = lineinfo, p = linearray; p != nextline; lp++, p++)
! 1214: {
! 1215: lp->text = *p;
! 1216: lp->key.text = find_field (keyfields, *p, &lp->keylen);
! 1217: if (keyfields->numeric)
! 1218: lp->key.number = find_value (lp->key.text, lp->keylen);
! 1219: }
! 1220:
! 1221: qsort (lineinfo, nextline - linearray, sizeof (struct lineinfo), compare_prepared);
! 1222:
! 1223: for (lp = lineinfo, p = linearray; p != nextline; lp++, p++)
! 1224: *p = lp->text;
! 1225:
! 1226: free (lineinfo);
! 1227: }
! 1228: else
! 1229: qsort (linearray, nextline - linearray, sizeof (u_short *), compare_full);
! 1230:
! 1231: /* Open the output file. */
! 1232:
! 1233: if (outfile)
! 1234: {
! 1235: ostream = fopen (outfile, "w");
! 1236: if (!ostream)
! 1237: pfatal_with_name (outfile);
! 1238: }
! 1239:
! 1240: writelines (linearray, nextline - linearray, ostream);
! 1241: if (outfile)
! 1242: fclose (ostream);
! 1243:
! 1244: free (linearray);
! 1245: free (data);
! 1246: }
! 1247:
! 1248: /* Parse an input string in core into lines.
! 1249: DATA is the input string, and SIZE is its length.
! 1250: Data goes in LINEARRAY starting at NEXTLINE.
! 1251: The value returned is the first entry in LINEARRAY still unused.
! 1252: Value 0 means input file contents are invalid. */
! 1253:
! 1254: u_short **
! 1255: parsefile (nextline, data, size)
! 1256: u_short **nextline;
! 1257: u_short *data;
! 1258: long size;
! 1259: {
! 1260: u_short *p, *end;
! 1261: u_short **line = nextline;
! 1262:
! 1263: p = data;
! 1264: end = p + size;
! 1265: *end = 0;
! 1266:
! 1267: while (p != end)
! 1268: {
! 1269: if (p[0] != '\\' && p[0] != '@')
! 1270: return 0;
! 1271:
! 1272: *line = p;
! 1273: while (*p && *p != '\n')
! 1274: p++;
! 1275: if (p != end)
! 1276: p++;
! 1277:
! 1278: line++;
! 1279: if (line == linearray + nlines)
! 1280: {
! 1281: u_short **old = linearray;
! 1282: linearray =
! 1283: (u_short **) xrealloc (linearray,
! 1284: sizeof (u_short *) * (nlines *= 4));
! 1285: line += linearray - old;
! 1286: }
! 1287: }
! 1288:
! 1289: return line;
! 1290: }
! 1291:
! 1292: /* Indexification is a filter applied to the sorted lines
! 1293: as they are being written to the output file.
! 1294: Multiple entries for the same name, with different page numbers,
! 1295: get combined into a single entry with multiple page numbers.
! 1296: The first braced field, which is used for sorting, is discarded.
! 1297: However, its first character is examined, folded to lower case,
! 1298: and if it is different from that in the previous line fed to us
! 1299: a \initial line is written with one argument, the new initial.
! 1300:
! 1301: If an entry has four braced fields, then the second and third
! 1302: constitute primary and secondary names.
! 1303: In this case, each change of primary name
! 1304: generates a \primary line which contains only the primary name,
! 1305: and in between these are \secondary lines which contain
! 1306: just a secondary name and page numbers. */
! 1307:
! 1308: /* The last primary name we wrote a \primary entry for.
! 1309: If only one level of indexing is being done, this is the last name seen. */
! 1310: u_short *lastprimary;
! 1311: /* Length of storage allocated for lastprimary. */
! 1312: int lastprimarylength;
! 1313:
! 1314: /* Similar, for the secondary name. */
! 1315: u_short *lastsecondary;
! 1316: int lastsecondarylength;
! 1317:
! 1318: /* Zero if we are not in the middle of writing an entry.
! 1319: One if we have written the beginning of an entry but have not
! 1320: yet written any page numbers into it.
! 1321: Greater than one if we have written the beginning of an entry
! 1322: plus at least one page number. */
! 1323: int pending;
! 1324:
! 1325: /* The initial (for sorting purposes) of the last primary entry written.
! 1326: When this changes, a \initial {c} line is written */
! 1327:
! 1328: u_short *lastinitial;
! 1329:
! 1330: int lastinitiallength;
! 1331:
! 1332: /* When we need a string of length 1 for the value of lastinitial,
! 1333: store it here. */
! 1334:
! 1335: u_short lastinitial1[2];
! 1336:
! 1337: /* Initialize static storage for writing an index. */
! 1338:
! 1339: void
! 1340: init_index ()
! 1341: {
! 1342: pending = 0;
! 1343: lastinitial = lastinitial1;
! 1344: lastinitial1[0] = 0;
! 1345: lastinitial1[1] = 0;
! 1346: lastinitiallength = 0;
! 1347: lastprimarylength = 100;
! 1348: lastprimary = (u_short *) xmalloc ((lastprimarylength + 1)*sizeof(u_short));
! 1349: memset (lastprimary, '\0', (lastprimarylength + 1)*sizeof(u_short));
! 1350: lastsecondarylength = 100;
! 1351: lastsecondary =
! 1352: (u_short *) xmalloc ((lastsecondarylength + 1)*sizeof(u_short));
! 1353: memset (lastsecondary, '\0', (lastsecondarylength + 1)*sizeof(u_short));
! 1354: }
! 1355:
! 1356: /* Indexify. Merge entries for the same name,
! 1357: insert headers for each initial character, etc. */
! 1358:
! 1359: void
! 1360: indexify (u_short *line, FILE *ostream)
! 1361: {
! 1362: u_short *primary, *secondary, *pagenumber;
! 1363: int primarylength, secondarylength = 0, pagelength;
! 1364: int nosecondary;
! 1365: int initiallength;
! 1366: u_short *initial;
! 1367: u_short initial1[2];
! 1368: register u_short *p;
! 1369:
! 1370: /* First, analyze the parts of the entry fed to us this time. */
! 1371:
! 1372: p = find_braced_pos (line, 0, 0, 0);
! 1373: if (*p == '{')
! 1374: {
! 1375: initial = p;
! 1376: /* Get length of inner pair of braces starting at `p',
! 1377: including that inner pair of braces. */
! 1378: initiallength = find_braced_end (p + 1) + 1 - p;
! 1379: }
! 1380: else
! 1381: {
! 1382: initial = initial1;
! 1383: initial1[0] = *p & 0x7F7F;
! 1384: initial1[1] = 0;
! 1385: initiallength = 1;
! 1386:
! 1387: if (initial1[0] >= 'a' && initial1[0] <= 'z')
! 1388: initial1[0] -= ' ';
! 1389: else if (initial1[0] > 0x2000)
! 1390: initial1[0] = char_order[initial1[0]];
! 1391: }
! 1392:
! 1393: pagenumber = find_braced_pos (line, 1, 0, 0);
! 1394: pagelength = find_braced_end (pagenumber) - pagenumber;
! 1395: if (pagelength == 0)
! 1396: abort ();
! 1397:
! 1398: primary = find_braced_pos (line, 2, 0, 0);
! 1399: primarylength = find_braced_end (primary) - primary;
! 1400:
! 1401: secondary = find_braced_pos (line, 3, 0, 0);
! 1402: nosecondary = !*secondary;
! 1403: if (!nosecondary)
! 1404: secondarylength = find_braced_end (secondary) - secondary;
! 1405:
! 1406: /* If the primary is different from before, make a new primary entry. */
! 1407: if (wstrncmp (primary, lastprimary, primarylength))
! 1408: {
! 1409: /* Close off current secondary entry first, if one is open. */
! 1410: if (pending)
! 1411: {
! 1412: fputs ("}\n", ostream);
! 1413: pending = 0;
! 1414: }
! 1415:
! 1416: /* If this primary has a different initial, include an entry for
! 1417: the initial. */
! 1418: if (initiallength != lastinitiallength ||
! 1419: (*initial && wstrncmp (initial, lastinitial, initiallength)))
! 1420: {
! 1421: fprintf (ostream, "\\initial {");
! 1422: wfwrite (initial, initiallength, 1, ostream);
! 1423: fprintf (ostream, "}\n", initial);
! 1424: if (initial == initial1)
! 1425: {
! 1426: lastinitial = lastinitial1;
! 1427: *lastinitial1 = *initial1;
! 1428: }
! 1429: else
! 1430: {
! 1431: lastinitial = initial;
! 1432: }
! 1433: lastinitiallength = initiallength;
! 1434: }
! 1435:
! 1436: /* Make the entry for the primary. */
! 1437: if (nosecondary)
! 1438: fputs ("\\entry {", ostream);
! 1439: else
! 1440: fputs ("\\primary {", ostream);
! 1441: wfwrite (primary, primarylength, 1, ostream);
! 1442: if (nosecondary)
! 1443: {
! 1444: fputs ("}{", ostream);
! 1445: pending = 1;
! 1446: }
! 1447: else
! 1448: fputs ("}\n", ostream);
! 1449:
! 1450: /* Record name of most recent primary. */
! 1451: if (lastprimarylength < primarylength)
! 1452: {
! 1453: lastprimarylength = primarylength + 100;
! 1454: lastprimary =
! 1455: (u_short *) xrealloc (lastprimary,
! 1456: (1 + lastprimarylength)*sizeof(u_short));
! 1457: }
! 1458: memcpy (lastprimary, primary, primarylength*sizeof(u_short));
! 1459: lastprimary[primarylength] = 0;
! 1460:
! 1461: /* There is no current secondary within this primary, now. */
! 1462: lastsecondary[0] = 0;
! 1463: }
! 1464:
! 1465: /* Should not have an entry with no subtopic following one with a subtopic. */
! 1466:
! 1467: if (nosecondary && *lastsecondary)
! 1468: {
! 1469: char tline[2001];
! 1470: int len;
! 1471:
! 1472: len = wtoc(tline, line, 2000); /* 2000 is much enough ? */
! 1473: tline[len] = '\0';
! 1474: error ("entry %s follows an entry with a secondary name", tline);
! 1475: }
! 1476:
! 1477: /* Start a new secondary entry if necessary. */
! 1478: if (!nosecondary && wstrncmp (secondary, lastsecondary, secondarylength))
! 1479: {
! 1480: if (pending)
! 1481: {
! 1482: fputs ("}\n", ostream);
! 1483: pending = 0;
! 1484: }
! 1485:
! 1486: /* Write the entry for the secondary. */
! 1487: fputs ("\\secondary {", ostream);
! 1488: wfwrite (secondary, secondarylength, 1, ostream);
! 1489: fputs ("}{", ostream);
! 1490: pending = 1;
! 1491:
! 1492: /* Record name of most recent secondary. */
! 1493: if (lastsecondarylength < secondarylength)
! 1494: {
! 1495: lastsecondarylength = secondarylength + 100;
! 1496: lastsecondary =
! 1497: (u_short *) xrealloc ((lastsecondary,
! 1498: 1 + lastsecondarylength)*sizeof(u_short));
! 1499: }
! 1500: memcpy (lastsecondary, secondary, secondarylength * sizeof(u_short));
! 1501: lastsecondary[secondarylength] = 0;
! 1502: }
! 1503:
! 1504: /* Here to add one more page number to the current entry. */
! 1505: if (pending++ != 1)
! 1506: fputs (", ", ostream); /* Punctuate first, if this is not the first. */
! 1507: wfwrite (pagenumber, pagelength, 1, ostream);
! 1508: }
! 1509:
! 1510: /* Close out any unfinished output entry. */
! 1511:
! 1512: void
! 1513: finish_index (ostream)
! 1514: FILE *ostream;
! 1515: {
! 1516: if (pending)
! 1517: fputs ("}\n", ostream);
! 1518: free (lastprimary);
! 1519: free (lastsecondary);
! 1520: }
! 1521:
! 1522: /* Copy the lines in the sorted order.
! 1523: Each line is copied out of the input file it was found in. */
! 1524:
! 1525: void
! 1526: writelines (linearray, nlines, ostream)
! 1527: u_short **linearray;
! 1528: int nlines;
! 1529: FILE *ostream;
! 1530: {
! 1531: u_short **stop_line = linearray + nlines;
! 1532: u_short **next_line;
! 1533:
! 1534: init_index ();
! 1535:
! 1536: /* Output the text of the lines, and free the buffer space. */
! 1537:
! 1538: for (next_line = linearray; next_line != stop_line; next_line++)
! 1539: {
! 1540: /* If -u was specified, output the line only if distinct from previous one. */
! 1541: if (next_line == linearray
! 1542: /* Compare previous line with this one, using only the
! 1543: explicitly specd keyfields. */
! 1544: || compare_general (*(next_line - 1), *next_line, 0L, 0L, num_keyfields - 1))
! 1545: {
! 1546: u_short *p = *next_line;
! 1547: u_short c;
! 1548:
! 1549: while ((c = *p++) && c != '\n')
! 1550: /* Do nothing. */ ;
! 1551: *(p - 1) = 0;
! 1552: indexify (*next_line, ostream);
! 1553: }
! 1554: }
! 1555:
! 1556: finish_index (ostream);
! 1557: }
! 1558:
! 1559: /* Assume (and optionally verify) that each input file is sorted;
! 1560: merge them and output the result.
! 1561: Returns nonzero if any input file fails to be sorted.
! 1562:
! 1563: This is the high-level interface that can handle an unlimited
! 1564: number of files. */
! 1565:
! 1566: #define MAX_DIRECT_MERGE 10
! 1567:
! 1568: int
! 1569: merge_files (infiles, nfiles, outfile)
! 1570: char **infiles;
! 1571: int nfiles;
! 1572: char *outfile;
! 1573: {
! 1574: char **tempfiles;
! 1575: int ntemps;
! 1576: int i;
! 1577: int value = 0;
! 1578: int start_tempcount = tempcount;
! 1579:
! 1580: if (nfiles <= MAX_DIRECT_MERGE)
! 1581: return merge_direct (infiles, nfiles, outfile);
! 1582:
! 1583: /* Merge groups of MAX_DIRECT_MERGE input files at a time,
! 1584: making a temporary file to hold each group's result. */
! 1585:
! 1586: ntemps = (nfiles + MAX_DIRECT_MERGE - 1) / MAX_DIRECT_MERGE;
! 1587: tempfiles = (char **) xmalloc (ntemps * sizeof (char *));
! 1588: for (i = 0; i < ntemps; i++)
! 1589: {
! 1590: int nf = MAX_DIRECT_MERGE;
! 1591: if (i + 1 == ntemps)
! 1592: nf = nfiles - i * MAX_DIRECT_MERGE;
! 1593: tempfiles[i] = maketempname (++tempcount);
! 1594: value |= merge_direct (&infiles[i * MAX_DIRECT_MERGE], nf, tempfiles[i]);
! 1595: }
! 1596:
! 1597: /* All temporary files that existed before are no longer needed
! 1598: since their contents have been merged into our new tempfiles.
! 1599: So delete them. */
! 1600: flush_tempfiles (start_tempcount);
! 1601:
! 1602: /* Now merge the temporary files we created. */
! 1603:
! 1604: merge_files (tempfiles, ntemps, outfile);
! 1605:
! 1606: free (tempfiles);
! 1607:
! 1608: return value;
! 1609: }
! 1610:
! 1611: /* Assume (and optionally verify) that each input file is sorted;
! 1612: merge them and output the result.
! 1613: Returns nonzero if any input file fails to be sorted.
! 1614:
! 1615: This version of merging will not work if the number of
! 1616: input files gets too high. Higher level functions
! 1617: use it only with a bounded number of input files. */
! 1618:
! 1619: int
! 1620: merge_direct (infiles, nfiles, outfile)
! 1621: char **infiles;
! 1622: int nfiles;
! 1623: char *outfile;
! 1624: {
! 1625: struct linebuffer *lb1, *lb2;
! 1626: struct linebuffer **thisline, **prevline;
! 1627: FILE **streams;
! 1628: int i;
! 1629: int nleft;
! 1630: int lossage = 0;
! 1631: int *file_lossage;
! 1632: struct linebuffer *prev_out = 0;
! 1633: FILE *ostream = stdout;
! 1634:
! 1635: if (outfile)
! 1636: {
! 1637: ostream = fopen (outfile, "w");
! 1638: }
! 1639: if (!ostream)
! 1640: pfatal_with_name (outfile);
! 1641:
! 1642: init_index ();
! 1643:
! 1644: if (nfiles == 0)
! 1645: {
! 1646: if (outfile)
! 1647: fclose (ostream);
! 1648: return 0;
! 1649: }
! 1650:
! 1651: /* For each file, make two line buffers.
! 1652: Also, for each file, there is an element of `thisline'
! 1653: which points at any time to one of the file's two buffers,
! 1654: and an element of `prevline' which points to the other buffer.
! 1655: `thisline' is supposed to point to the next available line from the file,
! 1656: while `prevline' holds the last file line used,
! 1657: which is remembered so that we can verify that the file is properly sorted. */
! 1658:
! 1659: /* lb1 and lb2 contain one buffer each per file. */
! 1660: lb1 = (struct linebuffer *) xmalloc (nfiles * sizeof (struct linebuffer));
! 1661: lb2 = (struct linebuffer *) xmalloc (nfiles * sizeof (struct linebuffer));
! 1662:
! 1663: /* thisline[i] points to the linebuffer holding the next available line in file i,
! 1664: or is zero if there are no lines left in that file. */
! 1665: thisline = (struct linebuffer **)
! 1666: xmalloc (nfiles * sizeof (struct linebuffer *));
! 1667: /* prevline[i] points to the linebuffer holding the last used line
! 1668: from file i. This is just for verifying that file i is properly
! 1669: sorted. */
! 1670: prevline = (struct linebuffer **)
! 1671: xmalloc (nfiles * sizeof (struct linebuffer *));
! 1672: /* streams[i] holds the input stream for file i. */
! 1673: streams = (FILE **) xmalloc (nfiles * sizeof (FILE *));
! 1674: /* file_lossage[i] is nonzero if we already know file i is not
! 1675: properly sorted. */
! 1676: file_lossage = (int *) xmalloc (nfiles * sizeof (int));
! 1677:
! 1678: /* Allocate and initialize all that storage. */
! 1679:
! 1680: for (i = 0; i < nfiles; i++)
! 1681: {
! 1682: initbuffer (&lb1[i]);
! 1683: initbuffer (&lb2[i]);
! 1684: thisline[i] = &lb1[i];
! 1685: prevline[i] = &lb2[i];
! 1686: file_lossage[i] = 0;
! 1687: streams[i] = fopen (infiles[i], "r");
! 1688: if (!streams[i])
! 1689: pfatal_with_name (infiles[i]);
! 1690:
! 1691: readline (thisline[i], streams[i]);
! 1692: }
! 1693:
! 1694: /* Keep count of number of files not at eof. */
! 1695: nleft = nfiles;
! 1696:
! 1697: while (nleft)
! 1698: {
! 1699: struct linebuffer *best = 0;
! 1700: struct linebuffer *exch;
! 1701: int bestfile = -1;
! 1702: int i;
! 1703:
! 1704: /* Look at the next avail line of each file; choose the least one. */
! 1705:
! 1706: for (i = 0; i < nfiles; i++)
! 1707: {
! 1708: if (thisline[i] &&
! 1709: (!best ||
! 1710: 0 < compare_general (best->buffer, thisline[i]->buffer,
! 1711: (long) bestfile, (long) i, num_keyfields)))
! 1712: {
! 1713: best = thisline[i];
! 1714: bestfile = i;
! 1715: }
! 1716: }
! 1717:
! 1718: /* Output that line, unless it matches the previous one and we
! 1719: don't want duplicates. */
! 1720:
! 1721: if (!(prev_out &&
! 1722: !compare_general (prev_out->buffer,
! 1723: best->buffer, 0L, 1L, num_keyfields - 1)))
! 1724: indexify (best->buffer, ostream);
! 1725: prev_out = best;
! 1726:
! 1727: /* Now make the line the previous of its file, and fetch a new
! 1728: line from that file. */
! 1729:
! 1730: exch = prevline[bestfile];
! 1731: prevline[bestfile] = thisline[bestfile];
! 1732: thisline[bestfile] = exch;
! 1733:
! 1734: while (1)
! 1735: {
! 1736: /* If the file has no more, mark it empty. */
! 1737:
! 1738: if (feof (streams[bestfile]))
! 1739: {
! 1740: thisline[bestfile] = 0;
! 1741: /* Update the number of files still not empty. */
! 1742: nleft--;
! 1743: break;
! 1744: }
! 1745: readline (thisline[bestfile], streams[bestfile]);
! 1746: if (thisline[bestfile]->buffer[0] || !feof (streams[bestfile]))
! 1747: break;
! 1748: }
! 1749: }
! 1750:
! 1751: finish_index (ostream);
! 1752:
! 1753: /* Free all storage and close all input streams. */
! 1754:
! 1755: for (i = 0; i < nfiles; i++)
! 1756: {
! 1757: fclose (streams[i]);
! 1758: free (lb1[i].buffer);
! 1759: free (lb2[i].buffer);
! 1760: }
! 1761: free (file_lossage);
! 1762: free (lb1);
! 1763: free (lb2);
! 1764: free (thisline);
! 1765: free (prevline);
! 1766: free (streams);
! 1767:
! 1768: if (outfile)
! 1769: fclose (ostream);
! 1770:
! 1771: return lossage;
! 1772: }
! 1773:
! 1774: /* Print error message and exit. */
! 1775:
! 1776: void
! 1777: fatal (format, arg)
! 1778: char *format, *arg;
! 1779: {
! 1780: error (format, arg);
! 1781: exit (TI_FATAL_ERROR);
! 1782: }
! 1783:
! 1784: /* Print error message. FORMAT is printf control string, ARG is arg for it. */
! 1785: void
! 1786: error (format, arg)
! 1787: char *format, *arg;
! 1788: {
! 1789: printf ("%s: ", program_name);
! 1790: printf (format, arg);
! 1791: if (format[strlen (format) -1] != '\n')
! 1792: printf ("\n");
! 1793: }
! 1794:
! 1795: void
! 1796: perror_with_name (name)
! 1797: char *name;
! 1798: {
! 1799: char *s;
! 1800:
! 1801: s = strerror (errno);
! 1802: printf ("%s: ", program_name);
! 1803: printf ("%s; for file `%s'.\n", s, name);
! 1804: }
! 1805:
! 1806: void
! 1807: pfatal_with_name (name)
! 1808: char *name;
! 1809: {
! 1810: char *s;
! 1811:
! 1812: s = strerror (errno);
! 1813: printf ("%s: ", program_name);
! 1814: printf ("%s; for file `%s'.\n", s, name);
! 1815: exit (TI_FATAL_ERROR);
! 1816: }
! 1817:
! 1818: /* Return a newly-allocated string whose contents concatenate those of
! 1819: S1, S2, S3. */
! 1820:
! 1821: char *
! 1822: concat (s1, s2, s3)
! 1823: char *s1, *s2, *s3;
! 1824: {
! 1825: int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
! 1826: char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
! 1827:
! 1828: strcpy (result, s1);
! 1829: strcpy (result + len1, s2);
! 1830: strcpy (result + len1 + len2, s3);
! 1831: *(result + len1 + len2 + len3) = 0;
! 1832:
! 1833: return result;
! 1834: }
! 1835:
! 1836: #if !defined (HAVE_STRERROR)
! 1837: extern char *sys_errlist[];
! 1838: extern int sys_nerr;
! 1839:
! 1840: char *
! 1841: strerror (num)
! 1842: int num;
! 1843: {
! 1844: if (num >= sys_nerr)
! 1845: return ("");
! 1846: else
! 1847: return (sys_errlist[num]);
! 1848: }
! 1849: #endif /* !HAVE_STRERROR */
! 1850:
! 1851: #if !defined (HAVE_STRCHR)
! 1852: char *
! 1853: strrchr (string, character)
! 1854: char *string;
! 1855: int character;
! 1856: {
! 1857: register int i;
! 1858:
! 1859: for (i = strlen (string) - 1; i > -1; i--)
! 1860: if (string[i] == character)
! 1861: return (string + i);
! 1862:
! 1863: return ((char *)NULL);
! 1864: }
! 1865: #endif /* HAVE_STRCHR */
! 1866:
! 1867: /* Just like malloc, but kills the program in case of fatal error. */
! 1868: void *
! 1869: xmalloc (nbytes)
! 1870: int nbytes;
! 1871: {
! 1872: void *temp = (void *) malloc (nbytes);
! 1873:
! 1874: if (nbytes && temp == (void *)NULL)
! 1875: memory_error ("xmalloc", nbytes);
! 1876:
! 1877: return (temp);
! 1878: }
! 1879:
! 1880: /* Like realloc (), but barfs if there isn't enough memory. */
! 1881: void *
! 1882: xrealloc (pointer, nbytes)
! 1883: void *pointer;
! 1884: int nbytes;
! 1885: {
! 1886: void *temp;
! 1887:
! 1888: if (!pointer)
! 1889: temp = (void *)xmalloc (nbytes);
! 1890: else
! 1891: temp = (void *)realloc (pointer, nbytes);
! 1892:
! 1893: if (nbytes && !temp)
! 1894: memory_error ("xrealloc", nbytes);
! 1895:
! 1896: return (temp);
! 1897: }
! 1898:
! 1899: void
! 1900: memory_error (callers_name, bytes_wanted)
! 1901: char *callers_name;
! 1902: int bytes_wanted;
! 1903: {
! 1904: char printable_string[80];
! 1905:
! 1906: sprintf (printable_string,
! 1907: "Virtual memory exhausted in %s ()! Needed %d bytes.",
! 1908: callers_name, bytes_wanted);
! 1909:
! 1910: error (printable_string);
! 1911: abort();
! 1912: }
! 1913:
! 1914:
! 1915: static int
! 1916: wstrncmp(const u_short *s1, const u_short *s2, size_t n)
! 1917: {
! 1918: int i;
! 1919: int d = 0;
! 1920:
! 1921: for (i=0; i<n && d == 0; i++)
! 1922: d = s1[i] - s2[i];
! 1923:
! 1924: return d;
! 1925: }
! 1926:
! 1927:
! 1928: static int
! 1929: wfwrite(u_short *ptr, size_t size, size_t nmemb, FILE*stream)
! 1930: {
! 1931: char *cptr;
! 1932: int ret, len;
! 1933:
! 1934: cptr = (char *)xmalloc(size * nmemb * sizeof(u_short)); /* 丼一杯! */
! 1935: len = wtoc(cptr, ptr, size*nmemb);
! 1936: assert(len <= (size * nmemb * sizeof(u_short)));
! 1937:
! 1938: ret = fwrite(cptr, len, nmemb, stream);
! 1939: free(cptr);
! 1940: return ret;
! 1941: }
! 1942:
! 1943:
! 1944: static int
! 1945: wtoc(char *cptr, u_short const *ptr, int len)
! 1946: {
! 1947: char *tptr;
! 1948: u_short c;
! 1949: int i;
! 1950:
! 1951: tptr = cptr;
! 1952: for (i = 0; i < len; i++)
! 1953: {
! 1954: c = ptr[i];
! 1955: if (G1_CHAR(c))
! 1956: {
! 1957: *tptr++ = c >> 8 | 0x0080; /* to EUC */
! 1958: c &= 0x007F;
! 1959: c |= 0x0080;
! 1960: }
! 1961: *tptr++ = c;
! 1962: }
! 1963:
! 1964: return tptr - cptr;
! 1965: }
! 1966:
! 1967:
! 1968: static int
! 1969: Vowel_of(int c)
! 1970: {
! 1971: if (0x2521 <= c && c < 0x2577) /* 片仮名は */
! 1972: c -= 0x100; /* 平仮名へ */
! 1973: /* ヴ、ヵ、ヶ、の3字は相当する平仮名はないが、コードがあると仮定する */
! 1974: /* 普通は問題にならない筈。 */
! 1975:
! 1976: if (0x2421 <= c && c < 0x2474)
! 1977: return Vowel_Table[c - 0x2420];
! 1978: else
! 1979: return c; /* 平仮名以外はそのまま */
! 1980: }
! 1981:
! 1982:
! 1983: static void
! 1984: init_Vowel_Table(void)
! 1985: {
! 1986: int i;
! 1987:
! 1988: /* あ〜ぞ */
! 1989: for (i = 0x2421 - 0x2420; i < 0x2445 - 0x2420; i += 10)
! 1990: {
! 1991: Vowel_Table[i] = Vowel_Table[i+1] = 0x2422; /* あ段 */
! 1992: Vowel_Table[i+2] = Vowel_Table[i+3] = 0x2424; /* い段 */
! 1993: Vowel_Table[i+4] = Vowel_Table[i+5] = 0x2426; /* う段 */
! 1994: Vowel_Table[i+6] = Vowel_Table[i+7] = 0x2428; /* え段 */
! 1995: Vowel_Table[i+8] = Vowel_Table[i+9] = 0x242A; /* お段 */
! 1996: }
! 1997: Vowel_Table[0x243F - 0x2420] = 0x2422; /* た */
! 1998: Vowel_Table[0x2440 - 0x2420] = 0x2422; /* だ */
! 1999: Vowel_Table[0x2441 - 0x2420] = 0x2424; /* ち */
! 2000: Vowel_Table[0x2442 - 0x2420] = 0x2424; /* ぢ */
! 2001: Vowel_Table[0x2443 - 0x2420] = 0x2426; /* っ */
! 2002: Vowel_Table[0x2444 - 0x2420] = 0x2426; /* つ */
! 2003: Vowel_Table[0x2445 - 0x2420] = 0x2426; /* づ */
! 2004: Vowel_Table[0x2446 - 0x2420] = 0x2428; /* て */
! 2005: Vowel_Table[0x2447 - 0x2420] = 0x2428; /* で */
! 2006: Vowel_Table[0x2448 - 0x2420] = 0x242A; /* と */
! 2007: Vowel_Table[0x2449 - 0x2420] = 0x242A; /* ど */
! 2008: Vowel_Table[0x244A - 0x2420] = 0x2422; /* な */
! 2009: Vowel_Table[0x244B - 0x2420] = 0x2424; /* に */
! 2010: Vowel_Table[0x244C - 0x2420] = 0x2426; /* ぬ */
! 2011: Vowel_Table[0x244D - 0x2420] = 0x2428; /* ね */
! 2012: Vowel_Table[0x244E - 0x2420] = 0x242A; /* の */
! 2013: /* は〜ぽ */
! 2014: for (i = 0x244F - 0x2420; i < 0x245E - 0x2420; i += 15)
! 2015: {
! 2016: Vowel_Table[i] = Vowel_Table[i+1] = Vowel_Table[i+2] = 0x2422;
! 2017: Vowel_Table[i+3] = Vowel_Table[i+4] = Vowel_Table[i+5] = 0x2424;
! 2018: Vowel_Table[i+6] = Vowel_Table[i+7] = Vowel_Table[i+8] = 0x2426;
! 2019: Vowel_Table[i+9] = Vowel_Table[i+11] = Vowel_Table[i+12] = 0x2428;
! 2020: Vowel_Table[i+12] = Vowel_Table[i+13] = Vowel_Table[i+14] = 0x242A;
! 2021: }
! 2022: Vowel_Table[0x245E - 0x2420] = 0x2422; /* ま */
! 2023: Vowel_Table[0x245F - 0x2420] = 0x2424; /* み */
! 2024: Vowel_Table[0x2460 - 0x2420] = 0x2426; /* む */
! 2025: Vowel_Table[0x2461 - 0x2420] = 0x2428; /* め */
! 2026: Vowel_Table[0x2462 - 0x2420] = 0x242A; /* も */
! 2027: Vowel_Table[0x2463 - 0x2420] = 0x2422; /* ゃ */
! 2028: Vowel_Table[0x2464 - 0x2420] = 0x2422; /* や */
! 2029: Vowel_Table[0x2465 - 0x2420] = 0x2426; /* ゅ */
! 2030: Vowel_Table[0x2466 - 0x2420] = 0x2426; /* ゆ */
! 2031: Vowel_Table[0x2467 - 0x2420] = 0x242A; /* ょ */
! 2032: Vowel_Table[0x2468 - 0x2420] = 0x242A; /* よ */
! 2033: Vowel_Table[0x2469 - 0x2420] = 0x2422; /* ら */
! 2034: Vowel_Table[0x246A - 0x2420] = 0x2424; /* り */
! 2035: Vowel_Table[0x246B - 0x2420] = 0x2426; /* る */
! 2036: Vowel_Table[0x246C - 0x2420] = 0x2428; /* れ */
! 2037: Vowel_Table[0x246D - 0x2420] = 0x242A; /* ろ */
! 2038: Vowel_Table[0x246E - 0x2420] = 0x2422; /* ゎ */
! 2039: Vowel_Table[0x246F - 0x2420] = 0x2422; /* わ */
! 2040: /* ゐ〜ヶ は、そのまま。母音への変換はしない。 */
! 2041: for (i = 0x2470 - 0x2420; i < 0x2477 - 0x2420; i++)
! 2042: Vowel_Table[i] = i;
! 2043: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to texindex.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / asir-doc / jtexindex / C