Receiving Segmentation fault (core dumped) in the following lex/yacc files. What is wrong with them?

Question

I'm getting Segmentation fault (core dumped) for the following codes :

The lex file is as follows, test.l :

    %{

    #include "y.tab.h"

    #define LOOKUP 0

    int state;

    int add_word(int type, char *word);
    int lookup_word(char *word);
    %}

    %%

    \n {state = LOOKUP;}
    \.\n {state = LOOKUP;
            return 0;
        }

    ^verb {state = VERB;}
    ^adj {state = ADJECTIVE;}
    ^adv {state = ADVERB;}
    ^noun {state = NOUN;}
    ^prep {state = PREPOSITION;}
    ^pron {state = PRONOUN;}
    ^conj {state = CONJUNCTION;}

    [a-zA-Z]+ {
                if(state != LOOKUP){
                    add_word(state, yytext);
                }else{
                    switch(lookup_word(yytext)){
                        case VERB: return(VERB);
                        case ADJECTIVE: return(ADJECTIVE);
                        case ADVERB: return(ADVERB);
                        case NOUN: return(NOUN);
                        case PREPOSITION: return(PREPOSITION);
                        case PRONOUN: return(PRONOUN);
                        case CONJUNCTION: return(CONJUNCTION);
                        default:
                            printf("%s: don't recog\n",yytext);
                    }
                }
                }
    . ;

    %%
    struct word{
        char *word_name;
        int word_type;
        struct word *next;
    };

    struct word *word_list;

    extern void *malloc();

    int add_word(int type, char *word){
        struct word *wp;
        if(lookup_word(word) != LOOKUP){
            printf("word %s already defined\n", word);
            return 0;
        }

        wp = (struct word *) malloc(sizeof(struct word));

        wp-> next = word_list;

        wp-> word_name = (char*) malloc(strlen(word)+1);
        strcpy(wp->word_name, word);
        wp->word_type = type;
        word_list = wp;
        return 1;
    }

    int lookup_word(char *word){
        struct word *wp = word_list;

        for(; wp; wp = wp->next){
        if(strcmp(wp->word_name, word) == 0)
            return wp->word_type;
        }
        return LOOKUP;
    }

The yacc file is as follows,

test.y:

%{

#include <stdio.h>

%}

%token NOUN PRONOUN VERB ADVERB ADJECTIVE PREPOSITION CONJUNCTION

%%
sentence: subject VERB object {printf("sentence is valid\n");}
        ;

subject: NOUN
        | PRONOUN
        ;
object: NOUN
        ;

%%

extern FILE *yyin;

main(){ 
    while(!feof(yyin)){
        yyparse();
    }
}

yyerror(s)
{
    fprintf(stderr, "some error\n");
}

I've been trying for hours to figure out what is the problem. I am completely new with these and following the book "O'reilly - Lex and Yacc".

Answer 1

The scanner generated by (f)lex, which is the component responsible for performing the input, initializes yyin and yyout to stdin and stdout, respectively, during its initialization function. Before that, they are both NULL pointers, as a result of C's static initialization rule (which is that global pointer variables are initialized to NULL.)

The initialization function is called the first time yylex is called. (It sets a flag so that the next call to yylex does not do the initialization again. That's a very typical approach to initializing library systems; most malloc implementations and some implementations of the C stdio functions do the same thing.)

yylex is called repeatedly by yyparse, so the first call to yyparse implicitly initializes yylex. But when you write:

main(){ 
  while(!feof(yyin)){
    yyparse();
  }
}

the first use of yyin occurs before it has been initialized. Consequently, the first time the while condition is evaluated, yyin is still NULL and therefore there is no second time; the resulting segfault is fatal.

You could fix that by initializing yyin yourself, but since while (!feof(file)) is always wrong (sm), it would make more sense to put the EOF test at the end of the loop:

int main(){ 
  do yyparse(); while (!feof(yyin));
}

See this very helpful SO answer to the question Why is “while ( !feof (file) )” always wrong? for a detailed analysis.