%{
/* genh.l -- lex file for genh */

#include <stdio.h>
#include <math.h>
#include <string.h>
#include "headers.h"

#undef  YYLMAX
#define YYLMAX 1024

static KEYENTRY keywords[] = {
  { CONST   ,      "const" },
  { LONG ,          "long" },
  { SHORT  ,        "short" },
  { STRUCT   ,      "struct" },
};

int nlflag;    /* if TRUE, pass back NEWLINE tokens, else skip */

int yylook();
int yyback(int*,int);
int keycmp(char *s,KEYENTRY* kptr);
int read(int,char*,int);
void exit(int);
int yywrap();

#undef  output
#define output(c) /* bit bucket */
%}

ws             [ \t]
newline        [\n]
letter         [_a-zA-Z]
digit          [0-9]
datsign        "@@"
atsign         "@"
digits         {digit}+
id             {letter}({letter}|{digit})*(({atsign}|{datsign}){letter}({letter}|{digit})*)?
fraction       [\.]{digits}
exp            [E]([+\-]?){digits}
real           {digits}{fraction}({exp})?
integer        {digits}
indirection    [*&]
indirections   {indirection}+
directive      [\#]{letter}*
cppcomment     "//"
override       "//++"
defaults       "defaults"
nonvirtual     "non-virtual"
private        "private"
protected      "protected"
public         "public"
pure           "pure"
virtual        "virtual"
inline         "inline"
friend         "friend"
static         "static"
terminal_sets "*terminal_sets*"

%%
[=:~]                   { return PRODUCTIONTYPE; }
[\.]                    { return DOT; }

"/"                     { 
                          int ch;

                          if ((ch = input()) == '*')
                             return BEGINCOMMENT;
                          else
                             unput(ch);
                          return '/';
                        }

"::"                    { return SCOPERESOLUTION; }
[\,]                    { return COMMA; }
[{]                     { return LBRACE; }
[}]                     { return RBRACE; }
[(]                     { return LPAREN; }
[)]                     { return RPAREN; }
[%]                     { return PERCENT; }
[\"]                    { return DQUOTE; }
[\']                    { return QUOTE; }
[\\]                    { return BACKSLASH; }
[\[]                    { return LSQUARE; }
[\]]                    { return RSQUARE; }

{indirections}          { 
                          int ch;

                          if (*yytext == '*') {
                             if ((ch = input()) == '/')
			       return ENDCOMMENT;
			     else
			       unput(ch);

			  }
                          return INDIRECTIONS;
			}

{real}                  { return NUMBER; }
{integer}               { return NUMBER; }

{directive}             { return DIRECTIVE; }
{override}              { return OVERRIDE; }
{defaults}              { return DEFAULTS; }
{nonvirtual}            { return NONVIRTUAL; }
{private}               { return PRIVATE; }
{protected}             { return PROTECTED; }
{public}                { return PUBLIC; }
{pure}                  { return PURE; }
{virtual}               { return VIRTUAL; }
{inline}                { return INLINE; }
{friend}                { return FRIEND; }
{static}                { return STATIC; }

{id}                    { KEYENTRY *keyptr;

                          keyptr = (KEYENTRY *)bsearch(yytext,keywords,
                                                       sizeray(keywords),
						       sizeof(keywords[0]),
						       (int (*)(void*,void*))
						       keycmp);

                          if (keyptr == NULL) { /* not a keyword */
			    return IDENTIFIER;
			  }
			  else
			    return keyptr->keyval;
                        }

{newline}               { return (nlflag) ? NEWLINE : yylex(); }

{ws}+                   { return WS; }

{cppcomment}            { return CPPCOMMENT; }

[;]                    { return SEMI; }

{terminal_sets}             {return TERMINAL_SETS;}

.			{ return ANYCHAR; }

%%

int keycmp(char *s,KEYENTRY* kptr) {
  return strcmp(s,kptr->text);
}