#include <stdio.h> // for getchar(), putchar(), printf(), EOF
#include <string.h> // for strcmp()
#include <ctype.h> // for isspace(), isalpha(), isalnum()
#define MAXWORD 100
// #define NKEYS (sizeof (keytab) / sizeof(struct key))
#define NKEYS (sizeof (keytab) / sizeof(keytab[0]))
struct key
{
char *word;
int count;
} keytab[] =
{{"auto", 0}, {"break", 0}, {"case", 0}, {"char", 0}, {"const", 0}, {"continue", 0},
{"default", 0}, {"define", 0}, {"do", 0}, {"double", 0}, {"else", 0}, {"enum", 0},
{"extern", 0}, {"float", 0}, {"for", 0}, {"goto", 0}, {"if", 0}, {"include", 0},
{"int", 0}, {"long", 0}, {"register", 0}, {"return", 0}, {"short", 0}, {"signed", 0},
{"sizeof", 0}, {"static", 0}, {"struct", 0}, {"switch", 0}, {"typedef", 0},
{"union", 0}, {"unsigned", 0}, {"void", 0}, {"volatile", 0}, {"while", 0}};
int getword(char *, int);
int binsearch(char *, struct key *, int);
// count C keywords
int main()
{
int c, n;
char word[MAXWORD];
while((c = getword(word, MAXWORD)) != EOF)
{
if (isalpha(c) || c == '_')
{
if ((n = binsearch(word, keytab, NKEYS)) >= 0)
{keytab[n].count++;}
}
}
for (n = 0, c = 0; n < NKEYS; n++)
{
if (keytab[n].count > 0)
{
c++;
printf("(%d, %s), ", keytab[n].count, keytab[n].word);
if (c % 5 == 0) {putchar('\n');}
}
}
if (c % 5 != 0) {putchar('\n');}
return 0;
}
// find word in tab[0] ... tab[n-1]
int binsearch(char *word, struct key tab[], int n)
{
int cond;
int low, high, mid;
low = 0;
high = n-1;
while (low <= high)
{
mid = (low + high) / 2;
if ((cond = strcmp(word, tab[mid].word)) < 0)
{high = mid - 1;}
else if (cond > 0)
{low = mid + 1;}
else {return mid;} // found it
}
return -1; // not found
}
int getch(void);
void ungetch(int);
// get next word or character from input
int getword(char *word, int lim)
{
int c;
char *w = word;
while (isspace(c = getch()))
{} // skip beginning whitespace
if (c != EOF)
{*w++ = c;}
if (!isalpha(c) && c != '_')
{
*w = '\0';
return c;
}
for ( ; --lim > 0; w++)
{
if (!isalnum(*w = getch()) && *w != '_')
{
ungetch(*w);
break; // out of for(), w++ is not executed
}
}
*w = '\0';
return word[0];
}
// buffer for ungetch():
int buf = EOF-1; // not a real character, not even EOF
int getch(void) // get a (possibly pushed-back) character
{
if (buf < EOF)
{
return getchar();
}
int temp = buf; // buf >= EOF
buf = EOF-1; // reset buf
return temp;
}
// push character back on input (make it available for the next getch()):
void ungetch(int c)
{
buf = c;
}
/*
gcc words.c -o words
./words < words.c
(2, auto), (3, break), (2, case), (9, char), (2, const),
(2, continue), (2, default), (5, define), (2, do), (2, double),
(4, else), (2, enum), (2, extern), (2, float), (9, for),
(2, goto), (13, if), (5, include), (22, int), (2, long),
(2, register), (9, return), (2, short), (2, signed), (6, sizeof),
(2, static), (6, struct), (2, switch), (2, typedef), (2, union),
(2, unsigned), (6, void), (2, volatile), (5, while),
*/
*****************************************************************************************
*****************************************************************************************
*****************************************************************************************
*****************************************************************************************
*****************************************************************************************
Exercise 6-1. Our version of getword() does not properly handle underscores, string constants, comments, or preprocessor control lines. Write a better version.
Then we can use the words program above to count the C keywords in the generated file(s).
#include <stdio.h> // for getchar(), putchar(), printf(), EOF
// test multiline preprocessor command:
#define FALSE \
0
#define TRUE 1
// testing a \
multiline \
C++ style \
comment
int main()
{
int c1, c2;
int insideComment = FALSE; // for C style comments
while ((c1 = getchar()) != EOF)
{
if (c1 == '\\') // escape character or sequence
{ /* skip \', \", \\ */ // \ continues a C++ style comment on the next line
c2 = getchar();
if (c2 == EOF)
{ // \ newline is part of a multiline preprocessor command or C++ comment
printf("\nEscape character not ended properly\n"); // Error message
return 1; // return from main(), end program with an error message
}
if (c2 == '\n') // not an escape, but a multiline command or comment
{
putchar(c1); // '\\'
putchar(c2); // '\n'
}
// else remove escape (print nothing)
}
else if (c1 == '\'') // character literal
{ // skip '\\', '"', '\"', '*', '#'
// remove character literal (print nothing)
while ((c1 = getchar()) != '\'')
{
if (c1 == EOF || c1 == '\n')
{
printf("\nCharacter literal not ended properly\n"); // Error message
return 1; // end program with an error message
}
// else
if (c1 == '\\') // escape char or sequence
{
// print nothing
c1 = getchar();
if (c1 == EOF)
{ // \ newline is part of a multiline preprocessor command or C++ comment
printf("\nEscape character not ended properly\n"); // Error message
return 1; // end program with an error message
}
// else skip char
}
// else skip char
} // here c1 == '\''
}
else if (c1 == '\"') // strings are on a single line
{ // Skip strings: "/*", "*/", "//", "'", "\"", "\'", "\\", "#"
// skip char (print nothing)
while ((c1 = getchar()) != '\"')
{
if (c1 == EOF || c1 == '\n')
{
printf("\nQuoted string not ended properly\n"); // Error message
return 1; // end program with an error message
}
else if (c1 == '\\') // escape char or sequence
{
// skip char (print nothing)
c1 = getchar();
if (c1 == EOF || c1 == '\n')
{
printf("\nEscape character not ended properly\n"); // Error message
return 1; // end program with an error message
}
// else skip char
}
// else skip char
} // here c1 == '\"'
} // continue with getchar() in outer while() to skip last '\"'
else if (c1 == '/')
{
c2 = /* testing */ getchar();
if (c2 == '/') // beginning of a C++ style comment
{
while ((c2 = getchar()) != EOF)
{ // \ continues a C++ style comment on the next line
if (c1 != '\\' && c2 == '\n')
{break;} // out of inner while()
c1 = c2; // c1 holds the penultimate char read
} // here c2 == '\n' or EOF, end of C++ style comment
if (c2 == EOF)
{return 0;} // end program normally, exit main()
putchar(c2); // putchar('\n'); // C++ style comment ends with '\n'
}
else if (c2 == '*') // beginning of a C style comment
{
insideComment = TRUE;
while (insideComment) // insideComment == 1 (insideComment != 0)
{
while ((c1 = getchar()) != '*')
{
if (c1 == EOF)
{
printf("\nC style comment not closed properly\n"); // Error message
return 1; // end program with an error message
}
// else skip chars till '*'
}
c2 = getchar();
if (c2 == EOF)
{
printf("\nC style comment not closed properly\n"); // Error message
return 1; // end program with an error message
}
else if (c2 == '/') // end of C style comment
{
insideComment = FALSE; // reset
break; // out of while(insideComment)
}
// else continue; // C style comment continues
} // end of while (insideComment)
}
else // no comment, false alarm
{
putchar(c1);
if (c2 != EOF) {putchar(c2);}
else {return 0;} // end program normally, exit main()
}
}
/*
else if (c1 == '#') // skip preprocessor control lines
{
while ((c2 = getchar()) != EOF)
{ // \ continues a preprocessor command on the next line
if (c1 != '\\' && c2 == '\n')
{break;} // out of inner while()
c1 = c2; // c1 holds the penultimate char read
} // here c2 == '\n' or EOF, end of preprocessor command
if (c2 == EOF)
{return 0;} // end program normally
// else skip line (don't print newline)
}
*/
else {putchar(c1);} // no comment
} // end of outer while()
return 0;
}
/*
gcc nocomment.c -o nocomment
./nocomment < nocomment.c > copy.c
// We cannot compile copy.c, it misses (preprocessor commands,)
// character and string literals
gcc words.c -o words
./words < copy.c
(2, break), (2, define), (9, else), (20, if), (1, include),
(3, int), (10, return), (6, while),
./nocomment < words.c > copy.c
./words < copy.c
(1, break), (7, char), (2, define), (2, else), (2, for),
(11, if), (3, include), (20, int), (7, return), (2, sizeof),
(3, struct), (4, void), (3, while),
rm copy.c // clean
*/
*****************************************************************************************
*****************************************************************************************
*****************************************************************************************
*****************************************************************************************
*****************************************************************************************
#include <stdio.h> // for getchar(), putchar(), printf(), EOF, NULL
#include <string.h> // for strcmp()
#include <ctype.h> // for isspace(), isalpha(), isalnum()
#define MAXWORD 100
// #define NKEYS (sizeof (keytab) / sizeof(struct key))
#define NKEYS (sizeof (keytab) / sizeof(keytab[0]))
struct key
{
char *word;
int count;
} keytab[] =
{{"auto", 0}, {"break", 0}, {"case", 0}, {"char", 0}, {"const", 0}, {"continue", 0},
{"default", 0}, {"define", 0}, {"do", 0}, {"double", 0}, {"else", 0}, {"enum", 0},
{"extern", 0}, {"float", 0}, {"for", 0}, {"goto", 0}, {"if", 0}, {"include", 0},
{"int", 0}, {"long", 0}, {"register", 0}, {"return", 0}, {"short", 0}, {"signed", 0},
{"sizeof", 0}, {"static", 0}, {"struct", 0}, {"switch", 0}, {"typedef", 0},
{"union", 0}, {"unsigned", 0}, {"void", 0}, {"volatile", 0}, {"while", 0}};
int getword(char *, int);
struct key * // function binsearch() returns pointer to struct key
binsearch(char *, struct key *, int);
// count C keywords, pointer version
int main()
{
int c;
char word[MAXWORD];
struct key *p;
while((c = getword(word, MAXWORD)) != EOF)
{
if (isalpha(c) || c == '_')
{
if ((p = binsearch(word, keytab, NKEYS)) != NULL)
{p->count++;}
}
}
for (p = keytab, c = 0; p < keytab + NKEYS; p++)
{
if (p->count > 0)
{
c++;
printf("(%d, %s), ", p->count, p->word);
if (c % 5 == 0) {putchar('\n');}
}
}
if (c % 5 != 0) {putchar('\n');}
return 0;
}
struct key * // function binsearch() returns pointer to struct key
binsearch(char *word, struct key *tab, int n)
{// find word in tab[0] ... tab[n-1]
int cond;
struct key *low, *high, *mid;
low = tab; // &tab[0]
high = tab+n-1; // &tab[n-1]
while (low <= high)
{
mid = low + (high - low) / 2; // pointer arithmetic
if ((cond = strcmp(word, mid->word)) < 0)
{high = mid-1;}
else if (cond > 0)
{low = mid + 1;}
else {return mid;} // found it
}
return NULL; // not found
}
int getch(void);
void ungetch(int);
// get next word or character from input
int getword(char *word, int lim)
{
int c;
char *w = word;
while (isspace(c = getch()))
{} // skip beginning whitespace
if (c != EOF)
{*w++ = c;}
if (!isalpha(c) && c != '_')
{
*w = '\0';
return c;
}
for ( ; --lim > 0; w++)
{
if (!isalnum(*w = getch()) && *w != '_')
{
ungetch(*w);
break; // out of for(), w++ is not executed
}
}
*w = '\0';
return word[0];
}
// buffer for ungetch():
int buf = EOF-1; // not a real character, not even EOF
int getch(void) // get a (possibly pushed-back) character
{
if (buf < EOF)
{
return getchar();
}
int temp = buf; // buf >= EOF
buf = EOF-1; // reset buf
return temp;
}
// push character back on input (make it available for the next getch()):
void ungetch(int c)
{
buf = c;
}
/*
gcc wordp.c -o wordp
./wordp < wordp.c
(2, auto), (5, break), (2, case), (10, char), (2, const),
(2, continue), (2, default), (7, define), (2, do), (2, double),
(6, else), (2, enum), (2, extern), (2, float), (10, for),
(2, goto), (15, if), (7, include), (21, int), (2, long),
(2, register), (11, return), (2, short), (2, signed), (7, sizeof),
(2, static), (13, struct), (2, switch), (2, typedef), (2, union),
(2, unsigned), (7, void), (2, volatile), (7, while),
./nocomment < nocomment.c > copy.c
./wordp < copy.c
(2, break), (2, define), (9, else), (20, if), (1, include),
(3, int), (10, return), (6, while),
./nocomment < wordp.c > copy.c
./wordp < copy.c
(1, break), (7, char), (2, define), (2, else), (2, for),
(11, if), (3, include), (17, int), (7, return), (2, sizeof),
(7, struct), (4, void), (3, while),
rm copy.c // clean
*/