Extraneous Errors? Where & What Are They? C Programming
my code has been proofread repeatedly and I still am unable to figure out why some of these lines give out error messages. Lines where there is only one ' }' get called out as an error. How is this possible?
#include <stdio.h>
#include <getword.h>
#define STORAGE 255
int getword(char *w) {
char *word = w; /*points to first char in array */
char iochar; /*holds current var being processed */
int counter = 0; /* counts number of characters in a word */
char *first = w; /* points to first character in array */
int bslashflag = 0; /* 0 if no backslash seen, 1 otherwise */
int negateornah = 0; /* if set to 1, return value is negated */
while( ( iochar = getchar() ) != EOF ) { /*runs until EOF is encountered */
if( iochar =='\\') /* if a slash char is found in the word*/
{ bslashflag = 1; /*acknowledge that*/
/*backslash was seen*/
iochar = getchar(); /* skip it & go to the next char*/
if(iochar == '\' ){ /*and if it ends up being another*/
/*slash, slash designated to be added in */
*word = iochar; /* so go ahead and add it in */
*word++; /* and go to the next empty slot */
counter++; /*and increment your counter */
iochar = getchar(); /* *ALERT << may or may not beneccessary */
} else if( iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&' )
{ /* if a metacharacter is found after a bslash, */
/*just treat it like any other character*/
*word = iochar;
*word++;
counter+=1;
}
}
else if (iochar == ' ')
{
if(counter == 0) //*f the first char is a space */
{
while( (iochar = getchar() ) == ' ') { } /*skips leading blanks*/
} else if(bslashflag == 1) { /*if there was bslash before space*/
*word++ = iochar; /*add the space as part of string*/
counter++; /*increments counter*/
bslashflag--; /*resets backslash flag for next char check*/
}
else
{ /* until alphanum char is found*/
*word = '\0'; /*if not leading blank, its the end of word*/
if(negateornah == 1)
{
negateornah= 0; /*reset flag for next run*/
counter *= -1; /*negate the value in counter*/
return counter;
}
return counter; /* return word size */
}
}
else if( iochar == '\n' || iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&' )
{ /*if a metacharacter is encountered*/
if(iochar == '\n' && counter == 0) /* if the first char in the word is \n */
{
*word = '\0'; /* and null terminate the array; TRY *first INCASE OF ERROR*/
if(negateornah == 1) {
negateornah= 0; /*reset flag for next run*/
counter *= -1; /*negate the value in counter*/
return counter;
}
return counter; /* null terminate the array and return count so scan can continue*/
}
else if(iochar == '\n' && counter != 0)
{
*word = '\0' ;
ungetc('\n',stdin); /* put it back where you got it*/
if(negateornah == 1) {
negateornah= 0; /*reset flag for next run*/
counter *= -1; /*negate the value in counter*/
return counter;
}
return counter; /*and return a number so the scan can continue*/
}
else if(iochar == '$')
{
if(counter ==0) {
negateornah = 1; } /*means $ was first char in word, set negate count flag*/
if(bslashflag == 1) /* if a backslash was seen before this character*/
{
*word = iochar; /* just add it into the word*/
*word++; /* as part of the string*/
counter++; /* and count it as a letter*/
bslashflag=0; /*reset flag for next check*/
}
*word++ = iochar; /*add it into word*/
counter++; /*and account for addition*/
return counter;
}
else if(iochar == '|') {
if(counter==0){
*word = iochar;
*word++;
counter++
return counter;
}
if(bslashflag == 1) {
*word = iochar;
*word++;
counter++;
int bslashflag = 0;
}
if(negateornah == 1) {
negateornah= 0; //reset flag for next run*/
counter *= -1; //negate the value in counter*/
return counter;
}
return counter;
}
else if(iochar == '&') {
if (counter ==0) {
*word++ = iochar;
*word = '\0';
counter++;
return counter;
}
if(bslashflag == 1) {
*word = iochar;
*word++;
counter++;
bslashflag = 0;
}
if(negateornah == 1) {
negateornah= 0; /*reset flag for next run*/
counter *= -1; /*negate the value in counter*/
return counter;
}
return counter;
}
else if( iochar == '<' || iochar == '>') {
if(counter==0){
*word++ = iochar;
*word = '\0';
return counter;
}
if(bslashflag==1) {
*word = iochar;
*word++;
counter++;
bslashflag = 0;
}
if(negateornah == 1) {
negateornah= 0; /*reset flag for next run*/
counter *= -1; /*negate the value in counter*/
return counter;
}
return counter;
}
else if (iochar == ' ') /* if space is encountered*/
{
if(bslashflag == 1){ /* if a backslash was seen before this*/
*word = iochar;
*word++;
counter++;
bslashflag = 0;
}
else if(counter == 0) /* as the first character */
{
while( (iochar = getchar() ) == ' ') { } /*keep going until*/
}
else { /* iochar is not a space*/
*word = '\0'; /* this block handles the word ending space*/
if(negateornah == 1) {
negateornah= 0; /*reset flag for next run*/
counter *= -1; /*negate the value in counter*/
return counter;
}
return counter; /* by null terminating the word at the end*/
} /* and returning the count and printed word*/
}
*word++ = iochar; /* add iochar into the array if its an alphanum char*/
counter+=1; /* increment counter to reflect added char*/
}
*word = '\0'; /* if EOF is encountered*/
*first = '\0'; /* null terminate entire word, clearing it from the array*/
if(counter != 0){
if(negateornah == 1) {
negateornah= 0; /*reset flag for next run*/
counter *= -1; /*negate the value in counter*/
return counter;
}
return counter; /*ensure word continues in next run*/
}
return -1; /*and return -1 for EOF*/
}
Solution
The most repeated error seems to be:
*word = iochar;
*word++;
Although doing this is fine:
*word++ = iochar;
If you want to split the two steps (set value indirectly; increment pointer) the right way is to do:
*word = iochar;
word++;
The next most repeated issue I see, which doesn't keep your code from compiling or running, is that you reset local variables just before a return -- there's no point, once you call return they're all gone and will not carry over to the next call.
After that, your indentation style is getting in your way -- pick one and stick with it rigidly. Even if you use a different style in another program, that's fine, just be consistent within the file.
Finally, don't write so much code without compiling and testing along the way. You should never be in a position to have so many errors to track down. As you add a new block of code, compile and test incrementally.
Applying the above fixes and suggestions, as well as fixes suggested by others, and translating your code into C ;-) here's a rework that compliles. It doesn't mean it's correct, simply that the compiler accepts it sufficiently that you can start the real debugging:
#include <stdio.h>
#include <stdbool.h>
// #include <getword.h>
int getword(char *w) {
char *word = w; /* points to first char in array */
char iochar; /* holds current var being processed */
int counter = 0; /* counts number of characters in a word */
char *first = w; /* points to first character in array */
bool bslashflag = false; /* false if no backslash seen, true otherwise */
bool negateornah = false; /* if true, return value is negated */
while ((iochar = getchar()) != EOF) { /* runs until EOF is encountered */
if (iochar == '\\') { /* if a slash char is found in the word */
bslashflag = true; /* acknowledge that backslash was seen */
iochar = getchar(); /* skip it & go to the next char */
if (iochar == '\\' ) { /* and if it ends up being another */
/* slash, slash designated to be added in */
*word++ = iochar; /* add it in and go to the next empty slot */
counter++; /* and increment your counter */
iochar = getchar(); /* *ALERT << may or may not be neccessary */
} else if (iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&' ) {
/* if a metacharacter is found after a backslash, */
/* just treat it like any other character */
*word++ = iochar;
counter++;
}
} else if (iochar == ' ') {
if (counter == 0) { /* if the first char is a space */
while ((iochar = getchar()) == ' ') {
/* skip leading blanks */
}
} else if (bslashflag) { /* if there was bslash before space */
*word++ = iochar; /* add the space as part of string */
counter++; /* increment counter */
bslashflag = false; /* reset backslash flag for next char check */
} else { /* until alphanum char is found */
*word = '\0'; /* if not leading blank, its the end of word */
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter; /* return word size */
}
} else if (iochar == '\n' || iochar == '<' || iochar == '>' || iochar == '|' || iochar == '$' || iochar == '&' ) {
/* if a metacharacter is encountered */
if (iochar == '\n' && counter == 0) { /* if the first char in the word is \n */
*word = '\0'; /* and null terminate the array; TRY *first INCASE OF ERROR */
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter; /* null terminate the array and return count so scan can continue */
} else if (iochar == '\n' && counter != 0) {
*word = '\0' ;
ungetc('\n', stdin); /* put it back where you got it */
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter; /* and return a number so the scan can continue */
} else if (iochar == '$') {
if (counter == 0) {
negateornah = true; /* means $ was first char in word, set negate count flag */
}
if (bslashflag) { /* if a backslash was seen before this character */
*word++ = iochar; /* just add it into the word as part of the string */
counter++; /* and count it as a letter */
}
*word++ = iochar; /* add it into word */
return counter + 1; /* and account for addition */
} else if (iochar == '|') {
if (counter == 0) {
*word++ = iochar;
return counter + 1;
}
if (bslashflag) {
*word++ = iochar;
counter++;
}
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter;
} else if (iochar == '&') {
if (counter == 0) {
*word++ = iochar;
*word = '\0';
return counter + 1;
}
if (bslashflag) {
*word++ = iochar;
counter++;
}
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter;
} else if (iochar == '<' || iochar == '>') {
if (counter == 0) {
*word++ = iochar;
*word = '\0';
return counter;
}
if (bslashflag) {
*word++ = iochar;
counter++;
}
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter;
} else if (iochar == ' ') { /* if space is encountered */
if (bslashflag) { /* if a backslash was seen before this */
*word++ = iochar;
counter++;
bslashflag = false;
} else if (counter == 0) { /* as the first character */
while ((iochar = getchar() ) == ' ') {
/* keep going until iochar is not a space */
}
} else {
*word = '\0'; /* this block handles the word ending space */
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter; /* by null terminating the word at the end */
} /* and return the count and printed word */
}
*word++ = iochar; /* add iochar into the array if its an alphanum char */
counter++; /* increment counter to reflect added char */
}
*word = '\0'; /* if EOF is encountered */
*first = '\0'; /* null terminate entire word, clearing it from the array */
if (counter != 0) {
if (negateornah) {
counter *= -1; /* negate the value in counter */
}
return counter;
}
}
return -1; /* and return -1 for EOF */
}
- How do I convert argv to lpCommandLine parameter of CreateProcess?
- How to calulate CRC of 1 byte using stm32l1 CRC unit
- Can't put values together into struct that is initiated by pointer and malloc
- Using TinyAES to encrypt a decrypt data returns a strange result
- What causes the error "undefined reference to (some function)"?
- What is the difference between memmove and memcpy?
- C compiler for Windows?
- How to setup a shared ccache
- Checking stack usage at compile time
- Static assertion to check if a variable name is defined in the current scope
- Trying to read txt file line by line in C Language
- How do you do exponentiation in C?
- Is it possible to modify the content of a struct pointer inside a function?
- Programmatically retrieving the absolute path of an OS X command-line app
- Should Portable Types Be Used in the Declaration of a Main Function? (C11)
- GCC Linker, bss section symbols equal zero length
- Is there any reasonable initial/invalid value for a pid_t?
- Fork in Linux: Weird infinite loop while freeing condition variable
- Function definition with prototype vs without prototype
- How do I achieve tilde expansion in C?
- Is there really no mremap in Darwin?
- Interpreting the format specifier in printf("%.-1f", 34.14)
- Why is my socket's open port not listed by netstat?
- Why I get bus-error with unused FILE pointer?
- How does strcmp() work?
- Rationale behind declaring FILE * volatile to stdin in C
- Getting actual file name (with proper casing) on Windows
- Is it possible to make a C++ application and use Flutter as the GUI framework?
- Difference between char* and const char*?
- How can I make switch-case statements case insensitive?