Homework & Coursework Questions

letters.h
#include <stdio.h>
int is_vowel(char c);
int is_h_consonant(char c);
#define TRUE  1
#define FALSE 0
#define FLUSH while(getchar()!='\n')
int convert_up_low(char c);

included w/ letters.c
included #include <stdio.h>
#include "letters.h"
int is_vowel(char c)
{
         /* this function is given a letter and return its value. */

        /*if the letter inputs are true */
      /*if (c=='A' ||c=='a'|| c=='E'||c=='e'|| c=='I'
            ||c=='i'|| c=='O'||c=='o'|| c=='U'||c=='u')
                { c= convert_up_low (char c);
                }*/


        /* if the letter is a vowel (lower or Upper case)*/

        if (c=='A' ||c=='a'|| c=='E'||c=='e'||
            c=='I'||c=='i'|| c=='O'||c=='o'||
            c=='U'||c=='u')
        {
         /* return the vowel upper or lower case*/
        return TRUE;
        }
        else
        {
        /* return false */
        return FALSE;
        }
}
int is_h_consonant(char c)
{
        /* if the letter is a consonant (lower or Upper case)*/
        if(c=='H'||c=='h'||c=='K'||c=='k'||
           c=='L'||c=='l'||c=='M'||c=='m'||
           c=='N'||c=='n'||c=='P'||c=='p'||
           c=='W'||c=='w'||c=='`')
        {
        /* return the consonant upper or lower case*/
        return TRUE;
        }

        else
        {
        /* return False */
        return FALSE;
        }
}

also chrutil.h
#define   ERROR     -2

#define   IS_DIGIT(c)   ((c) >= '0' && (c) <= '9')
#define   IS_LOWER(c)   ((c) >= 'a' && (c) <= 'z')
#define   IS_UPPER(c)   ((c) >= 'A' && (c) <= 'Z')
#define   IS_WHITE_SPACE(c)   ((c) == ' ' || (c) == '\t' || (c) == '\n')
#define   IS_PRINT(c)   ((c) >= 32 && (c) < 127)

#define  LOWER     0
#define  UPPER     1
#define  DIGIT     2
#define  PUNCT     3
#define  SPACE     4
#define  CONTROL   5
#define  SPECIAL   6


int dig_to_int(char ch);
char int_to_dig(int n);
char uppercase(char ch);
int getint();

int delimitp(char c);
int whitep(char c);
int punctp(char c);
int vowelp(char c);
int letterp(char c);
int illegal(char c);      /* Tests if c is legal. */

that includes chrutil.c

#include <stdio.h> 
#include "tfdef.h"
#include "chrutil.h"

/*   Function converts ch to an integer if it is a digit. Otherwise, it
 *        prints an error message.
 *        */
int dig_to_int(char ch)
{
     if (IS_DIGIT(ch))
          return ch - '0';
     printf("ERROR:dig_to_int:  %c is not a digit\n", ch);
     return ERROR;
}

/*   Function converts a positive integer less than 10 to a corresponding
 *        digit character.
 *        */
char int_to_dig(int n)
   {
     if (n >= 0 && n < 10)
          return n + '0';
     printf("ERROR:int_to_dig:  %d is not in the range 0 to 9\n", n);
    return  NULL;
   }


/*  Function reads the next integer from the input  */
int getint()
{    int n = 0;
     int got_dig = FALSE;
     signed char ch;


     ch = getchar();                     /* read next char                  */
     while (IS_WHITE_SPACE(ch))          /* skip white space                */
              ch = getchar();
     while (IS_DIGIT(ch)) {              /* repeat as long as ch is a digit */
          n = n * 10 + dig_to_int(ch);   /* accumulate value in n           */
          got_dig = TRUE;
#ifdef DEBUG
printf("debug:getint: ch = %c\n", ch);   /* debug statement */
printf("debug:getint: n = %d\n", n);     /* debug statement */
#endif
          ch = getchar();                /* read next char                  */
     }
     if(ch == EOF) return EOF;           /* test for end of file            */
     if(!got_dig)  return ERROR;         /* test for no digits read         */
     return n;                           /* otherwise return the result     */

}

/* Function tests if c is an alphabetic letter. */
int letterp(char c)
{
     if (IS_LOWER(c) || IS_UPPER(c))
          return TRUE;
     return FALSE;
}


/*   Function returns TRUE if c is a delimiter, i.e., it is a white space
 *        or a punctuation. Otherwise, it returns FALSE.
 *        */
int delimitp(char c)
{
     if (whitep(c) || punctp(c))
          return TRUE;
     return FALSE;
}

/* Function returns TRUE if c is white space; returns FALSE otherwise. */
int whitep(char c)
{
     if (c == '\n' || c == '\t' || c == ' ')
          return TRUE;
     return FALSE;
}

/* Function returns TRUE if c is a punctuation; returns FALSE otherwise. */
int punctp(char c)
{
     if (c == '.' || c == ',' || c == ';' || c == ':'
               || c == '?' || c == '!')
          return TRUE;
     return FALSE;
}


/*   Function checks if c is a vowel. */
int vowelp(char c)
{
     switch(c) {
          case 'a':
          case 'A':
          case 'e':
          case 'E':
          case 'i':
          case 'I':
          case 'o':
          case 'O':
          case 'u':
          case 'U':  return TRUE;
          default:   return FALSE;
     }
}


/* Function tests if c is printable. */
int illegal(char c)
{
   if (IS_PRINT(c) || IS_WHITE_SPACE(c))
     return FALSE;
   return TRUE;
}

3. The attempts at a solution (include all code and scripts):
here's the attempt though i don't know what to do add on 
spchk.c

 /* File Name: spchk.c
 * By: Matthew Yee
 * Login: mgy
 * Date:03/18/2011
 */
#include "chrutil.h"

#include "letters.h"
main()
{    signed char c;
     int inword,         /* flag indicating when in a word    */
     lns, wds, chrs;     /* Counters for lines, words, chars. */

    /* #ifdef INTERACT
     printf("***Line, Word, Character Count Program***\n\n");
     printf("Type characters, EOF to quit\n");
     #endif*/
     lns = wds = chrs = 0;    /* initialize counters to 0               */
     inword = FALSE;          /* before beginning we are not in a word  */

   while ((c = getchar()) != EOF)     /* while there are more characters */
     {    chrs = chrs + 1;               /* count characters     */
          if (c == '\n')                /* if newline char      */
        lns = lns + 1;            /* count lines          */

          /* if not in a word and not a delimiter  */
          /* then this must be the beginning of a word  */
          if (!inword && !delimitp(c))     /* if not in word and not delim. */
          {    inword = TRUE;               /* remember we are in a word     */
       wds = wds + 1;               /* count words                   */
          }

          /*  otherwise if in a word, but found a delimiter  */
          /*  then we just went beyond the end of the word  */
          else if (inword && delimitp(c))    /* if in word and a delimiter*/
          {    inword = FALSE;                /* we are no longer in a word*/


              getchar();



              putchar('\n');                 /* end word with a newline   */




          }
        while(inword)
          {if (inword)                    /*  if in a word         */
              { putchar(c);              /*  print the character  */
                  if (IS_UPPER(c)==TRUE)
                  {printf( "%c starts with a capital", c);
                   return c;
                  }


             c = getchar();
              }
          }
}
   /*  print the results  */
     printf("Lines = %d, Words = %d, Characters = %d\n",
               lns, wds, chrs);
}

int c;
int iscorrect = 1;
int inword  = 0;
int lastvowel = 0; // if it is 1, the previously read char was a vowel
while((c = getchar()) != EOF) {
        if(delimitp((char) c)) {
                if(inword) { // end of word reached
                        (iscorrect == 1 && lastvowel == 1) ? printf(" correct word\n"); : printf(" wrong word\n"); // word had to be correct and the char in front of the delimit had to be vowel
                        inword = 0;
                        iscorrect = 1; //reset
                } else // two or more delimiters, ignore them
                        continue;
        }
        if(!letterp((char) c)) { //word is def wrong
                inword = 1;
                iscorrect = 0;
                putchar(c);
                continue;
        }
        if(!inword) { //first char of word, so we don't check adjacent consonsants here
                inword = 1;
                iscorrect = 1; //we accecpt consonants and vowels here. all other got kicked of in the if before - prob obsolute because we reset it at the delimiters
                if(vowelp((char) c))
                        lastvowel = 1;
                else
                        lastvowel = 0;
                putchat(c);
        } else {
                if(!vowelp((char) c) && lastvowel = 0) //adjacent consonants
                        iscorrect = 0;
                putchar(c);
        }
}