%{
/* This file is in the public domain. */

#include <stdio.h>
#include "defs.h"
#include "tok.h"
#include "lex-externs.h"

static int flushing;

static int buf[256];
static int len = 0;

#define YY_INPUT(buf,res,siz) res=fsm_yyinput(buf,siz)

static int fsm_yyinput(char *buf, int siz)
{
 int c;
 int n;

 n = 0;
 for (;siz>0;siz--)
  { c = getchar();
    if (c == EOF) break;
#ifdef EBUG
    putc('_',stderr);
    putc('\b',stderr);
    putc(c,stderr);
#endif
    buf[n++] = c;
  }
 return((n>0)?n:YY_NULL);
}

%}
%option noyywrap
%start NRM ANY COPY
%%
<NRM>"$$"		{ return(tran_char=Quote); }
<NRM>$action		{ return(Action); }
<NRM>$any		{ return(tran_char=Any); }
<NRM>$anyof		{ return(tran_char=Anyof); }
<NRM>$binary		{ return(tran_char=Binary); }
<NRM>$digit		{ return(tran_char=Digit); }
<NRM>$decimal		{ return(tran_char=Decimal); }
<NRM>$eos		{ return(tran_char=Eos); }
<NRM>$exit		{ return(Exit); }
<NRM>$fail		{ return(Fail); }
<NRM>$hex		{ return(tran_char=Hex); }
<NRM>$initial		{ return(Initial); }
<NRM>$lambda		{ return(tran_char=Lambda); }
<NRM>$octal		{ return(tran_char=Octal); }
<NRM>$prefix		{ return(Prefix); }
<NRM>$state		{ return(State); }
<NRM>$symbol		{ return(tran_char=Symbol); }
<NRM>$tran		{ return(Tran); }
<NRM>$trace		{ return(Trace); }
<NRM>[a-zA-Z_][a-zA-Z0-9_]* { copy_in(&tran_string,yytext);
			      return(Ident);
			    }
<NRM>"'\\"[0-7]+"'"	{ int i;
			  sscanf(yytext,"'\\%o'",&i);
			  tran_char = i;
			  return(Char);
			}
<NRM>"'\\"."'"		{ switch(yytext[2])
			   { case 'b':
				tran_char = '\b';
				break;
			     case 'e':
				tran_char = '\033';
				break;
			     case 'f':
				tran_char = '\f';
				break;
			     case 'n':
				tran_char = '\n';
				break;
			     case 'r':
				tran_char = '\r';
				break;
			     case 't':
				tran_char = '\t';
				break;
			     default:
				tran_char = yytext[2];
				break;
			   }
			  return(Char);
			}
<NRM>"'"."'"		{ tran_char = yytext[1];
			  return(Char);
			}
<NRM>\"([^\"]*\\\")*[^\"]*\" { copy_in(&tran_string,yytext);
			       return(tran_char=String);
			     }
<NRM>" "		;
<NRM>\t			;
<NRM>"/*"([^\*]*\*[^/])*[^\*]*"*/" { register char *cp;
				     for (cp=yytext;*cp;cp++)
				      { if (*cp == '\n')
					 { line_no ++;
					 }
				      }
				   }
<NRM>.			{ return(tran_char=yytext[0]); }
<NRM>\n			{ line_no ++;
			  return(yytext[0]); }
<ANY>" "		{ if (! flushing)
			   { tran_char = ' ';
			     return(Anyof_char);
			   }
			}
<ANY>\t			{ if (! flushing)
			   { tran_char = '\t';
			     return(Anyof_char);
			   }
			}
<ANY>.			{ tran_char = yytext[0];
			  flushing = 0;
			  return(Anyof_char); }
<ANY>\n			{ line_no ++;
			  tran_char = '\n';
			  flushing = 0;
			  return('\n'); }
<ANY>\\[0-7]		{ tran_char = yytext[1]-'0';
			  flushing = 0;
			  return(Anyof_char); }
<ANY>\\[0-7][0-7]	{ tran_char = ((yytext[1]-'0') << 3) +
				       (yytext[2]-'0');
			  flushing = 0;
			  return(Anyof_char); }
<ANY>\\[0-7][0-7][0-7]	{ tran_char = ((yytext[1]-'0') << 6) +
				      ((yytext[2]-'0') << 3) +
				       (yytext[3]-'0');
			  flushing = 0;
			  return(Anyof_char); }
<ANY>\\.		{ tran_char = yytext[1];
			  flushing = 0;
			  switch (tran_char)
			   { case 'a':
				tran_char = '\a';
				break;
			     case 'b':
				tran_char = '\b';
				break;
			     case 'e':
				tran_char = '\033';
				break;
			     case 'f':
				tran_char = '\f';
				break;
			     case 'n':
				tran_char = '\n';
				break;
			     case 'r':
				tran_char = '\r';
				break;
			     case 't':
				tran_char = '\t';
				break;
			   }
			  return(Anyof_char); }
<COPY>.*\n		{ line_no ++;
			  ECHO;
			  BEGIN NRM;
			  return(tran_char='\n'); }
%%
void set_lex_nrm(void)
{
 BEGIN NRM;
}

void set_lex_flush(void)
{
 BEGIN ANY;
 flushing = 1;
}

int lex_input(void)
{
 return(input());
}

set_lex_copy()
{
 BEGIN COPY;
}