standard.shar

书名:C语言科学与艺术,以前交钱下载的

X    int len1, len2;
X
X    if (s1 == NULL || s2 == NULL) {
X        Error("NULL string passed to Concat");
X    }
X    len1 = strlen(s1);
X    len2 = strlen(s2);
X    s = CreateString(len1 + len2);
X    strcpy(s, s1);
X    strcpy(s + len1, s2);
X    return (s);
X}
X
Xchar IthChar(string s, int i)
X{
X    int len;
X
X    if (s == NULL) Error("NULL string passed to IthChar");
X    len = strlen(s);
X    if (i < 0 || i > len) {
X        Error("Index outside of string range in IthChar");
X    }
X    return (s[i]);
X}
X
Xstring SubString(string s, int p1, int p2)
X{
X    int len;
X    string result;
X
X    if (s == NULL) Error("NULL string passed to SubString");
X    len = strlen(s);
X    if (p1 < 0) p1 = 0;
X    if (p2 >= len) p2 = len - 1;
X    len = p2 - p1 + 1;
X    if (len < 0) len = 0;
X    result = CreateString(len);
X    strncpy(result, s + p1, len);
X    result[len] = '\0';
X    return (result);
X}
X
Xstring CharToString(char ch)
X{
X    string result;
X
X    result = CreateString(1);
X    result[0] = ch;
X    result[1] = '\0';
X    return (result);
X}
X
Xint StringLength(string s)
X{
X    if (s == NULL) Error("NULL string passed to StringLength");
X    return (strlen(s));
X}
X
Xstring CopyString(string s)
X{
X    string newstr;
X
X    if (s == NULL) Error("NULL string passed to CopyString");
X    newstr = CreateString(strlen(s));
X    strcpy(newstr, s);
X    return (newstr);
X}
X
X/* Section 2 -- String comparison functions */
X
Xbool StringEqual(string s1, string s2)
X{
X    if (s1 == NULL || s2 == NULL) {
X        Error("NULL string passed to StringEqual");
X    }
X    return (strcmp(s1, s2) == 0);
X}
X
Xint StringCompare(string s1, string s2)
X{
X    if (s1 == NULL || s2 == NULL) {
X        Error("NULL string passed to StringCompare");
X    }
X    return (strcmp(s1, s2));
X}
X
X/* Section 3 -- Search functions */
X
Xint FindChar(char ch, string text, int start)
X{
X    char *cptr;
X
X    if (text == NULL) Error("NULL string passed to FindChar");
X    if (start < 0) start = 0;
X    if (start > strlen(text)) return (-1);
X    cptr = strchr(text + start, ch);
X    if (cptr == NULL) return (-1);
X    return ((int) (cptr - text));
X}
X
Xint FindString(string str, string text, int start)
X{
X    char *cptr;
X
X    if (str == NULL) Error("NULL pattern string in FindString");
X    if (text == NULL) Error("NULL text string in FindString");
X    if (start < 0) start = 0;
X    if (start > strlen(text)) return (-1);
X    cptr = strstr(text + start, str);
X    if (cptr == NULL) return (-1);
X    return ((int) (cptr - text));
X}
X
X/* Section 4 -- Case-conversion functions */
X
Xstring ConvertToLowerCase(string s)
X{
X    string result;
X    int i;
X
X    if (s == NULL) {
X        Error("NULL string passed to ConvertToLowerCase");
X    }
X    result = CreateString(strlen(s));
X    for (i = 0; s[i] != '\0'; i++) result[i] = tolower(s[i]);
X    result[i] = '\0';
X    return (result);
X}
X
Xstring ConvertToUpperCase(string s)
X{
X    string result;
X    int i;
X
X    if (s == NULL) {
X        Error("NULL string passed to ConvertToUpperCase");
X    }
X    result = CreateString(strlen(s));
X    for (i = 0; s[i] != '\0'; i++) result[i] = toupper(s[i]);
X    result[i] = '\0';
X    return (result);
X}
X
X/* Section 5 -- Functions for converting numbers to strings */
X
Xstring IntegerToString(int n)
X{
X    char buffer[MaxDigits];
X
X    sprintf(buffer, "%d", n);
X    return (CopyString(buffer));
X}
X
Xint StringToInteger(string s)
X{
X    int result;
X    char dummy;
X
X    if (s == NULL) {
X        Error("NULL string passed to StringToInteger");
X    }
X    if (sscanf(s, " %d %c", &result, &dummy) != 1) {
X        Error("StringToInteger called on illegal number %s", s);
X    }
X    return (result);
X}
X
Xstring RealToString(double d)
X{
X    char buffer[MaxDigits];
X
X    sprintf(buffer, "%G", d);
X    return (CopyString(buffer));
X}
X
Xdouble StringToReal(string s)
X{
X    double result;
X    char dummy;
X
X    if (s == NULL) Error("NULL string passed to StringToReal");
X    if (sscanf(s, " %lg %c", &result, &dummy) != 1) {
X        Error("StringToReal called on illegal number %s", s);
X    }
X    return (result);
X}
X
X/* Private functions */
X
X/*
X * Function: CreateString
X * Usage: s = CreateString(len);
X * -----------------------------
X * This function dynamically allocates space for a string of
X * len characters, leaving room for the null character at the
X * end.
X */
X
Xstatic string CreateString(int len)
X{
X    return ((string) GetBlock(len + 1));
X}
END_OF_FILE
if test 5382 -ne `wc -c <'cslib/strlib.c'`; then
    echo shar: \"'cslib/strlib.c'\" unpacked with wrong size!
fi
# end of 'cslib/strlib.c'
fi
if test -f 'cslib/strlib.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/strlib.h'\"
else
echo shar: Extracting \"'cslib/strlib.h'\" \(7407 characters\)
sed "s/^X//" >'cslib/strlib.h' <<'END_OF_FILE'
X/*
X * File: strlib.h
X * Version: 1.0
X * Last modified on Fri Jul 15 14:10:40 1994 by eroberts
X * -----------------------------------------------------
X * The strlib.h file defines the interface for a simple
X * string library.  In the context of this package, strings
X * are considered to be an abstract data type, which means
X * that the client relies only on the operations defined for
X * the type and not on the underlying representation.
X */
X
X/*
X * Cautionary note:
X * ----------------
X * Although this interface provides an extremely convenient
X * abstraction for working with strings, it is not appropriate
X * for all applications.  In this interface, the functions that
X * return string values (such as Concat and SubString) do so
X * by allocating new memory.  Over time, a program that uses
X * this package will consume increasing amounts of memory
X * and eventually exhaust the available supply.  If you are
X * writing a program that runs for a short time and stops,
X * the fact that the package consumes memory is not a problem.
X * If, however, you are writing an application that must run
X * for an extended period of time, using this package requires
X * that you make some provision for freeing any allocated
X * storage.
X */
X
X#ifndef _strlib_h
X#define _strlib_h
X
X#include "genlib.h"
X
X/* Section 1 -- Basic string operations */
X
X/*
X * Function: Concat
X * Usage: s = Concat(s1, s2);
X * --------------------------
X * This function concatenates two strings by joining them end
X * to end.  For example, Concat("ABC", "DE") returns the string
X * "ABCDE".
X */
X
Xstring Concat(string s1, string s2);
X
X/*
X * Function: IthChar
X * Usage: ch = IthChar(s, i);
X * --------------------------
X * This function returns the character at position i in the
X * string s.  It is included in the library to make the type
X * string a true abstract type in the sense that all of the
X * necessary operations can be invoked using functions. Calling
X * IthChar(s, i) is like selecting s[i], except that IthChar
X * checks to see if i is within the range of legal index
X * positions, which extend from 0 to StringLength(s).
X * IthChar(s, StringLength(s)) returns the null character
X * at the end of the string.
X */
X
Xchar IthChar(string s, int i);
X
X/*
X * Function: SubString
X * Usage: t = SubString(s, p1, p2);
X * --------------------------------
X * SubString returns a copy of the substring of s consisting
X * of the characters between index positions p1 and p2,
X * inclusive.  The following special cases apply:
X *
X * 1. If p1 is less than 0, it is assumed to be 0.
X * 2. If p2 is greater than the index of the last string
X *    position, which is StringLength(s) - 1, then p2 is
X *    set equal to StringLength(s) - 1.
X * 3. If p2 < p1, SubString returns the empty string.
X */
X
Xstring SubString(string s, int p1, int p2);
X
X/*
X * Function: CharToString
X * Usage: s = CharToString(ch);
X * ----------------------------
X * This function takes a single character and returns a
X * one-character string consisting of that character.  The
X * CharToString function is useful, for example, if you
X * need to concatenate a string and a character.  Since
X * Concat requires two strings, you must first convert
X * the character into a string.
X */
X
Xstring CharToString(char ch);
X
X/*
X * Function: StringLength
X * Usage: len = StringLength(s);
X * -----------------------------
X * This function returns the length of s.
X */
X
Xint StringLength(string s);
X
X/*
X * Function: CopyString
X * Usage: newstr = CopyString(s);
X * ------------------------------
X * CopyString copies the string s into dynamically allocated
X * storage and returns the new string.  This function is not
X * ordinarily required if this package is used on its own,
X * but is often necessary when you are working with more than
X * one string package.
X */
X
Xstring CopyString(string s);
X
X/* Section 2 -- String comparison functions */
X
X/*
X * Function: StringEqual
X * Usage: if (StringEqual(s1, s2)) ...
X * -----------------------------------
X * This function returns TRUE if the strings s1 and s2 are
X * equal.  For the strings to be considered equal, every
X * character in one string must precisely match the
X * corresponding character in the other.  Uppercase and
X * lowercase characters are considered to be different.
X */
X
Xbool StringEqual(string s1, string s2);
X
X/*
X * Function: StringCompare
X * Usage: if (StringCompare(s1, s2) < 0) ...
X * -----------------------------------------
X * This function returns a number less than 0 if string s1
X * comes before s2 in alphabetical order, 0 if they are equal,
X * and a number greater than 0 if s1 comes after s2.  The
X * ordering is determined by the internal representation used
X * for characters, which is usually ASCII.
X */
X
Xint StringCompare(string s1, string s2);
X
X/* Section 3 -- Search functions */
X
X/*
X * Function: FindChar
X * Usage: p = FindChar(ch, text, start);
X * -------------------------------------
X * Beginning at position start in the string text, this
X * function searches for the character ch and returns the
X * first index at which it appears or -1 if no match is
X * found.
X */
X
Xint FindChar(char ch, string text, int start);
X
X/*
X * Function: FindString
X * Usage: p = FindString(str, text, start);
X * ----------------------------------------
X * Beginning at position start in the string text, this
X * function searches for the string str and returns the
X * first index at which it appears or -1 if no match is
X * found.
X */
X
Xint FindString(string str, string text, int start);
X
X/* Section 4 -- Case-conversion functions */
X
X/*
X * Function: ConvertToLowerCase
X * Usage: s = ConvertToLowerCase(s);
X * ---------------------------------
X * This function returns a new string with all
X * alphabetic characters converted to lower case.
X */
X
Xstring ConvertToLowerCase(string s);
X
X/*
X * Function: ConvertToUpperCase
X * Usage: s = ConvertToUpperCase(s);
X * ---------------------------------
X * This function returns a new string with all
X * alphabetic characters converted to upper case.
X */
X
Xstring ConvertToUpperCase(string s);
X
X/* Section 5 -- Functions for converting numbers to strings */
X
X/*
X * Function: IntegerToString
X * Usage: s = IntegerToString(n);
X * ------------------------------
X * This function converts an integer into the corresponding
X * string of digits.  For example, IntegerToString(123)
X * returns "123" as a string.
X */
X
Xstring IntegerToString(int n);
X
X/*
X * Function: StringToInteger
X * Usage: n = StringToInteger(s);
X * ------------------------------
X * This function converts a string of digits into an integer.
X * If the string is not a legal integer or contains extraneous
X * characters, StringToInteger signals an error condition.
X */
X
Xint StringToInteger(string s);
X
X/*
X * Function: RealToString
X * Usage: s = RealToString(d);
X * ---------------------------
X * This function converts a floating-point number into the
X * corresponding string form.  For example, calling
X * RealToString(23.45) returns "23.45".  The conversion is
X * the same as that used for "%G" format in printf.
X */
X
Xstring RealToString(double d);
X
X/*
X * Function: StringToReal
X * Usage: d = StringToReal(s);
X * ---------------------------
X * This function converts a string representing a real number
X * into its corresponding value.  If the string is not a
X * legal floating-point number