#
# ---------------------------------------------------------------------
#
#                          GRAMMAR SECTION
#
# ---------------------------------------------------------------------
#


# ---------------------------------------------------------------------
#   <grammar> ::= [{ <assignment> | <comment> | <white> }] EOF
#
#
grammar ::=

        out_header [{ (assignment | wc) flush }] [ '%%' [{ . }] ]

        ( eoi out_footer | error( 'Syntax error' ) );



# ---------------------------------------------------------------------
# <comment> ::= '#' ~[{  not '\n' }]~ '\n'
#
# where the internal routine 'commentchars' does a transparent parse on
# the expression '~[{ not '\n' }]~'.
#
comment ::=

	'##' ignorechars '\n'
	| '#' out_comment_begin commentchars '\n' out_comment_end;



# ---------------------------------------------------------------------
# <assignment> ::= <name> [<wc>] ('=' | '::=') <expression> ';'
#
assignment ::=

    out_func_type name [wc]
    ( '=' | '::=' | error( ' \'=\' or \'::=\' expected' ) )
    out_func_begin expression
    ( ';' inc_rule | error( '\';\' expected' ) )
    out_func_end;



# ---------------------------------------------------------------------
# <expression> ::= term [{ '|' term }]
#
expression ::=

    (       [wc] (
            out_or_begin term
            {[wc] '|' [wc] out_or_operator term} out_or_end
        |   term ) [wc]
    )
    | error('Expression expected');



# ---------------------------------------------------------------------
#   <term> ::= <ordinary_and> | <swapped_and> | <factor>
#
term ::=
    ordinary_and | swapped_and | factor;



# ---------------------------------------------------------------------
#   <ordinary_and> ::= factor { wc <factor> }
#
ordinary_and ::=

    out_and_begin factor out_and_1 {
        wc factor out_and_2
    } out_and_end;



# ---------------------------------------------------------------------
# <swapped_and> ::= factor { '#' <factor> }
#
swapped_and ::=

    out_swp_begin factor out_swp_1 {
            [wc] '#' [wc] out_swp_2 factor out_swp_3
        |   wc factor out_swp_4
    } out_swp_end;


# ---------------------------------------------------------------------
# <factor> ::= <IO> | ident | '(' expression rparen | option | repetition
#
# postfix operators are quite time consuming :(
factor ::=

        '!' [wc] simple_factor                  # The 'not' operator.
        | simple_factor [ [wc] ('*'|'+') ];     # Kleene's '*' and '+'.
                
simple_factor ::=
        IO
    |   function        
    |   identifier
    |   option
    |   repetition
    |   '('  expression rparen;




# --------------------------------------------------------------------
# <IO> ::= <input> | <output> | <trans> | '.' | <error>
#
IO ::=

        input
    |   output
    |   trans
    |   '.' out_trans_char
    |   syntax_error;



# ---------------------------------------------------------------------
# input ::= ['in' [wc] '(' [wc]] <string> [ [wc] rparen]
#
input ::=

        'in' [wc] '(' [wc]  out_str_begin string out_str_end [wc] rparen
    |   out_str_begin string out_str_end;



# ---------------------------------------------------------------------
# output ::= 'out' [<wc>] '(' [<wc>] <string> [<wc>] rparen
#   | '`' [{o_stringchar}] '`'
#
output ::=

        'out' out_out_1_begin [wc] '(' [wc] string [wc] rparen out_out_1_end
    |   '`' out_out_2_begin [{o_stringchar}] (
                '`' out_out_2_end
            |   error( 'Unterminated output string' )
        );



# ---------------------------------------------------------------------
# trans ::= 'trans' [<wc>] '(' [<wc>] <string> [<wc>] rparen
#   | '\"' [{t_stringchar}] '\"'
#
trans ::=

        out_tran_1_begin 'trans' [wc] '(' [wc] string [wc] rparen out_tran_1_end
    |   '\"' out_tran_2_begin [{t_stringchar}] (
                '\"' out_tran_2_end
            |   error( 'Unterminated trans string' )
        );



# ---------------------------------------------------------------------
# syntax_error ::= 'error' [wc] '(' [wc] string [wc] rparen
#
syntax_error ::=

   'error' [wc] '(' [wc] out_err_begin string [wc] rparen out_err_end;


# ---------------------------------------------------------------------
# There is NO white allowed between name and '(', or we would
# have a serious problem. still I think that this solution is
# NOT clear, and this should be changed in the future...
#
function ::=
        valid_name | name '(' expression rparen;

# ---------------------------------------------------------------------
#   <identifier> ::= <name>
#
identifier ::=
         valid_name | out_call_begin name out_call_end;

# --------------------------------------------------------------------
#
#
valid_name = 
    '__BNF_' error( 'names beginning with \'__BNF_\' are reserved' );

# ---------------------------------------------------------------------
# <option> ::= '[' <expression> ']'
#
option ::=

    '[' expression (']' | error( '\']\' expected' )) out_option;


# ---------------------------------------------------------------------
#   <repetition> ::= '{' <expression> '}'
#

repetition ::=

    '{' out_rep_begin expression ('}' | error( '\'}\' expected' )) out_rep_end;




# ---------------------------------------------------------------------
# <name> ::= <letter> (letter | digit)*
#
name ::=

    letter [{ letter | digit }];

# ---------------------------------------------------------------------
#   <string> ::= string_el ( wc string_el )*
#
string=
        string_el [{ wc out_str_seperator string_el }];


# ---------------------------------------------------------------------
# <string_el ::= '\'' [{stringchar}] '\''
#
string_el ::=

    '\'' out_str_ch [{ stringchar }] '\'' out_str_ch;



# ----------------------------------------------------------------------
# rparen ::= ')'
#
rparen ::=

    ')' | error( '\')\' expected' );

# ----------------------------------------------------------------------
# wc ::= white or comment in an expression
#
wc ::=

    { white | comment };


#
# ---------------------------------------------------------------------
#
#                           OUTPUT SECTION
#
# ---------------------------------------------------------------------
#

out_lbrace      ::= out( '{\n' ) inc_level;
out_rbrace      ::= dec_level out_indent out( '}' );
out_state_zero  ::= out_indent out('state = 0;\n');
out_do_begin    ::= out_indent `do ` out_lbrace;
out_do_end      ::= out_rbrace ` while( 0 );\n\n`;
out_hold        ::= out_indent `HOLD; /* --- remember current I/O state --- */\n`;
out_restore     ::= `RESTORE; /* --- restore I/O state --- */`;
out_do_hold_begin ::= out_do_begin out_indent `HOLD;\n\n`;
out_endfn       ::= ` ); /* --- Call function --- */\n`;
out_end_strfn   ::= ` ` out_endfn;
out_set_state   ::= out_indent `state = `;
out_break_on_accept ::=  out_indent `if (!state) break;\n`;
out_break_on_reject ::= out_indent `if (state) break;\n`;
out_break_and_restore_on_reject ::=
        out_indent `if (state) { RESTORE; break; };\n`;

# ---------------------------------------------------------------------
# out_header, out_footer: Generated code in the grammar rule
#
out_header=
        `/* This generated file is licenced and copyrighted under the same \n`
        ` * conditions as the sourcefile. Happy debugging:) */\n`
        `\n`
        `/*\n`
        `    defines:\n`
        `*/\n`
        `\n`
        `#define HOLD        unsigned hold___BNF_level = __BNF_level; char *hold___BNF_input = __BNF_input, *hold___BNF_output = __BNF_output\n`
        `#define RESTORE     {__BNF_level = hold___BNF_level; __BNF_input = hold___BNF_input; __BNF_output = hold___BNF_output;}\n`
        `\n`
        `#ifdef __TURBOC__\n`
        `# pragma warn -pro\n`
        `# pragma warn -nod\n`
        `#endif\n`
        `\n`
        `#ifdef _MSC_VER\n`
        `# pragma warning (disable:4013)\n`
        `# pragma warning (disable:4005)\n`
        `#endif\n`
        `\n`
        `/*\n`
        `    externals:\n`
        `*/\n`
        `\n`
        `extern char *__BNF_input, *__BNF_output;\nextern unsigned __BNF_level;\n`
		`extern unsigned int __BNF_tabsize;\n`
        `\n`
        `extern int __BNF_trans_string(char *),\n`
        `    __BNF_input_string(char *), __BNF_output_string(char *),\n`
        `    __BNF_trans_char(void), __BNF_swap(char *, char *, char *);\n`
        `\n`
		`\n`
        `extern void user_error(char *); /* user provided error handler must TERMINATE */\n`
        `\n`
        `\n`;

out_footer=
    `\n\n` out_comment_begin ` begining of standard utility functions ` out_comment_end `\n`
    now_do_the_builtins_dump_mister
	now_do_the_strfilio_mister;

# ---------------------------------------------------------------------
#   out_comment_begin, out_comment_end: Generated code in the comment rule
#
out_comment_begin = `/*`;
out_comment_end   = `*/\n`;

# ---------------------------------------------------------------------
# out_func_begin, out_func_end:
#       Generated code in the assigment rule.
#
out_func_type  = `\nint `;
out_func_begin = `(void)\n` out_lbrace out_indent `int state;\n\n`;
out_expr_empty = out_state_zero;
out_func_end   = out_indent `return state;` out_rbrace `\n\n`;


# ---------------------------------------------------------------------
# out_or_begin, out_or_end, out_or_end:
#
out_or_begin    = out_do_begin;
out_or_operator = out_break_on_accept;
out_or_end      = out_do_end;


# ---------------------------------------------------------------------
#   out_and_begin,out_and_1,out_and_2,out_and_end:
#
out_and_begin = out_do_hold_begin;
out_and_1     = out_break_on_reject;
out_and_2     = out_break_and_restore_on_reject;
out_and_end   = out_do_end;


#------------------------------------------------------
# output for 'swapped and'
#
out_swp_begin = out_do_hold_begin
                out_indent `register char *swap_first = __BNF_output, *swap_second;\n`;
out_swp_1     = out_break_on_reject;
out_swp_2     = out_indent `swap_second = __BNF_output;\n`;
out_swp_3     = out_break_and_restore_on_reject
                out_indent `__BNF_swap( swap_first, swap_second, __BNF_output );\n`
                out_indent `swap_first = __BNF_output;\n`;
out_swp_4     = out_break_and_restore_on_reject;
out_swp_end   = out_do_end;

#-------------------------------------------------------
# output for 'option'
#
out_option = out_state_zero;

#------------------------------------------
# output for 'repetition'
#
out_rep_begin = out_indent out_lbrace out_indent `int firstloop = 1;\n` out_do_begin;

##out_rep_end   = out_indent `if (firstloop) { if(state) break; firstloop = 0;} } while ( !state ); ` out_indent `state = firstloop;` out_rbrace;
out_rep_end   = out_indent `if (firstloop)\n`
                out_indent out_lbrace
                out_indent `if (state) break;\n`
                out_indent `firstloop = 0;\n`
                out_rbrace `\n`
                out_rbrace ` while ( !state );\n`
                out_indent `state = firstloop;\n`
                out_rbrace `\n`;

#---------------------------------------------
# output for 'trans any character' (a shortcut...)
#
out_trans_char = out_call_begin `__BNF_trans_char` out_call_end;


# ---------------------------------------------
# output for 'input a string'
#
out_str_begin = out_set_state `__BNF_input_string( `;
out_str_end   = out_end_strfn;


#------------------------------------------------------
#   output for 'output a string'
#
out_out_1_begin = out_set_state `__BNF_output_string( `;
out_out_1_end   = out_end_strfn;
out_out_2_begin = out_set_state `__BNF_output_string( \"`;
out_out_2_end   = `\"` out_end_strfn;

#---------------------------------
# output for 'trans a string'
#
out_tran_1_begin = out_call_begin `__BNF_trans_string( `;
out_tran_1_end   = out_end_strfn;
out_tran_2_begin = out_call_begin `__BNF_trans_string( \"`;
out_tran_2_end   = `\"` out_end_strfn;



# ---------------------------------
# output for 'error(...)' call
#
out_err_begin = out_indent `user_error( `;
out_err_end   = out_end_strfn out_state_zero;


#--------------------------------------------
# output for <call>
#
out_call_begin = out_set_state;
out_call_end   = `(` out_endfn;


#----------------------------------------------
# output a 'string start/stop symbol' (`"` in C)
#
out_str_ch = `\"`;

#-------------------------
# output between multiple spaces
#
out_str_seperator = `\n` out_indent;


# eof



##############################################################



now_do_the_builtins_dump_mister = 
`\n`
`\n`

`#include <stdio.h> /* for EOF */\n`
`#include <ctype.h>\n`
`#include <stdlib.h>\n`
`#include <string.h>\n`
`\n`
`/*#define HOLD        unsigned hold___BNF_level = __BNF_level; char *hold___BNF_input = __BNF_input, *hold___BNF_output = __BNF_output\n`
`#define RESTORE     {__BNF_level = hold___BNF_level, __BNF_input = hold___BNF_input; __BNF_output = hold___BNF_output;}*/\n`
`#define DEFUN(f)    int f(void)\n`
`#define CALL(f)     state = f();\n`
`#define IN__BNF_put(s)    state = __BNF_input_string( s );\n`
`#define OUT__BNF_put(s)   state = __BNF_output_string( s );\n`
`#define FUN_begin   { int state; HOLD;\n`
`#define FUN_end     if (state) RESTORE; return state; }\n`
`#define AND_begin   do { HOLD;\n`
`#define AND_1       if (state) break;\n`
`#define AND_2       if (state) { RESTORE; break; }\n`
`#define AND_end     } while (0);\n`
`#define OR_begin    do {\n`
`#define OR_1        if (!state) break;\n`
`#define OR_end      } while (0);\n`
`#define OPT_begin\n`
`#define OPT_end     state = 0;\n`
`#define REP_begin   { inte firstloop=1; do {\n`
`#define REP_end     if (firstloop) {if(state) break; firstloop=0;} } while (!state); state=firstloop; }\n`
`\n`
`extern char *__BNF_input, *__BNF_output;\n`
`unsigned __BNF_level;\n`
`unsigned int __BNF_rulecnt;`
`\n`
`/* we need some prototypes .... */\n`
`int __BNF_get(void);          /* returns EOF when eof read... */\n`
`int __BNF_flush(void);\n`
`#define __BNF_put(ch) *__BNF_output++ = (ch)\n`
`\n`
`int __BNF_input_string( char *s )\n`
`FUN_begin\n`
`  char *t;\n`
`\n`
`  for (t = s, state = 0; *t; t++)\n`
`    if ((state = (__BNF_get() != *t)) != 0) break;\n`
`\n`
`FUN_end\n`
`\n`
`int __BNF_output_string( char *source )\n`
`{\n`
`    register char *s = source, *t = __BNF_output;\n`
`\n`
`    while ( *s ) *t++ = *s++;\n`
`\n`
`    __BNF_output = t;\n`
`\n`
`    return 0;\n`
`}\n`
`\n`
`\n`
`int __BNF_trans_string( char *str )\n`
`FUN_begin\n`
`  char *s, ch;\n`
`\n`
`  for ( s = str; *s; s++) {\n`
`        ch = __BNF_get();\n`
`        if ( ch == *s )\n`
`          __BNF_put( ch );\n`
`        else {\n`
`          RESTORE;\n`
`          return 1;\n`
`        }\n`
`  }\n`
`  state = 0;\n`
`\n`
`FUN_end\n`
`\n`
`int __BNF_swap( char *first, char *second, char *third )\n`
`{\n`
`        unsigned len1 = second - first, len2 = third - second;\n`
`        char *hold = strncpy( (char *) malloc(len1+1), first, len1 );\n`
`\n`
`        strncpy( first, second, len2 );\n`
`        strncpy( first+len2, hold, len1 );\n`
`\n`
`        free(hold);\n`
`    return 0;\n`
`}\n`
`\n`
`DEFUN(__BNF_trans_char)\n`
`FUN_begin\n`
`  int ch;\n`
`\n`
`  if ( (state = ((ch = __BNF_get()) == EOF)) == 0) __BNF_put( ch );\n`
`FUN_end\n`
`\n`
`DEFUN(eoi)\n`
`FUN_begin\n`
`  state = !(__BNF_get() == EOF);\n`
`FUN_end\n`
`\n`
`DEFUN(commentchars)\n`
`{\n`
`        register char ch;\n`
`\n`
`        for ( ch = __BNF_get(); ch != '\\n'; ch = __BNF_get() )\n`
`                __BNF_put(ch);\n`
`\n`
`        --__BNF_input;\n`
`\n`
`        return 0;\n`
`}\n`
   `\n`
   `\n`
   `int ignorechars (void)\n`
   `{\n`
   `   int   ch;\n`
   `\n`
   `   ch = __BNF_get();\n`
   `   while ( ch != '\\n' && ch != EOF )\n`
   `      ch = __BNF_get();\n`
   `   -- __BNF_input;\n`
   `   return   0;\n`
   `}\n`
`\n`
`DEFUN(stringchar)\n`
`FUN_begin\n`
`  int ch=__BNF_get();\n`
`\n`
`  state = !(isprint( ch ) && ch != '\\n' && ch != '\\'');\n`
`\n`
`  if ( ch == '\\\\' ) {\n`
`    ch = __BNF_get();\n`
`    if ( !state ) {\n`
`      state = !isprint( ch );\n`
`      if (!state) {\n`
`        __BNF_put( '\\\\' );\n`
`        __BNF_put( ch );\n`
`      }\n`
`    }\n`
`  }\n`
`  else\n`
`    if ( !state ) __BNF_put( ch );\n`
`\n`
`FUN_end\n`
`\n`
`DEFUN(o_stringchar)\n`
`FUN_begin\n`
`  int ch=__BNF_get();\n`
`\n`
`  state = !(isprint( ch ) && ch != '\\n' && ch != '` 
out( '`' )
`');\n`
`\n`
`  if ( ch == '\\\\' ) {\n`
`    ch = __BNF_get();\n`
`    if ( !state ) {\n`
`      state = !isprint( ch );\n`
`      if (!state) {\n`
`        *__BNF_output++ = '\\\\';\n`
`        *__BNF_output++ = ch;\n`
`      }\n`
`    }\n`
`  }\n`
`  else\n`
`    if ( !state ) *__BNF_output++ = ch ;\n`
`FUN_end\n`
`\n`
`DEFUN(t_stringchar)\n`
`FUN_begin\n`
`  int ch=__BNF_get();\n`
`\n`
`  state = !(isprint( ch ) && ch != '\\n' && ch != '\"');\n`
`\n`
`  if ( ch == '\\\\' ) {\n`
`    ch = __BNF_get();\n`
`    if ( !state ) {\n`
`      state = !isprint( ch );\n`
`      if (!state)\n`
`        {       __BNF_put( '\\\\' );\n`
`                __BNF_put( ch );\n`
`        }\n`
`    }\n`
`  }\n`
`  else\n`
`    if ( !state ) __BNF_put( ch );\n`
`FUN_end\n`
`\n`
`DEFUN(letter)\n`
`FUN_begin\n`
`  int ch=__BNF_get();\n`
`\n`
`  state = !(isalpha( ch ) || ch == '_');\n`
`\n`
`  if (state)\n`
`    RESTORE\n`
`  else\n`
`    __BNF_put( ch );\n`
`FUN_end\n`
`\n`
`DEFUN(digit)\n`
`FUN_begin\n`
`  int ch = __BNF_get();\n`
`\n`
`  state = !isdigit( ch );\n`
`\n`
`  if (state)\n`
`    RESTORE\n`
`  else\n`
`    __BNF_put( ch );\n`
`FUN_end\n`
`\n`
`DEFUN(special)\n`
`FUN_begin\n`
`  int ch = __BNF_get();\n`
`\n`
`  state = !isgraph( ch );\n`
`\n`
`  if (state)\n`
`    RESTORE\n`
`  else\n`
`    __BNF_put( ch );\n`
`\n`
`FUN_end\n`
`\n`
`DEFUN(control)\n`
`FUN_begin\n`
`  int ch = __BNF_get();\n`
`\n`
`  state = !iscntrl( ch );\n`
`\n`
`  if (state)\n`
`    RESTORE\n`
`  else\n`
`    __BNF_put( ch );\n`
`FUN_end\n`
`\n`
`DEFUN(character)\n`
`FUN_begin\n`
`  OR_begin\n`
`    CALL(stringchar)\n`
`  OR_1\n`
`    CALL(control)\n`
`  OR_end\n`
`FUN_end\n`
`\n`
`\n`
`DEFUN(white)\n`
`FUN_begin\n`
`\n`
`  state = !isspace( __BNF_get() );\n`
`\n`
`  if ( !state ) {\n`
`    while ( isspace( __BNF_get() ) )\n`
`        ;\n`
`    --__BNF_input;\n`
`  };\n`
`\n`
`FUN_end\n`
`\n`
`DEFUN(inc_level)\n`
`FUN_begin\n`
`        ++__BNF_level;\n`
`\n`
`        state=0;\n`
`FUN_end\n`
`\n`
`DEFUN(dec_level)\n`
`FUN_begin\n`
`        --__BNF_level;\n`
`\n`
`        state=0;\n`
`FUN_end\n`
`\n`
`DEFUN(out_indent)\n`
`FUN_begin\n`
`        unsigned i,j;\n`
`\n`
`        for (i=0; i<__BNF_level; i++ )\n`
`            if (__BNF_tabsize) {\n`
`                for(j=0;j<__BNF_tabsize;j++) __BNF_put(' ');\n`
`            }\n`
`            else\n`
`                __BNF_put('\t');\n`
`\n`
`        state=0;\n`
`FUN_end\n`
`\n`
   `\n`
   `\n`
   `int inc_rule (void)\n`
   `{\n`
   `   ++ __BNF_rulecnt;\n`
   `   return   0;\n`
   `}\n`
`\n`
`int flush( void )\n`
`{\n`
`  return __BNF_flush();\n`
`}\n`
`\n`
`/* eof */\n`

`\n`
`\n`

;


##############################################################

now_do_the_strfilio_mister = ndt_a ndt_b;

ndt_a = 
`\n`
`\n`
`\n`
`#include <stdio.h>\n`
`\n`
`/****************************************************************************************\n`
` * We have either a strings or files as input and output.\n`
` */\n`
`\n`
`int __BNF_str_io_parser(char* input,char* output,int (*syntax)());\n`
`int __BNF_fil_io_parser(FILE* input,FILE* output,int (*syntax)());\n`
`\n`
`/****************************************************************************************\n`
` * STRIO/FILIO COMMON DEFS\n`
` */\n`
`\n`
`#include <stdlib.h>\n`
`\n`
`#define BUFFER_SIZE   (4*20480)\n`
`\n`
`unsigned __BNF_err_line;\n`
`unsigned long __BNF_no_read, __BNF_no_written;\n`
`char *__BNF_input, *__BNF_output;\n`
`unsigned int __BNF_tabsize = 0;\n`
`\n`
`static int __is_file_io = 0;\n`
`\n`
`/****************************************************************************************\n`
` * FILIO\n`
` */\n`
`\n`
`\n`
`FILE *if_ptr = NULL, *of_ptr = NULL;\n`
`static char  *max___BNF_input;\n`
`static char *__BNF_input_buffer = NULL, *__BNF_output_buffer = NULL;\n`
`\n`
`\n`
`static int init(void);\n`
`static int done(void);\n`
`\n`
`int __BNF_fil_io_parser( FILE *input, FILE *output, int (*syntax)() )\n`
`{\n`
`        int retval;\n`
`\n`
;
ndt_b = 
`  __is_file_io = 1;\n`
`\n`
`                /* --- initialisation --- */\n`
`\n`
`        __BNF_level = __BNF_rulecnt = 0;\n`
`        if_ptr = input;\n`
`        of_ptr = output;\n`
`\n`
`        if ( init() ) {\n`
`                fprintf( stderr, \"Fatal: Cannot allocate enough memory.\\n\" );\n`
`                return 1;\n`
`        }\n`
`                /* --- call the syntax parser --- */\n`
`        retval = (*syntax)();\n`
`\n`
`                /* --- clean up --- */\n`
`        done();\n`
`\n`
`        return retval;\n`
`}\n`
`\n`
`int __BNF_fil_get(void)\n`
`{\n`
`  int ch;\n`
`\n`
`  if ( __BNF_input == max___BNF_input ) {\n`
`    if ( (ch = fgetc(if_ptr)) != 0 ) {\n`
`      *__BNF_input++ = ch;\n`
`      max___BNF_input++;\n`
`      __BNF_no_read++;\n`
`    }\n`
`    if ( ch == '\\n' ) __BNF_err_line++;\n`
`    return ch;\n`
`  }\n`
`  else\n`
`    return *__BNF_input++;\n`
`}\n`
`\n`
`int __BNF_fil_put(int ch)\n`
`{\n`
`  if ( __BNF_output == __BNF_output_buffer+BUFFER_SIZE ) {\n`
`    return 1;\n`
`  }\n`
`\n`
`  *__BNF_output++ = ch;\n`
`  return 0;\n`
`}\n`
`\n`
`int __BNF_fil_flush(void)\n`
`{\n`
`\n`
`  char *s = __BNF_output_buffer;\n`
`\n`
`  while ( s < __BNF_output ) {\n`
`    __BNF_no_written++;\n`
`    fputc( *s++, of_ptr );\n`
`  }\n`
`  __BNF_output = __BNF_output_buffer;\n`
`\n`
`  return 0;\n`
`}\n`
`\n`
`\n`
`static int init(void)\n`
`{\n`
`  if ( (__BNF_input_buffer = malloc( BUFFER_SIZE )) != NULL ) {\n`
`    if ( (__BNF_output_buffer = malloc( BUFFER_SIZE )) != NULL ) {\n`
`      __BNF_input = max___BNF_input = __BNF_input_buffer;\n`
`      __BNF_output = __BNF_output_buffer;\n`
`\n`
`      __BNF_no_read = 0;\n`
`      __BNF_no_written = 0;\n`
`      __BNF_err_line=1;\n`
`  return 0;\n`
`}\n`
`else\n`
`      free( __BNF_input_buffer );\n`
`  }\n`
`\n`
`  return 1;\n`
`}\n`
`\n`
`static int done(void)\n`
`{\n`
`  __BNF_flush();\n`
`\n`
`  free( __BNF_output_buffer);\n`
`  free( __BNF_input_buffer );\n`
`\n`
`  __BNF_input_buffer = 0;\n`
`  __BNF_output_buffer = 0;\n`
`\n`
`  return 0;\n`
`}\n`
`\n`
`/****************************************************************************************\n`
`* STRIO\n`
`****************************************************************************************/\n`
`\n`
`int __BNF_str_io_parser( char *input, char *output, int (*syntax)() )\n`
`{\n`
`       int retval;\n`
`       char *s;\n`
`       __is_file_io = 0;\n`
`\n`
`       /* --- initialisation --- */\n`
`       __BNF_input = max___BNF_input = __BNF_input_buffer = input;\n`
`       __BNF_output = __BNF_output_buffer = output;\n`
`       __BNF_no_read = __BNF_no_written = 0;\n`
`       __BNF_err_line = 1;\n`
`       __BNF_level = __BNF_rulecnt = 0;\n`
`\n`
`       /* --- call the syntax parser --- */\n`
`       retval = syntax();\n`
`\n`
`       /* --- count the number of output-bytes --- */\n`
`       for ( s = __BNF_output_buffer; s < __BNF_output ; s++ )\n`
`               ++ __BNF_no_written;\n`
`\n`
`       return retval;\n`
`}\n`
`\n`
`int __BNF_str_get( void )\n`
`{\n`
`       register ch;\n`
`\n`
`       if ( __BNF_input == max___BNF_input ) {\n`
`               \n`
`               if ( (ch = *max___BNF_input) != '\\0' ) {\n`
`                       ++ max___BNF_input;\n`
`                       ++ __BNF_input;\n`
`                       ++ __BNF_no_read;\n`
`                       \n`
`                       if ( ch == '\\n' ) __BNF_err_line++;\n`
`                       \n`
`                       return ch;\n`
`               }\n`
`               else\n`
`                       return EOF;\n`
`       }\n`
`       else\n`
`               return *__BNF_input++;\n`
`}\n`
`\n`
`int __BNF_str_put( int ch )\n`
`{\n`
`       *__BNF_output++ = ch;\n`
`       return 0;\n`
`}\n`
`\n`
`\n`
`int __BNF_str_flush( void )\n`
`{\n`
`       return 0;\n`
`}\n`
`\n`
`\n`
`/****************************************************************************************\n`
`* STRIO/FILIO COMMON HOOKS\n`
`****************************************************************************************/\n`
`\n`
`\n`
`#if 0\n`
`int __BNF_put(int ch)\n`
`{\n`
`       return (__is_file_io == 1) ? __BNF_fil_put(ch) : __BNF_str_put(ch);\n`
`}\n`
`#endif\n`
`int __BNF_get(void)\n`
`{\n`
`       return (__is_file_io == 1) ? __BNF_fil_get() : __BNF_str_get();\n`
`}\n`
`int __BNF_flush(void)\n`
`{\n`
`       return (__is_file_io == 1) ? __BNF_fil_flush() : __BNF_str_flush();\n`
`}\n`
`\n`
`\n`

;