path: root/indexing/glo+idxtex/idxspell.c

/* #module    IdxSpell	"3-001"
 ***********************************************************************
 *                                                                     *
 * The software was developed at the Monsanto Company and is provided  *
 * "as-is".  Monsanto Company and the auther disclaim all warranties   *
 * on the software, including without limitation, all implied warran-  *
 * ties of merchantabilitiy and fitness.                               *
 *                                                                     *
 * This software does not contain any technical data or information    *
 * that is proprietary in nature.  It may be copied, modified, and     *
 * distributed on a non-profit basis and with the inclusion of this    *
 * notice.                                                             *
 *                                                                     *
 ***********************************************************************
 */
/*
 * Module Name:	IdxSpell
 *
 * Author:	R L Aurbach	CR&DS MIS Group    07-May-1986
 *
 * Function:
 *	Build the Spell String for an index term, properly handling LaTeX
 *	syntax and commands.
 *
 * Modification History:
 *
 * Version     Initials	   Date		Description
 * ------------------------------------------------------------------------
 * 1-001	RLA	07-May-1986	Original Code
 * 1-002	RLA	17-Mar-1987	Fix \verb error
 * 1-003	RLA	06-Apr-1987	Fix error processing emphasis
 * 2-004	RLA	16-Apr-1987	Honor the \verb environment in spelling
 * 2-005	RLA	20-Apr-1987	Enhance at-sign string
 * 3-001	F.H.	17-May-1991	converted to portable C
 */
/*
 * Module IdxSpell - Module-Wide Data Description Section
 *
 * Include Files:
 */
#ifdef MSDOS
#include <stdlib.h>
#include <io.h>
#define F_OK		0	/* access(): File exists */
#else
#include <sys/file.h>
extern char *sprintf();
#endif
#include <string.h>
#include <ctype.h>
#include "IdxDef.h"
/*
 * Module Definitions:
 */
#define		    TRUE	1
#define		    FALSE	0
/*
 * Global Declarations:
 */
/*
 * Static Declarations:
 */
#ifdef MSDOS
void idx_build_spell_string(char *desc);
void idx_replace_string(char *string, int start, int length, char *replace);
void idx_collapse_string(char *string);
void idx_process_accent(char *string);
void idx_process_groups(char *string);
int idx_process_verb(char *string);
void idx_process_backslash(char *string);
void idx_process_emphasis(char *string);
int idx_is_verbatim(char *desc, int *ctx, int *index);
void strupcase(char *in, char *out);
void strprefix(char *str, char prefix);
int strposition(char *str, char *e_array, int st);
int chrposition(char str, char *e_array);
#else
void idx_build_spell_string();
void idx_replace_string();
void idx_collapse_string();
void idx_process_accent();
void idx_process_groups();
int idx_process_verb();
void idx_process_backslash();
void idx_process_emphasis();
int idx_is_verbatim();
void strupcase();
void strprefix();
int strposition();
int chrposition();
#endif
static char *accent_set = "`'^\"~=.uvHtcdb";
#define	   emphasis_array_count	    18
    static char *emphasis_array[emphasis_array_count] = {
      "\\rm",
      "\\em",
      "\\bf",
      "\\it",
      "\\sf",
      "\\sl",
      "\\sc",
      "\\tt",
      "\\normalsize",
      "\\small",
      "\\tiny",
      "\\footnotesize",
      "\\large",
      "\\Large",
      "\\LARGE",
      "\\huge",
      "\\Huge",
      "\\cal"};
static char at_sign = '@';
static char *verb = "\\verb";
/*
 * External References:
 */
/*
 * Functions Called:
 */
/*
 * Function Idx_Build_Spell_String - Documentation Section
 *
 * Discussion:
 *	Create a string which can be used to put the token in the right place
 *	in a list of tokens.  The string will be UPPERCASE, will exclude 
 *	internal LaTeX commands which are included for emphasis, and will have
 *	whitespace collapsed into single spaces.
 *
 * Calling Synopsis:
 *	Call Idx_Build_Spell_String (token, desc)
 *
 * Inputs:
 *	token	    ->	is the token to be processed.  ASCIZ string passed by
 *			reference.
 *
 * Outputs:
 *	desc	    ->	is the "Spell String", properly formulated.  Passed by
 *			dynamic string descriptor.
 *
 * Return Value:
 *	none
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	none
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. Copy the token into a dynamic string.
 *	B. Process Accent commands in the string.
 *	C. Process emphasis commands in the string.
 *	D. Remove grouping characters in the string.
 *	E. Remove backslashes in the string.
 *	F. Process \verb commands in the string.
 *	G. Clean up the string.
 *	    1. Convert it to upper case.
 *	    2. Collapse the string -- i.e., remove non-essential whitespace.
 *	    3. If the string begins with a \, remove it.
 *	    4. Make sure that all strings beginning with symbols are in the
 *	       right place.
 *
 * Special Notes:
 *	none
 */

/*
 * Function Idx_Build_Spell_String - Code Section
 */
void idx_build_spell_string (desc)
    char *desc;
{
/*
 * Local Declarations
 */
/*
 * Module Body
 */
/* Copy the token string into a dynamic string for processing */
/* Process accent strings */
  idx_process_accent(desc);
/* Process emphasis commands */
  idx_process_emphasis(desc);
/* Remove grouping characters */
  idx_process_groups(desc);
/* Remove backslashes */
  idx_process_backslash(desc);
/* Process \verb commands */
  while (idx_process_verb(desc))	    ;
/* Clean up the string */
  strupcase(desc, desc);
  idx_collapse_string (desc);
  if (desc[0] == '\\') idx_replace_string(desc, 1, 1, (char *)0);
  if (desc[0] > 'Z') strprefix(desc, at_sign);
}

/*
 * Function Idx_Replace_String - Documentation Section
 *
 * Discussion:
 *	This function replaces a specified substring in a dynamic string with
 *	a specified replacement string.
 *
 * Calling Synopsis:
 *	Call Idx_Replace_String (string, start, length, replace)
 *
 * Inputs:
 *	string	    ->	is the string to be updated.  The string is a dynamic
 *			string, passed by descriptor.
 *
 *	start	    ->	is the starting position in the string.  The first
 *			position in the string is position 1.  Integer passed
 *			by value.
 *
 *	length	    ->	is the number of characters in the substring to be
 *			replaced.  Integer passed by value.
 *
 *	replace	    ->	is the replacement text.  ASCIZ string passed by 
 *			reference.
 *
 * Outputs:
 *	string	    ->	is the updated string.  It is a dynamic string, passed
 *			by descriptor.
 *
 * Return Value:
 *	none
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	none
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. Copy the characters up to the first character in the substring to
 *	   be replaced into a temporary string.
 *	B. Copy the replacement string into the temporary string.
 *	C. Copy the remainder of the initial string into the temporary string. 
 *	D. Update the initial string.
 *
 * Special Notes:
 *	It is assumed that the updated string will be no more than 132 
 *	characters long.
 */

/*
 * Function Idx_Replace_String - Code Section
 */
void idx_replace_string (string, start, length, replace)
    char *string;
    int  start;
    int  length;
    char *replace;
{
/*
 * Local Declarations
 */
  int  new_length;	    /* length of new string	    */
  int  rpl_length;	    /* length of the replace string */
  int  left;		    /* number of characters left    */
  char temp[133];	    /* temporary string		    */
/*
 * Module Body
 */
  new_length = 0;
  if (start > 1) {
    (void)strncpy(temp, string, start-1);
    new_length = start-1;
  }
  if (replace != 0) {
    rpl_length = strlen(replace);
    if (rpl_length > 0) {
      (void)strncpy(&temp[new_length], replace, rpl_length);
      new_length += rpl_length;
    }
  }
  left = strlen(string) - (start - 1) - length;
  if (left > 0) {
    (void)strncpy(&temp[new_length], &string[start+length-1], left);
    new_length += left;
  }
  temp[new_length] = '\0';
  string = strcpy(string, temp);
}

/*
 * Function Idx_Collapse_String - Documentation Section
 *
 * Discussion:
 *	Replace the string with a new string which as all extraneous whitespace
 *	removed.  That is, there is no whitespace at the beginning or end of
 *	the string and every internal occurrence of whitespace is collapsed to
 *	a single space character.
 *
 * Calling Synopsis:
 *	Call Idx_Collapse_String (string)
 *
 * Inputs:
 *	string	    ->	is the input string.  It is a dynamic string, passed by
 *			descriptor.
 *
 * Outputs:
 *	string	    ->	is the output string.  It is a dynamic string, passed by
 *			descriptor.
 *
 * Return Value:
 *	none
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	none
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. For all characters in the input string,
 *	    1. If the character is whitespace,
 *		a. If no characters have been transferred,
 *		    1. Ignore it.
 *		b. If the previous character transferred was a space,
 *		    1. Ignore it.
 *		c. Else,
 *		    1. Copy a space to the output string.
 *	    2. Else,
 *		a. Copy the character to the output string.
 *	B. If the last character in the output string is a space,
 *	    1. Remove it.
 *	C. Update the dynamic string.
 *
 * Special Notes:
 *	It is assumed that the collapsed string will be no more than 132 
 *	characters long.
 */

/*
 * Function Idx_Collapse_String - Code Section
 */
void idx_collapse_string (string)
char *string;
{
/*
 * Local Declarations
 */
  char temp[133];	    /* Working output string	    */
  char copy;		    /* Working character	    */
  int  i;		    /* Array index in input string  */
  int  j;		    /* Array index in temp string   */
/*
 * Module Body
 */
  for (i=0, j=0; i<strlen(string); i++) {
    copy = string[i];
    if (isspace(copy) != 0) {
      if (j == 0) continue;
      else {
	if (temp[j-1] == ' ') continue;
	else temp[j++] = ' ';
      }
    }
    else temp[j++] = copy;
  }
/* Check to see if the temporary string is terminated by whitespace */
  if ((j > 0) && (temp[j-1] == ' ')) j--;
/* Now copy the result to the output string */
  temp[j] = '\0';
  (void)strcpy(string, temp);
}

/*
 * Function Idx_Process_Accents - Documentation Section
 *
 * Discussion:
 *	This routine processes the spell string to remove all LaTeX commands
 *	which generate accents, without changing the spelling.  For example,
 *	the string "se\~{n}or" is translated to "senor".  Without special
 *	accent processing, the spell-string algorithm would produce "se n or",
 *	which might not appear in the proper place in the alphabetical listing.
 *
 * Calling Synopsis:
 *	call Idx_Process_Accents (string)
 *
 * Inputs:
 *	string	    ->	is the spell-string to be processed.  It is a dynamic
 *			string, passed by descriptor.
 *
 * Outputs:
 *	string	    ->	is the resultant spell-string.  It is a dynamic string,
 *			passed by descriptor.
 *
 * Return Value:
 *	none
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	none
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:.
 *	A. Search the string for an accent pattern:
 *	    1. The first character in the pattern is "\".
 *	    2. The next character in the pattern is one of the characters in
 *	       the accent_set.
 *	    3. The next character in the pattern is "{".
 *	B. Mark the pattern and find the terminating "}".
 *	C. Replace the pattern with the string located within the braces.
 *
 * Special Notes:
 *	none
 */
/*
 * Function Idx_Process_Accent - Code Section
 */ 
void idx_process_accent(string)
char *string;
{
/*
 * Local Declarations
 */
  char   accent_str = '\0';
  int    start;	            /* Start of string to replace   */
  char   *replace;	    /* Replacement string	    */
  int    i;		    /* Loop index		    */
  int    ctx = 0;	    /* context variable		    */
/*
 * Module Body
 */
  for (i = 0; i < strlen(string); i++) {
    if (string[i] != '\\') continue;
    start = ++i;
    accent_str = string[i];
    if (chrposition(accent_str, accent_set) == 0) continue;
    if (string[++i] != '{') continue;
    if (idx_is_verbatim(string, &ctx, &i)) continue;
    replace = &string[++i];
    while (i < strlen(string)) {
      if (string[i++] != '}') continue;
      string[i-1] = '\0';
      break;
    }
    idx_replace_string (string, start, i-start+1, replace);
  }
}

/*
 * Function Idx_Process_Groups - Documentation Section
 *
 * Discussion:
 *	Process the characters which delimit groups ('{', '}', and '$') in the
 *	spell string.  These characters are removed unless they are quoted
 *	(e.g., "{" is removed but "\{" is not).
 *
 * Calling Synopsis:
 *	Call Idx_Process_Groups (String)
 *
 * Inputs:
 *	string	    ->	is the spell string.  It is a dynamic string passed by
 *			descriptor.
 *
 * Outputs:
 *	string	    ->	is the spell string.  It is a dynamic string passed by
 *			descriptor.
 *
 * Return Value:
 *	none
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	returns with spell string possibly modified.
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. For all characters in the spell string,
 *	    1. If the character is '{', '}', or '$' and the preceeding
 *	       character is not a '\',
 *		a. Remove the character.
 *
 * Special Notes:
 *	none
 */

/*
 * Function Idx_Process_Groups - Code Section
 */ 
void idx_process_groups(string)
char *string;
{
/*
 * Local Declarations
 */
  int    i;		/* Loop index	    */
  int    ctx = 0;	/* Context variable */
/*
 * Module Body
 */
  for (i = 0; i < strlen(string); i++) {
    if ((string[i] == '{')||(string[i] == '}')||(string[i] == '$')) {
      if ((i == 0) || (string[i-1] != '\\')) {
	if (idx_is_verbatim(string, &ctx, &i)) continue;
	idx_replace_string(string, i+1, 1, (char *)0);	
	i--;
      }
    }
  }
}

/*
 * Function Idx_Process_Verb - Documentation Section
 *
 * Discussion:
 *	Process LaTeX \verb and \verb* commands in the spell string.  This is
 *	done by removing the \verb command from the spell string.
 *
 * Calling Synopsis:
 *	status = Idx_Process_Verb (string)
 *
 * Inputs:
 *	string	    ->	Spell string.  A dynamic string passed by descriptor.
 *
 * Outputs:
 *	string	    ->	Spell string.  A dynamic string passed by descriptor.
 *
 * Return Value:
 *	status	    ->	is a boolean integer passed by value.  It indicates
 *			whether or not a \verb command was found in the spell
 *			string.
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	status = TRUE	A \verb command was processed in the string.
 *	status = FALSE	No \verb command was processed.
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. Search the string for a \verb command:
 *	    1. \verb [optionally followed by a *]
 *	    2. Next character is not alphabetic
 *	B. Mark the pattern and find the terminating character.
 *	C. Replace the pattern with its argument.
 *
 * Special Notes:
 *	none
 */

/*
 * Function Idx_Process_Verb - Code Section
 */
int idx_process_verb(string)
char *string;
{
/*
 * Local Declarations
 */
  int    i;	        /* Loop index			    */
  int    start; 	/* Start of pattern		    */
  char   delim; 	/* Delimiter character		    */ 
  char   *replace;	/* Pointer to replacement string    */
/*
 * Module Body
 */ 
  if ((strlen(string)) < 7) return (FALSE);
  for (i = 0; i < (strlen(string)-7); i++) { 
    if (strncmp(&string[i], "\\verb", 5) != 0) continue;
    start = i + 1;
    i += 5;
    if (string[i] == '*') i++;
    delim = string[i++]; 
    if (isalpha(delim) != 0) continue;
    replace = &string[i];
    while (i < strlen(string)) {
      if (string[i++] != delim) continue;
      if (i < (strlen(string)-1)) {
	i = strlen(string);
	string[i-1] = delim;
	string[i] = '\0';
	i++;
      }
      else string[i-1] = '\0'; 
      break; 
    }
    idx_replace_string (string, start, i-start+1, replace); 
    return (TRUE);
  } 
  return (FALSE); 
} 

/*
 * Function Idx_Process_Backslash - Documentation Section
 *
 * Discussion:
 *	Remove all '\' characters.
 *
 * Calling Synopsis:
 *	Call Idx_Process_Backslash (string)
 *
 * Inputs:
 *	string	    ->	Spell String.  Dynamic string passed by descriptor.
 *
 * Outputs:
 *	string	    ->	Spell String.  Dynamic string passed by descriptor.
 *
 * Return Value:
 *	none
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	return
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. For all characters in the spell string,
 *	    1. If the character is a '\',
 *		a. Remove it.
 *
 * Special Notes:
 *	none
 */

/*
 * Function Idx_Process_Backslash - Code Section
 */
void idx_process_backslash(string)
char *string;
{
/*
 * Local Declarations
 */
  int    i;		/* Loop index	    */
  int    ctx = 0;	/* Context variable */
/*
 * Module Body
 */
  for (i = 0; i < strlen(string); i++) {
    if (string[i] == '\\') {
      if (idx_is_verbatim(string, &ctx, &i)) continue;
      idx_replace_string(string, i+1, 1, (char *)0); 
      i--;
    }
  }
}

/*
 * Function Idx_Process_Emphasis - Documentation Section
 *
 * Discussion:
 *	Remove the normal LaTeX emphasis strings (\rm, \em, \bf, \it, \sf,
 *	\sl, \tt, \normalsize, \small, \tiny, \footnotesize, \large, \Large,
 *	\LARGE, \huge, \Huge, \cal).
 *
 * Calling Synopsis:
 *	call Idx_Process_Emphasis (string)
 *
 * Inputs:
 *	string	    ->	Spell string.  Dynamic string passed by descriptor.
 *
 * Outputs:,
 *	string	    ->	Spell string.  Dynamic string passed by descriptor.
 *
 * Return Value:
 *	none
 *
 * Global Data:
 *	none 
 *
 * Files Used:
 *	none 
 *
 * Assumed Entry State: 
 *	nones
 *
 * Normal Exit State:
 *	none
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. For each of the listed special commands,
 *	    1. For each occurence of the string which is not part of a word, 
 *		a. Remove it.
 *
 * Special Notes:
 *	none
 */ 
/*
 * Function Idx_Process_Emphasis - Code Sections
 */
void idx_process_emphasis(string)
char *string;
{
/*
 * Local Declarations
 */
  int    i;		/* emphasis_array index		    */
  int    start;		/* starting position		    */
  int    length;	/* length of substring		    */
  int    ctx;		/* context variable		    */
  int    index;		/* string index			    */
  int    rpl_start;	/* start of string to replace	    */
/*
 * Module Body
 */
  for (i = 0; i < emphasis_array_count; i++) {
    ctx = 0;
    start = 0;
    while ((start = strposition(string, emphasis_array[i], start))
	   != -1) {
      rpl_start = start+1;
      index = start;
      length = strlen(emphasis_array[i]); 
      start += length;
/*@@@      if (((start) <= strlen(string)) &&
	  (isalpha(string[start-1]) != 0)) continue;*/
      if (idx_is_verbatim(string, &ctx, &index)) continue;
      idx_replace_string(string, rpl_start, length, (char *)0);
    }
  }
}

/*
 * Function Idx_Is_Verbatim - Documentation Sectione
 *
 * Discussion:
 *	Deterimine if the current string index is within a \verb or \verb*     
 *	range. 
 *
 * Calling Synopsis:
 *	boolean = Idx_Is_Verbatim (desc, ctx, index)
 *
 * Inputs:
 *	desc	    ->	is the character string descriptor being processed.
 *
 *	ctx	    ->	is a context variable, passed by ref.  Internally,
 *			it is the current starting value for the search. 
 *
 *	index	    ->	is the string index being tested. 
 *
 * Outputs:
 *	ctx	    ->	is the value of the first character to follow the	
 *			\verb or \verb* string.
 *
 *	index	    ->	is the new value of the string index.  If the index)
 *			is not in a verbatim, then the value is unchanged. 
 *			If it is in the string, then the index is updated to
 *			the end of the verbatim range.
 *
 * Return Value:
 *	boolean	    ->	is a boolean value.
 *
 * Global Data:
 *	none
 *
 * Files Used:
 *	none
 *
 * Assumed Entry State:
 *	none
 *
 * Normal Exit State:
 *	boolean = TRUE	    Input index is within the range of a verbatim.
 *			    Index is updated.  Ctx may be updated.
 *	boolean = FALSE	    Input string is not within the range of a verbatim.
 *			    Index and Ctx are unchanged.
 *
 * Error Conditions:
 *	none
 *
 * Algorithm:
 *	A. If index < ctx, then we know that we aren't in a verbatim.
 *	    1. Return FALSE.
 *	B. Find the next verbatim range.  Save the start and end (= ctx).
 *	C. If index < start,
 *	    1. Return FALSE,
 *	D. Else,
 *	    1. Index = end of range.
 *	    2. Return TRUE.
 *
 * Special Notes:
 *	none
 */

/*
 * Function Idx_Is_Verbatim - Code Section
 */
int idx_is_verbatim(desc, ctx, index)
char *desc;
int  *ctx;
int  *index;
{
/*
 * Local Declarationsn
 */
  int    start;
  int    i;
  char   delim;
/*
 * Module Body
 */
  if (*index < *ctx) return(FALSE);
/*
 * Find the next verbatim range.  If there are less than seven characters left
 * in the string, then the remainder of the string cannot contain a \verb 
 * command (because there isn't room).  Set the ctx variable to point to the
 * end of the string and report that we are not within a verbatim.
 */
  if ((strlen(desc) - *ctx) < 7) {
    *ctx = strlen(desc);
    return (FALSE);
  }
/*
 * Search for the next \verb string.  Note that the STR$POSITION routine uses
 * the convention that the first character of the string is position 1 (not 0).
 * If no string was found, then set the ctx to the end of the string and report
 * that we aren't in a verbatim.
 */
  i = *ctx;
  start = strposition(desc, verb, i);
  i = *ctx + 1;
  if (start == -1) { 
    *ctx = strlen(desc);
    return (FALSE);
  }
/*
 * There may be a verbatim in the string.  Its potential starting position is
 * "start" (adjusted to index the string from 0 rather than 1).  If this is
 * the case, then the delimiter character will not be an alpha.
 */
/*  start--;*/
  i = start + 5;
  if (desc[i] == '*')  i++;
  delim = desc[i];
/*
 * If the delimiter is an alpha, then we have not found a verbatim string (it
 * is something else).  If the index we are checking is within the range we've
 * looked at, then we know that it isn't in a verbatim and we can so report.
 *
 * On the other hand, if we haven't gotten far enough into the string yet to
 * know, we must keep looking.  We do this by calling this routine recursively.
 */
  if (isalpha(delim) != 0) {
    *ctx = i;
    if (*index < i) return (FALSE);
    else return(idx_is_verbatim(desc, ctx, index));
  }
/*
 * We have found a real verbatim string.  We search for its end.
 */
  while (i < strlen(desc)) if (desc[++i] == delim) break;
  *ctx = ++i;
/*
 * Now we can check to see if we're ok.  If the index is before the start of
 * the verbatim string, we aren't in it.  If it is in the middle, we are.
 * If it's after the end, we still don't know and have to call ourselves
 * recursively to find out.
 */
  if (*index < start) return(FALSE);
  if (*index < *ctx) {
    *index = *ctx - 1;
    return(TRUE);
  }
  else return(idx_is_verbatim(desc, ctx, index));
}

int strposition(str, e_array, st)
char *str;
char *e_array;
int st;
{
  int i, slen, elen, found;
  slen = strlen(str);
  elen = strlen(e_array);
  found = -1;
  for (i=st; i < (slen-elen); i++) {
    if (strncmp(&str[i],e_array,elen) == 0) {
      found = i;
      break;
    }
  }
  return(found);
}

int chrposition(str, e_array)
char str;
char *e_array;
{
  int i, elen, found;
  elen = strlen(e_array);
  found = 1;
  for (i=0; i < elen; i++)
    if (e_array[i] == str) {
      found = 0;
      break;
    }
  return(found);
}

void strupcase(in,out)
char *in,*out;
{
  int i,len;
  len = strlen(in);
  for (i=0;i<len;i++)
    if ((in[i] >= 'a') && (in[i] <= 'z')) out[i] = in[i]-32;
}

void strprefix(str,prefix)
char *str;
char prefix;
{
  int i,len;
  char tmp,tmp2;
  len = strlen(str);
  i = 0;
  tmp = str[i];
  str[i] = prefix;
  for (i=1;i<=len;i++) {
    tmp2 = str[i+1];
    str[i] = tmp;
    tmp = tmp2;
  }
  str[i] = tmp;
}