#ifndef lint #ifdef sccs static char sccsid[] = "@(#)str_utils.c 20.15 93/06/28"; #endif #endif /* * (c) Copyright 1989 Sun Microsystems, Inc. Sun design patents * pending in the U.S. and foreign countries. See LEGAL NOTICE * file for terms of the license. */ #include #include #include /* * xv_substring extracts a specified substring out of another string. It is a * generalization of strncpy. xv_substring copies n characters from s to dest, * starting at position start. if start is negative, start = strlen(s) - * start. for example, xv_substring(s, -3, 3, dest) will store into dest the * last three characters of s. returns True if successful, False if error, * e.g. n < 0, there weren't n charcters in s, etc. in case of failure, dest * will contain an empty string. */ Bool xv_substring(s, start, n, dest) char *s; int start, n; char *dest; { int slen; int i; if (s == NULL) return (False); slen = strlen(s); if (start < 0) start = (slen - start); /* negative numbers mean count from back */ if ((start < 0) || (n < 0)) goto fail; for (i = 0; i < n; i++) if (s[start + i] == '\0') goto fail; else dest[i] = s[start + i]; dest[i] = '\0'; return (True); fail:dest[0] = '\0'; return (False); } /* * xv_substrequal compares two substrings without having to construct them. If * case_matters = False, 'a' will match with 'a' or 'A'. */ Bool xv_substrequal(s1, start1, s2, start2, n, case_matters) char *s1, *s2; int start1, start2; Bool case_matters; { int i; if ((s1 == NULL) || (s2 == NULL)) return ((n == 0 && s2 == s2) ? True : False); for (i = 0; i < n; i++) { char c1, c2; c1 = s1[start1 + i]; c2 = s2[start2 + i]; if (c1 == c2) { } else if (case_matters) return (False); else if (isupper(c1)) { if (islower(c2)) { if ((c1 - 'A') != (c2 - 'a')) return (False); } else return (False); } else if (islower(c1)) { if (isupper(c2)) { if ((c1 - 'a') != (c2 - 'A')) return (False); } else return False; } else return False; } return (True); } /* * strequal compares two strings It uses xv_substrequal. If case_matters = * False, 'a' will match with 'a' or 'A'. either s1 or s2 can be NULL without * harm. */ Bool string_equal(s1, s2, case_matters) char *s1, *s2; Bool case_matters; { int i; if (s1 == s2) return (True); else if ((s1 == NULL) || (s2 == NULL)) return (False); for (i = 0;; i++) { char c1, c2; c1 = s1[i]; c2 = s2[i]; if (c1 == c2) { if (s1[i] == '\0') return (True); } else if (case_matters) return (False); else if (isupper(c1)) { if (islower(c2)) { if ((c1 - 'A') != (c2 - 'a')) return (False); } else return (False); } else if (islower(c1)) { if (isupper(c2)) { if ((c1 - 'a') != (c2 - 'A')) return (False); } else return (False); } else return (False); } } /* * string_find searches one instance of a string for another. If successful, * returns the position in the string where the match began, otherwise -1. If * case_matters = False, 'a' will match with 'a' or 'A'. */ int string_find(s, target, case_matters) char *s, *target; Bool case_matters; { int i, n; if (s == NULL) return (-1); else if (target == NULL) return (0); n = strlen(target); for (i = 0;; i++) if (s[i] == '\0') return (-1); else if (xv_substrequal(s, i, target, 0, n, case_matters)) return (i); } /* * string_get_token is used for tokenizing input, where more degree of * flexibility is required than simply delimiting tokens by white spaces * characters are divided into three classes, Break, Sepr, and Other. * separators (Sepr) serve to delimit a token. Leading separators are * skipped. think of separators as white space. Break characters delimit * tokens, and are themselves tokens. Thus, if a break character is the first * thing seen it is returned as the token. If any non-separator characters * have been seen, then they are returned as the token, and the break * character will be the returned as the result of the next call to * get_token. for example, if charproc returns Sepr for space, and Break for * '(' and ')' and Other for all alphabetic characters, then the string "now * (is) the" will yield five tokens consisting of "now" "(" "is" ")" and * "the" * * get_token stores the token that it constructs into dest, which is also * returned as its value. index marks the current position in the string to * "begin reading from" it is updated so that the client program does not * have to keep track of how many characters have been read. * * get_token returns NULL, rather than the empty string, corresponding to the * case where the token is empty */ char * string_get_token(s, index, dest, charproc) char *s; int *index; char *dest; enum CharClass (*charproc) (); { char c; int i = 0; for (;;) { c = s[(*index)++]; if (c == '\0') goto backup; switch ((*charproc) (c)) { case Sepr: if (i != 0) /* something seen */ goto backup; else continue; case Break: if (i == 0) { /* * nothing seen yet, this character is the token */ dest[i++] = c; goto exit; } else goto backup; case Other: dest[i++] = c; } } backup: (*index)--; exit: dest[i] = '\0'; return (i == 0 ? NULL : dest); } /* * string_get_sequence is a more primitive tokenizer than get_token. it takes * a procedure which for each character specifies whether the character is to * terminate the sequence, and whether or not the character is to be included * in the sequence. (If the character terminates the sequence, but is not * included, then it will be seen again on the next call.) For example, * having seen a \"\, to read to the matching \"\, call get_sequence with an * action procedure that returns {True, True} for \"\ and {False, True} for * everything else. (If you want to detect the case where a " is preceded by * a \\, simply save the last character and modify the procedure accordingly. * * Note that gettoken can be defined in terms of get_sequence by having Other * characters return {False, True}, and also noticing whether any have been * seen yet, having Seprs return {(seen_some_others ? True : False), False} * and Break characters return {True, (seen_some_others ? False : True)} * * returns NULL for the empty sequence */ char * string_get_sequence(s, index, dest, charproc) char *s; int *index; char *dest; struct CharAction (*charproc) (); { char c; struct CharAction action; int i = 0; for (;;) { c = s[(*index)++]; if (c == '\0') goto backup; action = (*charproc) (c); if (action.include) dest[i++] = c; if (action.stop) { if (!action.include) goto backup; /* if c was not included, then need to back * up */ else goto exit; } } backup: (*index)--; exit: dest[i] = '\0'; return (i == 0 ? NULL : dest); }