home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / CSAPE32.ARJ / SOURCE / FUNCS / FNVALSTR.C < prev    next >
C/C++ Source or Header  |  1990-03-28  |  3KB  |  139 lines
  1. /*
  2.       fnvalstr.c        9/17/88
  3.  
  4.     % valid_String
  5.  
  6.     String validation functions
  7.  
  8.     C-scape 3.2
  9.     Copyright (c) 1986, 1987, 1988 by Oakland Group, Inc.
  10.     ALL RIGHTS RESERVED.
  11.  
  12.     Revision History:
  13.     -----------------
  14.     11/18/88 jmd    Added command code prefixes
  15.     11/04/89 jdc    changed toupper & tolower to otoupper & otolower
  16.      3/28/90 jmd    ansi-fied
  17. */
  18.  
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <ctype.h>
  22.  
  23. #include "cscape.h"
  24.  
  25. #define    DELIMITER    ','
  26.  
  27. boolean valid_String(char *string, char *vstr)
  28. /*
  29.     Returns whether the string is within the list of choices
  30.     specified by vstr.
  31.     vstr is composed of strings separated by ','s.
  32.     For example:
  33.     valid_String("Joe", "Joe,John,Ted");
  34.     would return TRUE.
  35.     Return TRUE if vstr == NULL or if vstr == "";
  36.     vstr can have an optional command code prefix:
  37.     (the command code must be the first item in the string)
  38.     valid_String("Joe", "{i}Joe,John,Ted");
  39.     i        ignore case
  40.     s        strip spaces before compare
  41.     digit    use only the first n characters for the comparison. (0-9 only)
  42. */
  43. {
  44.     char *p, *q, *s1, *s2, hold;
  45.     boolean    igcase = FALSE;
  46.     boolean    strip = FALSE;
  47.     boolean    digit = FALSE;
  48.     boolean    equal;
  49.     int      count, clen = 0;
  50.  
  51.     if (vstr == NULL || vstr[0] == '\0') {
  52.         return(TRUE);
  53.     }
  54.  
  55.     /* process command code prefix */
  56.     p = vstr;
  57.     if (*p == '{') {
  58.         for(;*p != '}' && *p != '\0';p++) {
  59.             switch(*p) {
  60.             case 'i':
  61.                 /* Ignore case */
  62.                 igcase = TRUE;
  63.                 break;
  64.             case 's':
  65.                 /* Strip spaces */
  66.                 strip = TRUE;
  67.                 break;
  68.             default:
  69.                 /* Set compare length */
  70.                 if (*p >= '0' && *p <= '9') {
  71.                     clen = *p - '0';
  72.                     digit = TRUE;
  73.                 }
  74.                 break;
  75.             }
  76.         }
  77.  
  78.         if (*p == '\0' || *(p+1) == '\0') {
  79.             return(TRUE);
  80.         }
  81.         else {
  82.             /* skip past '{' */
  83.             p++;
  84.         }
  85.     }
  86.  
  87.     q = p;
  88.     for(;;p++) {
  89.         if (*p == DELIMITER || *p == '\0') {
  90.  
  91.             /* compare the two strings */
  92.             equal = TRUE;
  93.             count = 0;
  94.             for (s1 = string, s2 = q; (!digit || count < clen); s1++, s2++) {
  95.  
  96.                 if (strip) {
  97.                     /* skip spaces */
  98.                     while(*s1 == ' ') {
  99.                         s1++;
  100.                     }
  101.                     while(*s2 == ' ') {
  102.                         s2++;
  103.                     }
  104.                 }
  105.  
  106.                 /* Convert DELIMITER to '\0' */
  107.                 hold = (*s2 == DELIMITER) ? (char) '\0' : *s2;
  108.  
  109.                 if ( ((igcase) ? otoupper(*s1) : *s1) !=
  110.                      ((igcase) ? otoupper(hold) : hold)) {
  111.                     equal = FALSE;
  112.                     break;
  113.                 }
  114.                 if (digit) {
  115.                     /* Increment count if we're counting characters */
  116.                     count++;
  117.                 }
  118.  
  119.                 if (*s1 == '\0' || *s2 == '\0' || *s2 == DELIMITER) {
  120.                     break;
  121.                 }
  122.             }
  123.             if (equal) {
  124.                 return(TRUE);
  125.             }
  126.             if (*p == '\0') {
  127.                     break;
  128.             }
  129.             else {
  130.                 q = p + 1;
  131.             }
  132.         }
  133.     }
  134.  
  135.     return(FALSE);
  136. }
  137.  
  138.  
  139.