/*       CHAP_3_CHARCLASS.C                                     */

/* This example uses the isalpha, isdigit, and isspace          */
/* functions to count the number of occurrences of letters,     */
/* digits, and white-space characters entered through the       */
/* standard input (stdin).                                      */

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>

main()
{
    char c;
    int i = 0,
        j = 0,
        k = 0;

    while ((c = getchar()) != EOF) {
        if (isalpha(c))
            i++;
        if (isdigit(c))
            j++;
        if (isspace(c))
            k++;
    }

    printf("Number of letters: %d\n", i);
    printf("Number of digits:  %d\n", j);
    printf("Number of spaces:  %d\n", k);
}

$ RUN  EXAMPLE1
I saw 35 people riding bicycles on Main Street.[Return]
[Ctrl/Z]
Number of letters: 36
Number of digits:  2
Number of spaces:  8
$

ecvt         _tolower
fcvt         toupper
gcvt         _toupper
mbtowc       towctrans
mbrtowc      wctrans
mbsrtowcs    wcrtomb
toascii      wcsrtombs
tolower

/*     CHAP_3_CHARCONV.C                                        */

/* This program uses the ecvt function to convert a double      */
/* value to a string. The program then prints the string.       */

#include <stdio.h>
#include <stdlib.h>
#include <unixlib.h>
#include <string.h>

main()
{

    double val;         /* Value to be converted */

    int sign,           /* Variables for sign   */
        point;          /* and decimal place    */

    /*  Array for the converted string  */
    static char string[20];

    val = -3.1297830e-10;

    printf("original value: %e\n", val);
    if (sign)
        printf("value is negative\n");
    else
        printf("value is positive\n");
    printf("decimal point at %d\n", point);
}

$ RUN  EXAMPLE2
original value: -3.129783e-10
converted string: 31298
value is negative
decimal point at -9
$

/*     CHAP_3_CONV_UPPERLOWER.C                                 */

/* This program uses the functions toupper and tolower to       */
/* convert uppercase to lowercase and lowercase to uppercase    */
/* using input from the standard input (stdin).                 */

#include <ctype.h>
#include <stdio.h>      /*  To use EOF identifier */
#include <stdlib.h>

main()
{
    char c,
         ch;

    while ((c = getchar()) != EOF) {
        if (c >= 'A' && c <= 'Z')
            ch = tolower(c);
        else
            ch = toupper(c);
        putchar(ch);
    }
}

$ RUN  EXAMPLE3
LET'S GO TO THE welcome INN.[Ctrl/Z]
let's go to the WELCOME inn.
$

/*        CHAP_3_CONCAT.C                                      */

/*  This example uses strcat and strncat to concatenate two    */
/*  strings.                                                   */

#include <stdio.h>
#include <string.h>

main()
{
    static char string1[80] = "Concatenates ";
    static char string2[] = "two strings ";
    static char string3[] = "up to a maximum of characters.";
    static char string4[] = "imum number of characters";

    printf("strcat:\t%s\n", strcat(string1, string2));
    printf("strncat ( 0):\t%s\n", strncat(string1, string3, 0));
    printf("strncat (11):\t%s\n", strncat(string1, string3, 11));
    printf("strncat (40):\t%s\n", strncat(string1, string4, 40));
}

$ RUN  EXAMPLE1
strcat: Concatenates two strings
strncat ( 0): Concatenates two strings
strncat (11): Concatenates two strings up to a max
strncat (40): Concatenates two strings up to a maximum number of characters.
$

/*        CHAP_3_STRCSPN.C                                     */

/*  This example shows how strcspn interprets four             */
/*  different kinds of arguments.                              */

#include <stdio.h>

main()
{

    printf("strcspn with null charset: %d\n",
            strcspn("abcdef", ""));

    printf("strcspn with null string: %d\n",
            strcspn("", "abcdef"));

    printf("strcspn(\"xabc\", \"abc\"): %d\n",
           strcspn("xabc", "abc"));

    printf("strcspn(\"abc\", \"def\"): %d\n",
            strcspn("abc", "def"));
}

$ RUN  EXAMPLE2 

strcspn with null charset:  6
strcspn with null string:  0
strcspn("xabc","abc"):  1
strcspn("abc","def"):  3

/*        CHAP_3_STDARG.C                                       */

/* This routine accepts a variable number of string arguments,  */
/* preceded by a count of the number of such strings. It        */
/* allocates enough space in which to concatenate all of the    */
/* strings, concatenates them together, and returns the address */
/* of the new string. It returns NULL if there are no string    */
/* arguments, or if they are all null strings.                  */

#include <stdarg.h>       /* Include appropriate header files   */
#include <stdlib.h>       /* for the "example" call in main.    */
#include <string.h>
#include <stdio.h>

/* NSTRINGS is the maximum number of string arguments accepted  */
/* (arbitrary).                                                 */

#define NSTRINGS 10

char *concatenate(int n,...)
{
    va_list ap;         /* Declare the argument pointer. */

    char *list[NSTRINGS],
        *string;
    int index = 0,
        size = 0;

    /* Check that the number of arguments is within range.   */

    if (n <= 0)
        return NULL;
    if (n > NSTRINGS)
        n = NSTRINGS;

    va_start(ap, n);    /* Initialize the argument pointer.  */

    do {
        /* Extract the next argument and save it. */

        list[index] = va_arg(ap, char *);

        size += strlen(list[index]);
    } while (++index < n);

    va_end(ap); /* Terminate use of ap. */

    if (size == 0)
        return NULL;

    string = malloc(size + 1);
    string[0] = '\0';

    /* Append each argument to the end of the growing result    */
    /*  string.                                                 */

    for (index = 0; index < n; ++index)
        strcat(string, list[index]);

    return string;
}

/* An example of calling this routine is */

main() {
    char *ret_string ;

    ret_string = concatenate(7, "This ", "message ", "is ",
                                "built with ", "a", " variable arg",
                                " list.") ;

    puts(ret_string) ;
}

This message is built with a variable arg list.