user3390986 user3390986 - 2 months ago 7
C Question

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?
ERROR MESSAGES HERE

#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*/
}

Answer

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 */
}