how to use scanf to read every word in a file. - c

Question

In c code. I have an input file (called in) that is a mad-lib in the format, "I have really < adjective> eyes" (no spaces inside the <>) and I want to write a bool function that uses scanf to read every word and return true if the word begins with '<' (also called a token) How would I go about doing that? and yes I have to use scanf. Here is what I have right now but I do not think that it is completely right, so another question is, how do I know if my function is properly working.
/* istoken = returns true if word is a token */
bool istoken(char word[]) {
char first;
int firstindex;
while (1) {
scanf("%s", word);
first = word[MAX_LEN];
firstindex = (int)strlen(word);
if (first == '<') {
printf("The token is: %s\n", first);
return true; }
else {
return false; }
}
}

Answer 1

In the caller, word must be sufficienly sized to hold the largest word in your text (+3 chars, 2 for <,> and the nul-termanting character. You should pass the maximum length for word as a parameter to istoken, but since you are using scanf, you must hard-code the field width modifier to protect your array bounds. (that is one of the reasons fgets is recommended over scanf -- but you must use scanf). Don't skimp on buffer size for word in the caller. Something like the following should suffice in the caller (probably main() for you):
#define MAXC 1024
...
char word[MAXC] = "";
There is no need for first or firstindex. To check the first character in a string, all you need do is dereference the pointer. With that, it is simply a matter of:
/* istoken = returns true if word is a token */
bool istoken (char *word) {
while (scanf("%1023s", word) == 1) /* did a valid read take place? */
if (*word == '<') /* is 1st char '<' ? */
return true; /* return true */
return false; /* out of words, return false */
}
(note: simply returning the token in word via the pointer parameter while returning bool, seems a bit of an awkward factoring of your code -- but it is doable. Also, if the token exceeds 1024 chars, including the nul-terminating char -- you will not have a complete token in word on function return)
Look things over and let me know if you have further questions.
A Short Example Reading stdin
#include <stdio.h>
#include <stdbool.h>
#define MAXC 1024
/* istoken = returns true if word is a token */
bool istoken (char *word) {
while (scanf("%1023s", word) == 1) /* did a valid read take place? */
if (*word == '<') /* is 1st char '<' ? */
return true; /* return true */
return false; /* out of words, return false */
}
int main (void) {
char word[MAXC] = "";
if (istoken (word))
printf ("found token: '%s'\n", word);
else
fprintf (stderr, "error: no token found.\n");
return 0;
}
Example Use/Output
$ echo "my dog has <too> many fleas." | ./bin/scanftoken
found token: '<too>'
Last note: while you, as you propose in the comment below, can output the token from within intoken, e.g.
bool istoken(char word[]) {
while (scanf("%100s", word) == 1) {
if (word[0] == '<') {
printf("the token is: %s\n", word);
return true;
}
}
return false;
}
That is generally something you want to avoid. Within your program design you want (as a goal) to separate your implementation (what your program does, computes, etc..) from Input/Output. That makes your code usable when called by more than one function that wants to output printf("the token is: %s\n", word);
While a bit uncommon, your istoken function that locates a token and returns true/false makes more sense if the caller then uses that return to determine what to do with the token in word. If you are just going to print it from inside intoken if a token is found, and then do nothing with the return in the caller, then why declare it as bool anyway -- you may as well just declare it as void if you are not using the return.
Like I said this is (a goal). You can factor your code any way you like as long as it is valid code. The use of printf within istoken is perfectly valid for temporary debugging purposes as well. (in fact that is one of the most helpful debugging tools you have, just sprinkle temporary printf statements throughout the logic path in your program to find out where you code works as intended and where the "train-falls-off-the-track" so to speak.
Example with File I/O
OK, we are finally getting to 'Z' with this 'XY' problem. Since, as I now understand, you have your text in a file (I have used "myfile.txt" for the input) and you want to read your inputfile in istoken and return word and true/false to main() and if true then write the token to your output file (I used "tokenfile.txt" before for my output file), then what you need to do is open both your input file and output file using fopen in main() similar to the following:
FILE *ifp = fopen ("myfile.txt", "r"), /* infile pointer */
*ofp = fopen ("tokenfile.txt", "w"); /* outfile pointer */
(I'm not that creative, I just use ifp for the input file pointer and ofp for the output file pointer)
Whenever you open a file, before you attempt to read or write to the file, you must validate that the file is actually open for reading or writing (e.g. fopen succeeded). For example:
if (ifp == NULL) { /* validate input open for reading */
perror ("fopen-myfile.txt");
return 1;
}
if (ofp == NULL) { /* validate output open for writing */
perror ("fopen-tokenfile.txt");
return 1;
}
Now with both files open, you can call istoken and read from ifp. However, this takes modifying istoken to take a FILE * parameter for use with fscanf instead of using scanf. For example:
/* istoken = returns true if word is a token */
bool istoken (FILE *ifp, char *word) {
while (fscanf(ifp, "%1023s", word) == 1) /* valid read take place? */
if (*word == '<') /* is 1st char '<' ? */
return true; /* return true */
return false; /* out of words */
}
After the return of istoken, you can write to stdout to let the user know if a token was found and also write to ofp to store token in your output file, e.g..
if (istoken (ifp, word)) { /* call istoken passing open ifp */
printf ("found token: '%s'\n", word); /* output token */
fprintf (ofp, "%s\n", word); /* write token to outfile */
}
else
fprintf (stderr, "error: no token found.\n");
Lastly, you must fclose the files you have open. But there is a twist for files you write to. You should validate the fclose to insure a stream-error did not occur on ofp that may not have been otherwise caught. e.g.
fclose (ifp); /* close infile pointer */
if (fclose(ofp) == EOF) /* validate "close-after-write" */
perror ("stream error on outfile stream close");
Putting it altogether, you can do something like the following:
#include <stdio.h>
#include <stdbool.h>
#define MAXC 1024
/* istoken = returns true if word is a token */
bool istoken (FILE *ifp, char *word) {
while (fscanf(ifp, "%1023s", word) == 1) /* valid read take place? */
if (*word == '<') /* is 1st char '<' ? */
return true; /* return true */
return false; /* out of words */
}
int main (void) {
char word[MAXC] = "";
FILE *ifp = fopen ("myfile.txt", "r"), /* infile pointer */
*ofp = fopen ("tokenfile.txt", "w"); /* outfile pointer */
if (ifp == NULL) { /* validate input open for reading */
perror ("fopen-myfile.txt");
return 1;
}
if (ofp == NULL) { /* validate output open for writing */
perror ("fopen-tokenfile.txt");
return 1;
}
if (istoken (ifp, word)) { /* call istoken passing open ifp */
printf ("found token: '%s'\n", word); /* output token */
fprintf (ofp, "%s\n", word); /* write token to outfile */
}
else
fprintf (stderr, "error: no token found.\n");
fclose (ifp); /* close infile pointer */
if (fclose(ofp) == EOF) /* validate "close-after-write" */
perror ("stream error on outfile stream close");
return 0;
}
Example Input File
$ cat myfile.txt
my dog has <too> many fleas.
Example Use/Output
$ ./bin/scanftoken
found token: '<too>'
$ cat tokenfile.txt
<too>
The best advice I can give you on learning C is to simply slow down. There is a lot to learn, and in fact given 30 years, I have barely scratched the surface (that and they keep revising the standard every so often). Just take it a step at a time. Loop up the man page for each function you use, find out what the proper parameter are and most critically what it returns and what form of error reporting is has (e.g. does it set errno so you can use perror to report the error or do you need to use fprintf (stderr, ....)?
Always enable compiler warnings and read and understand the warning and do not accept code until it compiles without warning. You can learn a lot of C just by listening to what your compiler is telling you. And if all else fails... talk to the duck. How to debug small programs, really, it helps :)

Answer 2

If you mind using some powerful lexical analyzer, I suggest you using flex which can help you lot for tokenization.
As you can see, Flex let you write token pattern and generate a C parser which does all the work.
Here is a program which compresses multiple blanks and tabs down to a single blank, and throws away whitespace found at the end of a line:
%%
[ \t]+ putchar( ' ' );
[ \t]+$ /* ignore this token */
You can find more at http://alumni.cs.ucr.edu/~lgao/teaching/flex.html.