summaryrefslogtreecommitdiff
path: root/indexing/makeindex/src/scanst.c
diff options
context:
space:
mode:
Diffstat (limited to 'indexing/makeindex/src/scanst.c')
-rw-r--r--indexing/makeindex/src/scanst.c616
1 files changed, 616 insertions, 0 deletions
diff --git a/indexing/makeindex/src/scanst.c b/indexing/makeindex/src/scanst.c
new file mode 100644
index 0000000000..ed3e9654d8
--- /dev/null
+++ b/indexing/makeindex/src/scanst.c
@@ -0,0 +1,616 @@
+/*
+ *
+ * This file is part of
+ * MakeIndex - A formatter and format independent index processor
+ *
+ * Copyright (C) 1989 by Chen & Harrison International Systems, Inc.
+ * Copyright (C) 1988 by Olivetti Research Center
+ * Copyright (C) 1987 by Regents of the University of California
+ *
+ * Author:
+ * Pehong Chen
+ * Chen & Harrison International Systems, Inc.
+ * Palo Alto, California
+ * USA
+ * (phc@renoir.berkeley.edu or chen@orc.olivetti.com)
+ *
+ * Contributors:
+ * Please refer to the CONTRIB file that comes with this release
+ * for a list of people who have contributed to this and/or previous
+ * release(s) of MakeIndex.
+ *
+ * All rights reserved by the copyright holders. See the copyright
+ * notice distributed with this software for a complete description of
+ * the conditions under which it is made available.
+ *
+ */
+
+#include "mkind.h"
+#include "scanst.h"
+
+static int sty_lc = 0; /* line count */
+static int sty_tc = 0; /* total count */
+static int sty_ec = 0; /* error count */
+
+char idx_keyword[ARRAY_MAX] = IDX_KEYWORD;
+char idx_aopen = IDX_AOPEN;
+char idx_aclose = IDX_ACLOSE;
+char idx_level = IDX_LEVEL;
+char idx_ropen = IDX_ROPEN;
+char idx_rclose = IDX_RCLOSE;
+char idx_quote = IDX_QUOTE;
+char idx_actual = IDX_ACTUAL;
+char idx_encap = IDX_ENCAP;
+char idx_escape = IDX_ESCAPE;
+
+char preamble[ARRAY_MAX] = PREAMBLE_DEF;
+char postamble[ARRAY_MAX] = POSTAMBLE_DEF;
+int prelen = PREAMBLE_LEN;
+int postlen = POSTAMBLE_LEN;
+
+char setpage_open[ARRAY_MAX] = SETPAGEOPEN_DEF;
+char setpage_close[ARRAY_MAX] = SETPAGECLOSE_DEF;
+int setpagelen = SETPAGE_LEN;
+
+char group_skip[ARRAY_MAX] = GROUPSKIP_DEF;
+int skiplen = GROUPSKIP_LEN;
+
+int headings_flag = HEADINGSFLAG_DEF;
+char heading_pre[ARRAY_MAX] = HEADINGPRE_DEF;
+char heading_suf[ARRAY_MAX] = HEADINGSUF_DEF;
+int headprelen = HEADINGPRE_LEN;
+int headsuflen = HEADINGSUF_LEN;
+
+char symhead_pos[ARRAY_MAX] = SYMHEADPOS_DEF;
+char symhead_neg[ARRAY_MAX] = SYMHEADNEG_DEF;
+
+char numhead_pos[ARRAY_MAX] = NUMHEADPOS_DEF;
+char numhead_neg[ARRAY_MAX] = NUMHEADNEG_DEF;
+
+char item_r[FIELD_MAX][ARRAY_MAX] = {ITEM0_DEF, ITEM1_DEF, ITEM2_DEF};
+char item_u[FIELD_MAX][ARRAY_MAX] = {"", ITEM1_DEF, ITEM2_DEF};
+char item_x[FIELD_MAX][ARRAY_MAX] = {"", ITEM1_DEF, ITEM2_DEF};
+
+int ilen_r[FIELD_MAX] = {ITEM_LEN, ITEM_LEN, ITEM_LEN};
+int ilen_u[FIELD_MAX] = {0, ITEM_LEN, ITEM_LEN};
+int ilen_x[FIELD_MAX] = {0, ITEM_LEN, ITEM_LEN};
+
+char delim_p[FIELD_MAX][ARRAY_MAX] = {DELIM_DEF, DELIM_DEF, DELIM_DEF};
+char delim_n[ARRAY_MAX] = DELIM_DEF; /* page number separator */
+char delim_r[ARRAY_MAX] = DELIMR_DEF;/* page range designator */
+char delim_t[ARRAY_MAX] = DELIMT_DEF;/* page list terminating delimiter */
+
+char suffix_2p[ARRAY_MAX] = ""; /* suffix for two page ranges */
+char suffix_3p[ARRAY_MAX] = ""; /* suffix for three page ranges */
+char suffix_mp[ARRAY_MAX] = ""; /* suffix for multiple page ranges */
+
+char encap_p[ARRAY_MAX] = ENCAP0_DEF;/* encapsulator prefix */
+char encap_i[ARRAY_MAX] = ENCAP1_DEF;/* encapsulator infix */
+char encap_s[ARRAY_MAX] = ENCAP2_DEF;/* encapsulator postfix */
+
+int linemax = LINE_MAX;
+
+int indent_length = INDENTLEN_DEF;
+char indent_space[ARRAY_MAX] = INDENTSPC_DEF;
+
+char page_comp[ARRAY_MAX] = COMPOSITOR_DEF;
+int page_offset[PAGETYPE_MAX] = {
+0,
+ROMAN_LOWER_OFFSET,
+ROMAN_LOWER_OFFSET + ARABIC_OFFSET,
+ROMAN_LOWER_OFFSET + ARABIC_OFFSET + ALPHA_LOWER_OFFSET,
+ROMAN_LOWER_OFFSET + ARABIC_OFFSET + ALPHA_LOWER_OFFSET + ROMAN_UPPER_OFFSET
+};
+static char page_prec[ARRAY_MAX] = PRECEDENCE_DEF;
+
+static int put_dot;
+
+static int count_lfd ARGS((char *str));
+static int next_nonblank ARGS((void));
+static int process_precedence ARGS((void));
+static int scan_char ARGS((char *c));
+static int scan_spec ARGS((char *spec));
+static int scan_string ARGS((char *str));
+
+void
+scan_sty(VOID_ARG)
+{
+ char spec[STRING_MAX];
+ int tmp;
+
+ MESSAGE("Scanning style file %s", sty_fn);
+ while (scan_spec(spec)) {
+ sty_tc++;
+ put_dot = TRUE;
+
+ /* output pre- and post-ambles */
+ if (STREQ(spec, PREAMBLE)) {
+ (void) scan_string(preamble);
+ prelen = count_lfd(preamble);
+ } else if (STREQ(spec, POSTAMBLE)) {
+ (void) scan_string(postamble);
+ postlen = count_lfd(postamble);
+ } else if (STREQ(spec, GROUP_SKIP)) {
+ (void) scan_string(group_skip);
+ skiplen = count_lfd(group_skip);
+ } else if (STREQ(spec, HEADINGS_FLAG)) {
+ SCAN_NO(&headings_flag);
+ } else if (STREQ(spec, HEADING_PRE)) {
+ (void) scan_string(heading_pre);
+ headprelen = count_lfd(heading_pre);
+ } else if (STREQ(spec, HEADING_SUF)) {
+ (void) scan_string(heading_suf);
+ headsuflen = count_lfd(heading_suf);
+ } else if (STREQ(spec, SYMHEAD_POS)) {
+ (void) scan_string(symhead_pos);
+ } else if (STREQ(spec, SYMHEAD_NEG)) {
+ (void) scan_string(symhead_neg);
+ } else if (STREQ(spec, NUMHEAD_POS)) {
+ (void) scan_string(numhead_pos);
+ } else if (STREQ(spec, NUMHEAD_NEG)) {
+ (void) scan_string(numhead_neg);
+ } else if (STREQ(spec, SETPAGEOPEN)) {
+ (void) scan_string(setpage_open);
+ setpagelen = count_lfd(setpage_open);
+ } else if (STREQ(spec, SETPAGECLOSE)) {
+ (void) scan_string(setpage_close);
+ setpagelen = count_lfd(setpage_close);
+ /* output index item commands */
+ } else if (STREQ(spec, ITEM_0)) {
+ (void) scan_string(item_r[0]);
+ ilen_r[0] = count_lfd(item_r[0]);
+ } else if (STREQ(spec, ITEM_1)) {
+ (void) scan_string(item_r[1]);
+ ilen_r[1] = count_lfd(item_r[1]);
+ } else if (STREQ(spec, ITEM_2)) {
+ (void) scan_string(item_r[2]);
+ ilen_r[2] = count_lfd(item_r[2]);
+ } else if (STREQ(spec, ITEM_01)) {
+ (void) scan_string(item_u[1]);
+ ilen_u[1] = count_lfd(item_u[1]);
+ } else if (STREQ(spec, ITEM_12)) {
+ (void) scan_string(item_u[2]);
+ ilen_u[2] = count_lfd(item_u[2]);
+ } else if (STREQ(spec, ITEM_x1)) {
+ (void) scan_string(item_x[1]);
+ ilen_x[1] = count_lfd(item_x[1]);
+ } else if (STREQ(spec, ITEM_x2)) {
+ (void) scan_string(item_x[2]);
+ ilen_x[2] = count_lfd(item_x[2]);
+ /* output encapsulators */
+ } else if (STREQ(spec, ENCAP_0))
+ (void) scan_string(encap_p);
+ else if (STREQ(spec, ENCAP_1))
+ (void) scan_string(encap_i);
+ else if (STREQ(spec, ENCAP_2))
+ (void) scan_string(encap_s);
+ /* output delimiters */
+ else if (STREQ(spec, DELIM_0))
+ (void) scan_string(delim_p[0]);
+ else if (STREQ(spec, DELIM_1))
+ (void) scan_string(delim_p[1]);
+ else if (STREQ(spec, DELIM_2))
+ (void) scan_string(delim_p[2]);
+ else if (STREQ(spec, DELIM_N))
+ (void) scan_string(delim_n);
+ else if (STREQ(spec, DELIM_R))
+ (void) scan_string(delim_r);
+ else if (STREQ(spec, DELIM_T))
+ (void) scan_string(delim_t);
+ else if (STREQ(spec, SUFFIX_2P))
+ (void) scan_string(suffix_2p);
+ else if (STREQ(spec, SUFFIX_3P))
+ (void) scan_string(suffix_3p);
+ else if (STREQ(spec, SUFFIX_MP))
+ (void) scan_string(suffix_mp);
+ /* output line width */
+ else if (STREQ(spec, LINEMAX)) {
+ SCAN_NO(&tmp);
+ if (tmp > 0)
+ linemax = tmp;
+ else
+ STY_ERROR2("%s must be positive (got %d)",
+ LINEMAX, tmp);
+ /* output line indentation length */
+ } else if (STREQ(spec, INDENT_LENGTH)) {
+ SCAN_NO(&tmp);
+ if (tmp >= 0)
+ indent_length = tmp;
+ else
+ STY_ERROR2("%s must be nonnegative (got %d)",
+ INDENT_LENGTH, tmp);
+ /* output line indentation */
+ } else if (STREQ(spec, INDENT_SPACE)) {
+ (void) scan_string(indent_space);
+ /* composite page delimiter */
+ } else if (STREQ(spec, COMPOSITOR)) {
+ (void) scan_string(page_comp);
+ /* page precedence */
+ } else if (STREQ(spec, PRECEDENCE)) {
+ (void) scan_string(page_prec);
+ (void) process_precedence();
+ /* index input format */
+ } else if (STREQ(spec, KEYWORD))
+ (void) scan_string(idx_keyword);
+ else if (STREQ(spec, AOPEN))
+ (void) scan_char(&idx_aopen);
+ else if (STREQ(spec, ACLOSE))
+ (void) scan_char(&idx_aclose);
+ else if (STREQ(spec, LEVEL))
+ (void) scan_char(&idx_level);
+ else if (STREQ(spec, ROPEN))
+ (void) scan_char(&idx_ropen);
+ else if (STREQ(spec, RCLOSE))
+ (void) scan_char(&idx_rclose);
+ else if (STREQ(spec, QUOTE))
+ (void) scan_char(&idx_quote);
+ else if (STREQ(spec, ACTUAL))
+ (void) scan_char(&idx_actual);
+ else if (STREQ(spec, ENCAP))
+ (void) scan_char(&idx_encap);
+ else if (STREQ(spec, ESCAPE))
+ (void) scan_char(&idx_escape);
+ else {
+ (void) next_nonblank();
+ STY_SKIPLINE;
+ STY_ERROR("Unknown specifier %s.\n", spec);
+ put_dot = FALSE;
+ }
+ if (put_dot) {
+ STY_DOT;
+ }
+ }
+
+ /* check if quote and escape are distinct */
+ if (idx_quote == idx_escape) {
+ STY_ERROR(
+ "Quote and escape symbols must be distinct (both `%c' now).\n",
+ idx_quote);
+ idx_quote = IDX_QUOTE;
+ idx_escape = IDX_ESCAPE;
+ }
+ DONE(sty_tc - sty_ec, "attributes redefined", sty_ec, "ignored");
+ CLOSE(sty_fp);
+}
+
+static int
+#if STDC
+scan_spec(char spec[])
+#else
+scan_spec(spec)
+char spec[];
+#endif
+{
+ int i = 0;
+ int c;
+
+ while (TRUE)
+ if ((c = next_nonblank()) == -1)
+ return (FALSE);
+ else if (c == COMMENT) {
+ STY_SKIPLINE;
+ } else
+ break;
+
+ spec[0] = TOLOWER(c);
+ while ((i++ < STRING_MAX) && ((c = GET_CHAR(sty_fp)) != SPC) &&
+ (c != TAB) && (c != LFD) && (c != EOF))
+ spec[i] = TOLOWER(c);
+ if (i < STRING_MAX) {
+ spec[i] = NUL;
+ if (c == EOF) {
+ STY_ERROR(
+ "No attribute for specifier %s (premature EOF)\n",
+ spec);
+ return (-1);
+ }
+ if (c == LFD)
+ sty_lc++;
+ return (TRUE);
+ } else {
+ STY_ERROR2("Specifier %s too long (max %d).\n",
+ spec, STRING_MAX);
+ return (FALSE);
+ }
+}
+
+
+static int
+next_nonblank(VOID_ARG)
+{
+ int c;
+
+ while (TRUE) {
+ switch (c = GET_CHAR(sty_fp)) {
+ case EOF:
+ return (-1);
+
+ case LFD:
+ sty_lc++;
+ case SPC:
+ case TAB:
+ break;
+ default:
+ return (c);
+ }
+ }
+#if IBM_PC_TURBO
+ return (-1); /* not reached, but keeps compiler happy */
+#endif
+}
+
+
+static int
+#if STDC
+scan_string(char str[])
+#else
+scan_string(str)
+char str[];
+#endif
+{
+ char clone[ARRAY_MAX];
+ int i = 0;
+ int c;
+
+ switch (c = next_nonblank()) {
+ case STR_DELIM:
+ while (TRUE)
+ switch (c = GET_CHAR(sty_fp)) {
+ case EOF:
+ STY_ERROR("No closing delimiter in %s.\n",
+ clone);
+ return (FALSE);
+ case STR_DELIM:
+ clone[i] = NUL;
+ strcpy(str, clone);
+ return (TRUE);
+ case BSH:
+ switch (c = GET_CHAR(sty_fp)) {
+ case 't':
+ clone[i++] = TAB;
+ break;
+ case 'n':
+ clone[i++] = LFD;
+ break;
+
+ default:
+ clone[i++] = (char) c;
+ break;
+ }
+ break;
+ default:
+ if (c == LFD)
+ sty_lc++;
+ if (i < ARRAY_MAX)
+ clone[i++] = (char) c;
+ else {
+ STY_SKIPLINE;
+ STY_ERROR2(
+ "Attribute string %s too long (max %d).\n",
+ clone, ARRAY_MAX);
+ return (FALSE);
+ }
+ break;
+ }
+ break;
+ case COMMENT:
+ STY_SKIPLINE;
+ break;
+ default:
+ STY_SKIPLINE;
+ STY_ERROR("No opening delimiter.\n", "");
+ return (FALSE);
+ }
+ return (TRUE); /* function value no longer used */
+}
+
+
+static int
+#if STDC
+scan_char(char *c)
+#else
+scan_char(c)
+char *c;
+#endif
+{
+ int clone;
+
+ switch (clone = next_nonblank()) {
+ case CHR_DELIM:
+ switch (clone = GET_CHAR(sty_fp)) {
+ case CHR_DELIM:
+ STY_SKIPLINE;
+ STY_ERROR("Premature closing delimiter.\n", "");
+ return (FALSE);
+ case LFD:
+ sty_lc++;
+ case EOF:
+ STY_ERROR("No character (premature EOF).\n", "");
+ return (FALSE);
+ case BSH:
+ clone = GET_CHAR(sty_fp);
+ default:
+ if (GET_CHAR(sty_fp) == CHR_DELIM) {
+ *c = (char) clone;
+ return (TRUE);
+ } else {
+ STY_ERROR("No closing delimiter or too many letters.\n", "");
+ return (FALSE);
+ }
+ }
+ /* break; */ /* NOT REACHED */
+ case COMMENT:
+ STY_SKIPLINE;
+ break;
+ default:
+ STY_SKIPLINE;
+ STY_ERROR("No opening delimiter.\n", "");
+ return (FALSE);
+ }
+ return (TRUE); /* function value no longer used */
+}
+
+
+static int
+#if STDC
+count_lfd(char *str)
+#else
+count_lfd(str)
+char *str;
+#endif
+{
+ int i = 0;
+ int n = 0;
+
+ while (str[i] != NUL) {
+ if (str[i] == LFD)
+ n++;
+ i++;
+ }
+ return (n);
+}
+
+
+static int
+process_precedence(VOID_ARG)
+{
+ int order[PAGETYPE_MAX];
+ int type[PAGETYPE_MAX];
+ int i = 0;
+ int last;
+ int roml = FALSE;
+ int romu = FALSE;
+ int arab = FALSE;
+ int alpl = FALSE;
+ int alpu = FALSE;
+
+ /* check for llegal specifiers first */
+ while ((i < PAGETYPE_MAX) && (page_prec[i] != NUL)) {
+ switch (page_prec[i]) {
+ case ROMAN_LOWER:
+ if (roml) {
+ MULTIPLE(ROMAN_LOWER);
+ } else
+ roml = TRUE;
+ break;
+ case ROMAN_UPPER:
+ if (romu) {
+ MULTIPLE(ROMAN_UPPER);
+ } else
+ romu = TRUE;
+ break;
+ case ARABIC:
+ if (arab) {
+ MULTIPLE(ARABIC);
+ } else
+ arab = TRUE;
+ break;
+ case ALPHA_LOWER:
+ if (alpl) {
+ MULTIPLE(ALPHA_UPPER);
+ } else
+ alpl = TRUE;
+ break;
+ case ALPHA_UPPER:
+ if (alpu) {
+ MULTIPLE(ALPHA_UPPER);
+ } else
+ alpu = TRUE;
+ break;
+ default:
+ STY_SKIPLINE;
+ STY_ERROR("Unknow type `%c' in page precedence specification.\n",
+ page_prec[i]);
+ return (FALSE);
+ }
+ i++;
+ }
+ if (page_prec[i] != NUL) {
+ STY_SKIPLINE;
+ STY_ERROR("Page precedence specification string too long.\n", "");
+ return (FALSE);
+ }
+ last = i;
+ switch (page_prec[0]) {
+ case ROMAN_LOWER:
+ order[0] = ROMAN_LOWER_OFFSET;
+ type[0] = ROML;
+ break;
+ case ROMAN_UPPER:
+ order[0] = ROMAN_UPPER_OFFSET;
+ type[0] = ROMU;
+ break;
+ case ARABIC:
+ order[0] = ARABIC_OFFSET;
+ type[0] = ARAB;
+ break;
+ case ALPHA_LOWER:
+ order[0] = ALPHA_LOWER_OFFSET;
+ type[0] = ALPL;
+ break;
+ case ALPHA_UPPER:
+ order[0] = ALPHA_LOWER_OFFSET;
+ type[0] = ALPU;
+ break;
+ }
+
+ i = 1;
+ while (i < last) {
+ switch (page_prec[i]) {
+ case ROMAN_LOWER:
+ order[i] = order[i - 1] + ROMAN_LOWER_OFFSET;
+ type[i] = ROML;
+ break;
+ case ROMAN_UPPER:
+ order[i] = order[i - 1] + ROMAN_UPPER_OFFSET;
+ type[i] = ROMU;
+ break;
+ case ARABIC:
+ order[i] = order[i - 1] + ARABIC_OFFSET;
+ type[i] = ARAB;
+ break;
+ case ALPHA_LOWER:
+ order[i] = order[i - 1] + ALPHA_LOWER_OFFSET;
+ type[i] = ALPL;
+ break;
+ case ALPHA_UPPER:
+ order[i] = order[i - 1] + ALPHA_LOWER_OFFSET;
+ type[i] = ALPU;
+ break;
+ }
+ i++;
+ }
+
+ for (i = 0; i < PAGETYPE_MAX; i++) {
+ page_offset[i] = -1;
+ }
+ page_offset[type[0]] = 0;
+ for (i = 1; i < last; i++) {
+ page_offset[type[i]] = order[i - 1];
+ }
+ for (i = 0; i < PAGETYPE_MAX; i++) {
+ if (page_offset[i] == -1) {
+ switch (type[last - 1]) {
+ case ROML:
+ order[last] = order[last - 1] + ROMAN_LOWER_OFFSET;
+ break;
+ case ROMU:
+ order[last] = order[last - 1] + ROMAN_UPPER_OFFSET;
+ break;
+ case ARAB:
+ order[last] = order[last - 1] + ARABIC_OFFSET;
+ break;
+ case ALPL:
+ order[last] = order[last - 1] + ALPHA_LOWER_OFFSET;
+ break;
+ case ALPU:
+ order[last] = order[last - 1] + ALPHA_UPPER_OFFSET;
+ break;
+ }
+ type[last] = i;
+ page_offset[i] = order[last];
+ last++;
+ }
+ }
+ return (TRUE); /* function value no longer used */
+}