Bison Issues - Start Symbol does not output any proposal

I keep getting "Fatal error: Start symbol N_START does not output any suggestion. I completely lost what might be wrong with this code."

I have looked at previous versions and I cannot find anything that I do differently.

Here is the code (long D :)

%error-verbose
%{

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string>
#include <cstring>

using namespace std;

void printTokenInfo(char* tokenType, char* lexeme);
void printRule(const char *lhs, const char *rhs);
int yyerror(const char *s);

int numLines = 0; 

extern "C" {
 int yyparse(void);
 int yylex(void);
 int yywrap() { return 1; }
}

%}

/* Token declarations */
%token T_ASSIGN T_MULT T_PLUS T_MINUS T_DIV
%token T_AND T_OR T_NOT T_LT T_GT
%token T_LE T_GE T_EQ T_NE T_VAR
%token T_ARRAY T_OF T_BOOL T_CHAR T_INT
%token T_PROG T_PROC T_BEGIN T_END T_WHILE
%token T_DO T_IF T_READ T_UNKNOWN
%token T_WRITE T_TRUE T_FALSE T_LBRACK T_RBRACK
%token T_SCOLON T_COLON T_LPAREN T_RPAREN T_COMMA
%token T_DOT T_DOTDOT T_INTCONST T_CHARCONST T_IDENT

%nonassoc T_THEN
%nonassoc T_ELSE

/* Starting point */
%start N_START

%%
N_START : N_PROG
    {
        printRule("START", "PROG");
        return 0;
    }
    ;
N_PROG  : N_PROGLBL T_IDENT T_SCOLON N_BLOCK T_DOT
    {
        printRule("PROG", "PROG_LBL ident ; BLOCK.");
    }
    ;
N_PROGLBL : T_PROG
    {
        printRule("PROG_LBL", "T_PROGTOKEN");
    }
    ;
N_BLOCK : N_VAR_DEC N_PROC_DEC N_STMT
    {
        printRule("BLOCK", "VAR_DEC PROC_DEC STMT");
    }
    ;
N_VAR_DEC_PART  :   //Epsilon
    {
        printRule("VAR_DEC_PART", "epsilon");
    }
            |   T_VAR N_VAR_DEC T_SCOLON N_VAR_DEC_LST
    {
        printRule("VAR_DEC_PART", "var VAR_DEC : VAR_DEC_LST");
    }
    ;
N_VAR_DEC_LST   :   //Epsilon
    {
        printRule("VAR_DEC_LST", "epsilon");
    }
                |   N_VAR_DEC T_SCOLON N_VAR_DEC_LST
    {
        printRule("VAR_DEC_LST", "VAR_DEC : VAR_DEC_LST");
    }
    ;
N_VAR_DEC   :   T_IDENT N_VAR_DEC_LST T_COLON N_TYPE
    {
        printRule("VAR_DEC", "ident VAR_DEC_LST : TYPE");
    }
    ;
N_IDENT     :   T_IDENT
    {
        printRule("IDENT", "ident");
    }
    ;
N_IDENT_LST :   //Epsilon
    {
        printRule("IDENT_LST", "epsilon");
    }
            |   T_COMMA N_IDENT N_IDENT_LST
    {
        printRule("IDENT_LST", ", IDENT IDENT_LST");
    }
    ;
N_TYPE  :   N_SIMPLE
    {
        printRule("TYPE", "SIMPLE");
    }
        |   N_ARRAY
    {
        printRule("TYPE", "ARRAY");
    }
    ;
N_ARRAY :   T_ARRAY T_LBRACK N_IDX_RANGE T_RBRACK T_OF N_SIMPLE
    {
        printRule("ARRAY", "ARRAY ( IDX_RANGE ) of SIMPLE");
    }
    ;
N_IDX   :   N_INTCONST
    {
        printRule("IDX", "IN_CONST");
    }
    ;
N_IDX_RANGE :   N_IDX T_DOTDOT N_IDX
    {
        printRule("IDX_RANGE", "IDX .. IDX");
    }
    ;
N_SIMPLE    :   T_INTCONST
    {
        printRule("SIMPLE", "intconst");
    }
            |   T_CHARCONST
    {
        printRule("SIMPLE", "charconst");
    }
            |   T_BOOL
    {
        printRule("SIMPLE", "bool");
    }
    ;
N_PROC_DEC_PART :   //Epsilon
    {
        printRule("PROC_DEC_PART", "epsilon");
    }
                |   N_PROC_DEC T_SCOLON N_PROC_DEC_PART
    {
        printRule("PROC_DEC_PART", "PROC_DEC : PROC_DEC_PART");
    }
    ;
N_PROC_DEC  :   N_PROC_HDR N_BLOCK
    {
        printRule("PROC_DEC", "PROC_HDR BLOCK");
    }
    ;
N_PROC_HDR  :   T_PROC T_IDENT T_SCOLON
    {
        printRule("PROC_HDR", "proc ident :");
    }
    ;
N_STMT_PART :   N_COMPOUND
    {
        printRule("STMT_PART", "COMPOUND");
    }
    ;
N_COMPOUND  :   T_BEGIN N_STMT N_STMT_LST T_END
    {
        printRule("COMPOUND", "begin STMT STMT_LST end");
    }
    ;
N_STMT_LST  :   //Epsilon
    {
        printRule("STMT_LST", "epsilon");
    }
            |   T_SCOLON N_STMT N_STMT_LST
    {
        printRule("STMT_LST", ": STMT STMT_LST");
    }
    ;
N_STMT  :   N_ASSIGN
    {
        printRule("STMT", "ASSIGN");
    }
        |   N_PROC_STMT
    {
        printRule("STMT", "PROC_STMT");
    }
        |   N_READ
    {
        printRule("STMT", "READ");
    }
        |   N_WRITE
    {
        printRule("STMT", "WRITE");
    }
        |   N_CONDITION
    {
        printRule("STMT", "CONDITION");
    }
        |   N_WHILE
    {
        printRule("STMT", "WHILE");
    }
        |   N_COMPOUND
    {
        printRule("STMT", "COMPOUND");
    }
    ;
N_ASSIGN    :   N_VAR T_ASSIGN N_EXPR
    {
        printRule("ASSIGN", "VAR := EXPR");
    }
    ;
N_PROC_STMT :   N_PROC_IDENT
    {
        printRule("PROC_STMT", "PROC_IDENT");
    }
    ;
N_PROC_IDENT    :   T_IDENT
    {
        printRule("PROC_IDENT", "ident");
    }
    ;
N_READ  :   T_READ T_LPAREN N_INPUT_VAR N_INPUT_LST T_RPAREN
    {
        printRule("READ", "read ( INPUT INPUT_LST )");
    }
    ;
N_INPUT_LST :   //Epsilon
    {
        printRule("INPUT_LST", "epsilon");
    }
            |   T_COMMA N_INPUT_VAR N_INPUT_LST
    {
        printRule("INPUT_LST", ", INPUT_VAR INPUT_LST");
    }
    ;
N_INPUT_VAR :   N_VAR
    {
        printRule("INPUT_VAR", "VAR");
    }
    ;
N_WRITE :   T_WRITE T_LPAREN N_OUTPUT N_OUTPUT_LST T_RPAREN
    {
        printRule("WRITE", "write ( OUTPUT OUTPUT_LST )");
    }
    ;
N_OUTPUT_LST    :   //Epsilon
    {
        printRule("OUTPUT_LST", "epsilon");
    }
                |   T_COMMA N_OUTPUT N_OUTPUT_LST
    {
        printRule("OUTPUT_LST", ", OUTPUT OUTPUT_LST");
    }
    ;
N_OUTPUT    :   N_EXPR
    {
        printRule("OUTPUT", "EXPR");
    }
    ;
N_CONDITION :   T_IF N_EXPR T_THEN N_STMT
    {
        printRule("CONDITION", "if EXPR then STMT");
    }
            |   T_IF N_EXPR T_THEN N_STMT T_ELSE N_STMT
    {
        printRule("CONDITION", "if EXPR then STMT else STMT");
    }
    ;
N_WHILE :   T_WHILE N_EXPR T_DO N_STMT
    {
        printRule("WHILE", "while EXPR do STMT");
    }
    ;
N_EXPR  :   N_SIMPLE_EXPR
    {
        printRule("EXPR", "SIMPLE_EXPR");
    }
        |   N_SIMPLE_EXPR N_REL_OP N_SIMPLE_EXPR
    {
        printRule("EXPR", "SIMPLE_EXPR REL_OP SIMPLE_EXPR");
    }
    ;
N_SIMPLE_EXPR   :   N_TERM N_ADD_OP_LST
    {
        printRule("SIMPLE_EXPR", "TERM ADD_OP_LST");
    }
    ;
N_ADD_OP_LST    :   //Epsilon
    {
        printRule("ADD_OP_LST", "epsilon");
    }
                |   N_ADD_OP N_TERM N_ADD_OP_LST
    {
        printRule("ADD_OP_LST", "ADD_OP TERM ADD_OP_LST");
    }
    ;
N_TERM  :   N_FACTOR N_MULT_OP_LST
    {
        printRule("TERM", "FACTOR MULT_OP_LST");
    }
    ;
N_MULT_OP_LST   :   //Epsilon
    {
        printRule("MULT_OP_LST", "epsilon");
    }
                |   N_MULT_OP N_FACTOR N_MULT_OP_LST
    {
        printRule("MULT_OP_LST", "MULT_OP FACTOR MULT_OP_LST");
    }
    ;
N_FACTOR    :   N_SIGN N_VAR
    {
        printRule("FACTOR", "SIGN VAR");
    }
            |   N_CONST
    {
        printRule("FACTOR", "CONST");
    }
            |   T_LPAREN N_EXPR T_RPAREN
    {
        printRule("FACTOR", "( EXPR )");
    }
            |   T_NOT N_FACTOR
    {
        printRule("FACTOR", "not FACTOR");
    }
    ;
N_SIGN  :   //Epsilon
    {
        printRule("SIGN", "epsilon");
    }
        |   T_PLUS
    {
        printRule("SIGN", "+");
    }
        |   T_MINUS
    {
        printRule("SIGN", "-");
    }
    ;
N_ADD_OP    :   T_PLUS
    {
        printRule("ADD_OP", "+");
    }
            |   T_MINUS
    {
        printRule("ADD_OP", "-");
    }
            |   T_OR
    {
        printRule("ADD_OP", "or");
    }
    ;
N_MULT_OP   :   T_MULT
    {
        printRule("MULT_OP", "*");
    }
            |   T_DIV
    {
        printRule("MULT_OP", "/");
    }
            |   T_AND
    {
        printRule("MULT_OP", "and");
    }
    ;
N_REL_OP    :   T_LT
    {
        printRule("REL_OP", "<");
    }
            |   T_GT
    {
        printRule("REL_OP", ">");
    }
            |   T_LE
    {
        printRule("REL_OP", "<=");
    }
            |   T_GE
    {
        printRule("REL_OP", ">=");
    }
            |   T_EQ
    {
        printRule("REL_OP", "=");
    }
    ;
N_VAR   :   N_ENTIRE_VAR
    {
        printRule("VAR", "ENTIRE_VAR");
    }
        |   N_IDX_VAR
    {
        printRule("VAR", "IDX_VAR");
    }
    ;
N_IDX_VAR   :   N_ARRAY_VAR T_LBRACK N_EXPR T_RBRACK
    {
        printRule("IDX_VAR", "ARRAY_VAR ( EXPR )");
    }
    ;
N_ARRAY_VAR :   N_ENTIRE_VAR
    {
        printRule("ARRAY_VAR", "ENTIRE_VAR");
    }
    ;
N_ENTIRE_VAR    :   N_VAR_IDENT
    {
        printRule("ENTIRE_VAR", "VAR_IDENT");
    }
    ;
N_VAR_IDENT :   T_IDENT
    {
        printRule("VAR_IDENT", "IDENT");
    }
    ;
N_CONST :   N_INTCONST
    {
        printRule("CONST", "INTCONST");
    }
        |   T_CHARCONST
    {
        printRule("CONST", "CHARCONST");
    }
        |   N_BOOLCONST
    {
        printRule("CONST", "BOOLCONST");
    }
    ;
N_INTCONST  :   N_SIGN T_INTCONST
    {
        printRule("INTCONST", "SIGN intconst");
    }
    ;
N_BOOLCONST :   T_TRUE
    {
        printRule("BOOLCONST", "true");
    }
            |   T_FALSE
    {
        printRule("BOOLCONST", "false");
    }
    ;
%%

#include "lex.yy.c"
extern FILE *yyin;

void printRule(const char *lhs, const char *rhs) {
    printf("%s -> %s\n", lhs, rhs);
    return;
}

int yyerror(const char *s) {
    printf("%s\n", s);
    return(1);
}

void printTokenInfo(const char* tokenType, const char* lexeme) {
    printf("TOKEN: %s LEXEME: %s\n", tokenType, lexeme);
}

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

    printf("%d lines processed\n", numLines);

    return 0;
}

      

        
        
        
      

    

Any ideas?