/* ------------------------------------------------------------------------ @NAME : string_util.c @DESCRIPTION: Various string-processing utility functions: bt_purify_string() bt_change_case() and their helpers: foreign_letter() purify_special_char() @GLOBALS : @CALLS : @CALLERS : @CREATED : 1997/10/19, Greg Ward @MODIFIED : 1997/11/25, GPW: renamed to from purify.c to string_util.c added bt_change_case() and friends @VERSION : $Id: string_util.c,v 1.10 1999/10/28 22:50:28 greg Rel $ -------------------------------------------------------------------------- */ #include #include #include #include #include "error.h" #include "btparse.h" #include "bt_debug.h" /* * These definitions should be fixed to be consistent with HTML * entities, just for fun. And perhaps I should add entries for * accented letters (at least those supported by TeX and HTML). */ typedef enum { L_OTHER, /* not a "foreign" letter */ L_OSLASH_L, /* Eastern European {\o} */ L_OSLASH_U, L_LSLASH_L, /* {\l} */ L_LSLASH_U, L_OELIG_L, /* Latin {\oe} ligature */ L_OELIG_U, L_AELIG_L, /* {\ae} ligature */ L_AELIG_U, L_SSHARP_L, /* German "sharp s" {\ss} */ L_SSHARP_U, L_ACIRCLE_L, /* Nordic {\aa} */ L_ACIRCLE_U, L_INODOT_L, /* undotted i: {\i} */ L_JNODOT_L /* {\j} */ } bt_letter; static const char * uc_version[] = { NULL, /* L_OTHER */ "\\O", /* L_OSLASH_L */ "\\O", /* L_OSLASH_U */ "\\L", /* L_LSLASH_L */ "\\L", /* L_LSLASH_U */ "\\OE", /* L_OELIG_L */ "\\OE", /* L_OELIG_U */ "\\AE", /* L_AELIG_L */ "\\AE", /* L_AELIG_U */ "SS", /* L_SSHARP_L -- for LaTeX 2.09 */ "\\SS", /* L_SSHARP_U */ "\\AA", /* L_ACIRCLE_L */ "\\AA", /* L_ACIRCLE_U */ "I", /* L_INODOT_L */ "J" /* L_JNODOT_L */ }; static const char * lc_version[] = { NULL, /* L_OTHER */ "\\o", /* L_OSLASH_L */ "\\o", /* L_OSLASH_U */ "\\l", /* L_LSLASH_L */ "\\l", /* L_LSLASH_U */ "\\oe", /* L_OELIG_L */ "\\oe", /* L_OELIG_U */ "\\ae", /* L_AELIG_L */ "\\ae", /* L_AELIG_U */ "\\ss", /* L_SSHARP_L */ "\\ss", /* L_SSHARP_U */ "\\aa", /* L_ACIRCLE_L */ "\\aa", /* L_ACIRCLE_U */ "\\i", /* L_INODOT_L */ "\\j" /* L_JNODOT_L */ }; /* ------------------------------------------------------------------------ @NAME : foreign_letter() @INPUT : str start stop @OUTPUT : letter @RETURNS : TRUE if the string delimited by start and stop is a foreign letter control sequence @DESCRIPTION: Determines if a character sequence is one of (La)TeX's "foreign letter" control sequences (l, o, ae, oe, aa, ss, plus uppercase versions). If `letter' is non-NULL, returns which letter was found in it (as a bt_letter value). @CALLS : @CALLERS : purify_special_char() @CREATED : 1997/10/19, GPW @MODIFIED : -------------------------------------------------------------------------- */ static boolean foreign_letter (char *str, int start, int stop, bt_letter * letter) { char c1, c2; bt_letter dummy; /* * This is written for speed, not flexibility -- adding new foreign * letters would be trying and vexatious. * * N.B. my gold standard list of foreign letters is Kopka and Daly's * *A Guide to LaTeX 2e*, section 2.5.6. */ if (letter == NULL) /* so we can assign to *letter */ letter = &dummy; /* without compunctions */ *letter = L_OTHER; /* assume not a "foreign" letter */ c1 = str[start+0]; /* only two characters that we're */ c2 = str[start+1]; /* interested in */ switch (stop - start) { case 1: /* one-character control sequences */ switch (c1) /* (\o and \l) */ { case 'o': *letter = L_OSLASH_L; return TRUE; case 'O': *letter = L_OSLASH_U; return TRUE; case 'l': *letter = L_LSLASH_L; return TRUE; case 'L': *letter = L_LSLASH_L; return TRUE; case 'i': *letter = L_INODOT_L; return TRUE; case 'j': *letter = L_JNODOT_L; return TRUE; default: return FALSE; } break; case 2: /* two character control sequences */ switch (c1) /* (\oe, \ae, \aa, and \ss) */ { case 'o': if (c2 == 'e') { *letter = L_OELIG_L; return TRUE; } case 'O': if (c2 == 'E') { *letter = L_OELIG_U; return TRUE; } /* BibTeX 0.99 does not handle \aa and \AA -- but I do!*/ case 'a': if (c2 == 'e') { *letter = L_AELIG_L; return TRUE; } else if (c2 == 'a') { *letter = L_ACIRCLE_L; return TRUE; } else return FALSE; case 'A': if (c2 == 'E') { *letter = L_AELIG_U; return TRUE; } else if (c2 == 'A') { *letter = L_ACIRCLE_U; return TRUE; } else return FALSE; /* uppercase sharp-s -- new with LaTeX 2e (so far all I do * is recognize it as a "foreign" letter) */ case 's': if (c2 == 's') { *letter = L_SSHARP_L; return TRUE; } else return FALSE; case 'S': if (c2 == 'S') { *letter = L_SSHARP_U; return TRUE; } else return FALSE; } break; default: return FALSE; } /* switch on length of control sequence */ internal_error ("foreign_letter(): should never reach end of function"); return FALSE; /* to keep gcc -Wall happy */ } /* foreign_letter */ /* ------------------------------------------------------------------------ @NAME : purify_special_char() @INPUT : *src, *dst - pointers into the input and output strings @OUTPUT : *src - updated to point to the closing brace of the special char *dst - updated to point to the next available spot for copying text to @RETURNS : @DESCRIPTION: "Purifies" a BibTeX special character. On input, *src should point to the opening brace of a special character (ie. the brace must be at depth 0 of the whole string, and the character immediately following it must be a backslash). *dst should point to the next spot to copy into the output (purified) string. purify_special_char() will skip over the opening brace and backslash; if the control sequence is one of LaTeX's foreign letter sequences (as determined by foreign_letter()), then it is simply copied to *dst. Otherwise the control sequence is skipped. In either case, text after the control sequence is either copied (alphabetic characters) or skipped (anything else, including hyphens, ties, and digits). @CALLS : foreign_letter() @CALLERS : bt_purify_string() @CREATED : 1997/10/19, GPW @MODIFIED : -------------------------------------------------------------------------- */ static void purify_special_char (char *str, int * src, int * dst) { int depth; int peek; assert (str[*src] == '{' && str[*src + 1] == '\\'); depth = 1; *src += 2; /* jump to start of control sequence */ peek = *src; /* scan to end of control sequence */ while (isalpha (str[peek])) peek++; if (peek == *src) /* in case of single-char, non-alpha */ peek++; /* control sequence (eg. {\'e}) */ if (foreign_letter (str, *src, peek, NULL)) { assert (peek - *src == 1 || peek - *src == 2); str[(*dst)++] = str[(*src)++]; /* copy first char */ if (*src < peek) /* copy second char, downcasing */ str[(*dst)++] = tolower (str[(*src)++]); } else /* not a foreign letter -- skip */ { /* the control sequence entirely */ *src = peek; } while (str[*src]) { switch (str[*src]) { case '{': depth++; (*src)++; break; case '}': depth--; if (depth == 0) return; /* done with special char */ (*src)++; break; default: if (isalpha (str[*src])) /* copy alphabetic chars */ str[(*dst)++] = str[(*src)++]; else /* skip everything else */ (*src)++; } } /* * If we get here, we have unbalanced braces -- the '}' case should * always hit a depth == 0 point if braces are balanced. No warning, * though, because a) BibTeX doesn't warn about purifying unbalanced * strings, and b) we (should have) already warned about it in the * lexer. */ } /* purify_special_char() */ /* ------------------------------------------------------------------------ @NAME : bt_purify_string() @INOUT : instr @INPUT : options @OUTPUT : @RETURNS : instr - same as input string, but modified in place @DESCRIPTION: "Purifies" a BibTeX string. This consists of copying alphanumeric characters, converting hyphens and ties to space, copying spaces, and skipping everything else. (Well, almost -- special characters are handled specially, of course. Basically, accented letters have the control sequence skipped, while foreign letters have the control sequence preserved in a reasonable manner. See purify_special_char() for details.) @CALLS : purify_special_char() @CALLERS : @CREATED : 1997/10/19, GPW @MODIFIED : -------------------------------------------------------------------------- */ void bt_purify_string (char * string, ushort options) { int src, /* both indeces into string */ dst; int depth; /* brace depth in string */ unsigned orig_len; /* * Since purification always copies or deletes chars, outstr will * be no longer than string -- so nothing fancy is required to put * an upper bound on its eventual size. */ depth = 0; src = 0; dst = 0; orig_len = strlen (string); DBG_ACTION (1, printf ("bt_purify_string(): input = %p (%s)\n", string, string)); while (string[src] != (char) 0) { DBG_ACTION (2, printf (" next: >%c<: ", string[src])); switch (string[src]) { case '~': /* "separator" characters -- */ case '-': /* replaced with space */ case ' ': /* and copy an actual space */ string[dst++] = ' '; src++; DBG_ACTION (2, printf ("replacing with space")); break; case '{': if (depth == 0 && string[src+1] == '\\') { DBG_ACTION (2, printf ("special char found")); purify_special_char (string, &src, &dst); } else { DBG_ACTION (2, printf ("ordinary open brace")); src++; } depth++; break; case '}': DBG_ACTION (2, printf ("close brace")); depth--; src++; break; default: if (isalnum (string[src])) /* any alphanumeric char -- */ { DBG_ACTION (2, printf ("alphanumeric -- copying")); string[dst++] = string[src++]; /* copy it */ } else /* anything else -- skip it */ { DBG_ACTION (2, printf ("non-separator, non-brace, non-alpha")); src++; } } /* switch string[src] */ DBG_ACTION (2, printf ("\n")); } /* while string[src] */ DBG_ACTION (1, printf ("bt_purify_string(): depth on exit: %d\n", depth)); string[dst] = (char) 0; assert (strlen (string) <= orig_len); } /* bt_purify_string() */ /* ====================================================================== * Case-transformation stuff */ /* ------------------------------------------------------------------------ @NAME : convert_special_char() @INPUT : transform @INOUT : string src dst start_sentence after_colon @RETURNS : @DESCRIPTION: Does case conversion on a special character. @GLOBALS : @CALLS : @CALLERS : @CREATED : 1997/11/25, GPW @MODIFIED : -------------------------------------------------------------------------- */ static void convert_special_char (char transform, char * string, int * src, int * dst, boolean * start_sentence, boolean * after_colon) { int depth; boolean done_special; int cs_end; int cs_len; /* counting the backslash */ bt_letter letter; const char * repl; int repl_len; #ifndef ALLOW_WARNINGS repl = NULL; /* silence "might be used" */ /* uninitialized" warning */ #endif /* First, copy just the opening brace */ string[(*dst)++] = string[(*src)++]; /* * Now loop over characters inside the braces -- stop when we reach * the matching close brace, or when the string ends. */ depth = 1; /* because we're in a special char */ done_special = FALSE; while (string[*src] != 0 && !done_special) { switch (string[*src]) { case '\\': /* a control sequence */ { cs_end = *src+1; /* scan over chars of c.s. */ while (isalpha (string[cs_end])) cs_end++; /* * OK, now *src points to the backslash (so src+*1 points to * first char. of control sequence), and cs_end points to * character immediately following end of control sequence. * Thus we analyze [*src+1..cs_end] to determine if the control * sequence is a foreign letter, and use (cs_end - (*src+1) + 1) * = (cs_end - *src) as the length of the control sequence. */ cs_len = cs_end - *src; /* length of cs, counting backslash */ if (foreign_letter (string, *src+1, cs_end, &letter)) { if (letter == L_OTHER) internal_error ("impossible foreign letter"); switch (transform) { case 'u': repl = uc_version[(int) letter]; break; case 'l': repl = lc_version[(int) letter]; break; case 't': if (*start_sentence || *after_colon) { repl = uc_version[(int) letter]; *start_sentence = *after_colon = FALSE; } else { repl = lc_version[(int) letter]; } break; default: internal_error ("impossible case transform \"%c\"", transform); } repl_len = strlen (repl); if (repl_len > cs_len) internal_error ("replacement text longer than original cs"); strncpy (string + *dst, repl, repl_len); *src = cs_end; *dst += repl_len; } /* control sequence is a foreign letter */ else { /* not a foreign letter -- just copy the control seq. as is */ strncpy (string + *dst, string + *src, cs_end - *src); *src += cs_len; assert (*src == cs_end); *dst += cs_len; } /* control sequence not a foreign letter */ break; } /* case: '\\' */ case '{': { string[(*dst)++] = string[(*src)++]; depth++; break; } case '}': { string[(*dst)++] = string[(*src)++]; depth--; if (depth == 0) done_special = TRUE; break; } default: /* any other character */ { switch (transform) { /* * Inside special chars, lowercase and title caps are same. * (At least, that's bibtex's convention. I might change this * at some point to be a bit smarter.) */ case 'l': case 't': string[(*dst)++] = tolower (string[(*src)++]); break; case 'u': string[(*dst)++] = toupper (string[(*src)++]); break; default: internal_error ("impossible case transform \"%c\"", transform); } } /* default char */ } /* switch: current char */ } /* while: string or special char not done */ } /* convert_special_char() */ /* ------------------------------------------------------------------------ @NAME : bt_change_case() @INPUT : @OUTPUT : @RETURNS : @DESCRIPTION: Converts a string (in-place) to either uppercase, lowercase, or "title capitalization"> @GLOBALS : @CALLS : @CALLERS : @CREATED : 1997/11/25, GPW @MODIFIED : -------------------------------------------------------------------------- */ void bt_change_case (char transform, char * string, ushort options) { int len; int depth; int src, dst; /* indeces into string */ boolean start_sentence; boolean after_colon; src = dst = 0; len = strlen (string); depth = 0; start_sentence = TRUE; after_colon = FALSE; while (string[src] != 0) { switch (string[src]) { case '{': /* * At start of special character? The entire special char. * will be handled here, as follows: * - text at any brace-depth within the s.c. is case-mangled; * punctuation (sentence endings, colons) are ignored * - control sequences are left alone, unless they are * one of the "foreign letter" control sequences, in * which case they're converted to the appropriate string * according to the uc_version or lc_version tables. */ if (depth == 0 && string[src+1] == '\\') { convert_special_char (transform, string, &src, &dst, &start_sentence, &after_colon); } /* * Otherwise, it's just something in braces. This is probably * a proper noun or something encased in braces to protect it * from case-mangling, so we do not case-mangle it. However, * we *do* switch out of start_sentence or after_colon mode if * we happen to be there (otherwise we'll do the wrong thing * once we're out of the braces). */ else { string[dst++] = string[src++]; start_sentence = after_colon = FALSE; depth++; } break; case '}': string[dst++] = string[src++]; depth--; break; /* * Sentence-ending punctuation and colons are handled separately * to allow for exact mimicing of BibTeX's behaviour. I happen * to think that this behaviour (capitalize first word of sentences * in a title) is better than BibTeX's, but I want to keep my * options open for a future goal of perfect compatability. */ case '.': case '?': case '!': start_sentence = TRUE; string[dst++] = string[src++]; break; case ':': after_colon = TRUE; string[dst++] = string[src++]; break; default: if (isspace (string[src])) { string[dst++] = string[src++]; } else { if (depth == 0) { switch (transform) { case 'u': string[dst++] = toupper (string[src++]); break; case 'l': string[dst++] = tolower (string[src++]); break; case 't': if (start_sentence || after_colon) { /* * XXX BibTeX only preserves case of character * immediately after a colon; I do two things * differently: first, I pay attention to sentence * punctuation, and second I force uppercase * at start of sentence or after a colon. */ string[dst++] = toupper (string[src++]); start_sentence = after_colon = FALSE; } else { string[dst++] = tolower (string[src++]); } break; default: internal_error ("impossible case transform \"%c\"", transform); } } /* depth == 0 */ else { string[dst++] = string[src++]; } } /* not blank */ } /* switch on current character */ } /* while not at end of string */ } /* bt_change_case */