%{
/*
                                   L E X E R
*/

#include "iccomp.h"
#include "parser.h"

#ifndef fileno
int fileno(FILE *stream);
#endif

#undef  YY_INPUT
#define YY_INPUT(buf,result,max_size) result = yylex_input(buf, max_size);

#ifdef unput
    /* If this stops working, have a look at lexer2.c to see what was   */
    /* changed in the flex-implementation                               */

    static void yyunput (int c,char *buf_ptr  );
    void (*unusedUnput)(int c,char *buf_ptr) = &yyunput;
#endif

%}

%x str

%%

<str>[^"]   |
<str>\\.                {  
                            lexstring = xstrcat(lexstring, yytext);
                        }
<str>\"                 {
                            BEGIN 0;
                            if (!stresc(lexstring))
                                semantic("illegal escape sequence in string");
                            return(STRING);
                        }
[ \t]                   ;
\n                      yylineno++;
^#.*                    {
                            change_file(yytext + 1);
                        }
\"                      {
                            lexstring[0] = 0; BEGIN str;
                        }
'.'                     {
                            sprintf(lexstring, "%d%c", yytext[1], 0);
                            return(NUMBER);
                        }

arghead                 {
                            yylval.type = f_arg_head;
                            return(ARG_HEAD);
                        }
argtail                 {
                            yylval.type = f_arg_tail;
                            return(ARG_TAIL);
                        }
ascii                   {                   /* ascii_int may become ascii_str */
                            yylval.type = f_ascii_int;
                            return(ASCII);
                        }
break                   {
                            return(BREAK);
                        }
chdir                   {
                            yylval.type = f_chdir;
                            return(CHDIR);
                        }
cmdtail                 {
                            yylval.type = f_cmd_tail;
                            return(CMD_TAIL);
                        }
cmdhead                 {
                            yylval.type = f_cmd_head;
                            return(CMD_HEAD);
                        }
change_base             {
                            yylval.type = f_c_base;
                            return(C_BASE);
                        }
change_ext              {
                            yylval.type = f_c_ext;
                            return(C_EXT);
                        }
change_path             {
                            yylval.type = f_c_path;
                            return(C_PATH);
                        }
fprintf                 {
                            yylval.type = f_fprintf;
                            return(FPRINTF);
                        }
get_base                {
                            yylval.type = f_g_base;
                            return(G_BASE);
                        }
get_ext                 {
                            yylval.type = f_g_ext;
                            return(G_EXT);
                        }
get_path                {
                            yylval.type = f_g_path;
                            return(G_PATH);
                        }
getch                   {
                            yylval.type = f_getch;
                            return(GETCH);
                        }
getpid                  {
                            yylval.type = f_getpid;
                            return(GETPID);
                        }
gets                    {
                            yylval.type = f_gets;
                            return(GETS);
                        }
echo                    {
                            yylval.type = f_echo;
                            return(M_ECHO);
                        }
element                 {
                            yylval.type = f_element;
                            return(ELEMENT);
                        }
else                    {
                            return(ELSE);
                        }
exec                    {
                            yylval.type = f_exec;
                            return(EXEC);
                        }
execute                 {
                            yylval.type = f_execute;
                            return(EXECUTE);
                        }
exists                  {
                            yylval.type = f_exists;
                            return(EXISTS);
                        }
exit                    {
                            yylval.type = op_exit;
                            return(EXIT);
                        }
fgets                   {
                            yylval.type = f_fgets;
                            return (FGETS);
                        }
for                     {
                            return(FOR);
                        }
getenv                  {
                            yylval.type = f_getenv;
                            return GETENV;
                        }
if                      {
                            return(IF);
                        }
void                    {
                            yylval.type = 0;    /* 0 == void */
                            return (VOID);
                        }
int                     {
                            yylval.type = e_int;
                            return(INT);
                        }
list                    {
                            yylval.type = e_list;
                            return(LIST);
                        }
makelist                {
                            yylval.type = f_makelist;
                            return(MAKELIST);
                        }
older                   {
                            yylval.type = op_older;
                            return(OLDER);
                        }
printf                  {
                            yylval.type = f_printf;
                            return(PRINTF);
                        }
putenv                  {
                            yylval.type = f_putenv;
                            return (PUTENV);
                        }
return                  {
                            yylval.type = op_ret;
                            return(RETURN);
                        }
sizeof          |
sizeoflist              {
                            yylval.type = f_sizeoflist;
                            return(SIZEOFLIST);
                        }
stat                    {
                            yylval.type = f_stat;
                            return (STAT);
                        }
string                  {
                            yylval.type = e_str;
                            return(STRINGTYPE);
                        }
strlen                  {
                            yylval.type = f_strlen;
                            return(STRLEN);
                        }
strlwr                  {
                            yylval.type = f_strlwr;
                            return(STRLWR);
                        }
strupr                  {
                            yylval.type = f_strupr;
                            return(STRUPR);
                        }
strtok                  {
                            yylval.type = f_fields;
                            return(FIELDS);
                        }
strfind                 {
                            yylval.type = f_strfind;
                            return STRFIND;
                        }
substr                  {
                            yylval.type = f_substr;
                            return SUBSTR;
                        }
system                  {
                            yylval.type = f_system;
                            return(SYSTEM);
                        }
while                   {
                            return(WHILE);
                        }
newer   |
younger                 {
                            yylval.type = op_younger;
                            return(YOUNGER);
                        }
"++"                    {
                            return(INC);
                        }
"--"                    {
                            return(DEC);
                        }
"/="                    {
                            return(DIV_IS);
                        }
"-="                    {
                            return(MINUS_IS);
                        }
"*="                    {
                            return(MUL_IS);
                        }
"%="                    {
                            return(MOD_IS);
                        }
"+="                    {
                            return(PLUS_IS);
                        }
"&="                    {
                            return(AND_IS);
                        }
"|="                    {
                            return(OR_IS);
                        }
"^="                    {
                            return(XOR_IS);
                        }
"<<="                   {
                            return(SHL_IS);
                        }
">>="                   {
                            return(SHR_IS);
                        }
"||"                    {
                            return(OR);
                        }
"&&"                    {
                            return(AND);
                        }
"=="                    {
                            return(EQUAL);
                        }
"!="                    {
                            return(NOT_EQUAL);
                        }
"<="                    {
                            return(SMALLER_EQUAL);
                        }
">="                    {
                            return(GREATER_EQUAL);
                        }
">>"                    {
                            return(SHR);
                        }
"<<"                    {
                            return(SHL);
                        }
0x[0-9]+                {
                            unsigned value;
                            sscanf(yytext + 2, "%x", &value);
                            sprintf(lexstring, "%d", (int)value);
                            return(NUMBER);
                        }
[0-9]+                  {
                            lexstring = xstrdup(yytext);
                            return(NUMBER);
                        }
OFF         |
P_CHECK                 {                   /* P_CHECK: value in icm.h */
                            lexstring = xstrdup("0");
                            return(NUMBER);
                        }
S_IFDIR     |
O_FILE      |                               /* O_FILE: value in icm.h */
ON                      {
                            lexstring = xstrdup("1");
                            return(NUMBER);
                        }
S_IFCHR     |
P_NOCHECK   |
O_DIR                   {                   /* O_DIR: value in icm.h */
                            lexstring = xstrdup("2");
                            return(NUMBER);
                        }
S_IFREG     |
O_SUBDIR                {                   /* O_SUBDIR: value in icm.h */
                            lexstring = xstrdup("4");
                            return(NUMBER);
                        }
S_IREAD     |
O_ALL                   {                   /* O_ALL: value in icm.h */
                            lexstring = xstrdup("8");
                            return(NUMBER);
                        }
S_IWRITE                {
                            lexstring = xstrdup("16");
                            return(NUMBER);
                        }
S_IEXEC                 {
                            lexstring = xstrdup("32");
                            return(NUMBER);
                        }
[_A-Za-z][A-Za-z0-9_]*  {
                            lexstring = xstrdup(yytext);
                            return(IDENTIFIER);
                        }
.                       return yytext[0];
