YACC=bison
YFLAGS=-t
CFLAGS=-g
LEX=flex

.SUFFIXES: _lex.c _yacc.c


.l_lex.c :
    $(LEX) $(LFLAGS) -t $< > $@

%.c :   %.y
    # Cancel this rule, and create our own

.y_yacc.c :
    $(YACC) $(YFLAGS) -d $< -o $@

all:    olmenu

olmenu_lex_test.c : olmenu.l olmenu_tokens.y
    $(YACC) $(YFLAGS) -d olmenu_tokens.y
    mv olmenu_tokens.tab.h olmenu_yacc.h
    $(LEX) -d -t olmenu.l > $@

olmenu_lex_test :   olmenu_lex_test.c
    $(CC) $(CFLAGS) -DTEST_LEX $< -o $@ -ll

olmenu-proto1_yacc.c    :   olmenu-proto1.y
    $(YACC) $(YFLAGS) -d $< -o $@
    mv olmenu-proto1_yacc.h olmenu_yacc.h

olmenu-proto1   :   olmenu-proto1_yacc.o olmenu_lex.o
    $(CC) -o $@ olmenu-proto1_yacc.o olmenu_lex.o

olmenu-proto2_yacc.c    :   olmenu-proto2.y
    $(YACC) $(YFLAGS) -d $< -o $@
    mv olmenu-proto2_yacc.h olmenu_yacc.h

olmenu-proto2   :   olmenu-proto2_yacc.o olmenu_lex.o
    $(CC) -o $@ olmenu-proto2_yacc.o olmenu_lex.o

olmenu  :   olmenu_yacc.o olmenu_lex.o dtwmrc.o
    $(CC) -o $@ olmenu_yacc.o olmenu_lex.o dtwmrc.o

olmenu_yacc.o   :   olmenu_yacc.c olmenu.h

olmenu_lex.o    :   olmenu_lex.c olmenu_yacc.h

dtwmrc.o    :   dtwmrc.c olmenu.h olmenu_yacc.h

clean   :
    rm -f *_yacc.[ch] *_lex.c *.o *.tab.[ch] *_yacc.output olmenu_lex_test.c

```

when invoking ```make olmenu-proto1```, it prints:
```
bison -t  -d olmenu-proto1.y -o olmenu-proto1_yacc.c
mv olmenu-proto1_yacc.h olmenu_yacc.h
cc -g   -c -o olmenu-proto1_yacc.o olmenu-proto1_yacc.c
olmenu-proto1.y: In function ‘main’:
olmenu-proto1.y:154:25: warning: incompatible implicit declaration of built-in function ‘exit’ [enabled by default]
                         exit(1);
                         ^
flex  -t olmenu.l > olmenu_lex.c
cc -g   -c -o olmenu_lex.o olmenu_lex.c
olmenu.l: In function ‘yylex’:
olmenu.l:109:8: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 <ENV>[^$]+   return((int)yytext);
        ^
olmenu.l:119:27: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
       if (s!=NULL) return((int)s);
                           ^
olmenu.l:125:27: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
       if (s!=NULL) return((int)s);
                           ^
olmenu.l: In function ‘expand_env’:
olmenu.l:185:20: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
   seglen = strlen(segment);
                    ^
cc -o olmenu-proto1 olmenu-proto1_yacc.o olmenu_lex.o

/*olmenu.l*/
%{
    #include "olmenu_yacc.h"
    #include <math.h>
    #include <string.h>

#ifndef YYLTYPE_IS_DECLARED
    typedef struct { int first_line; } yyltype;
    #define YYLTYPE yyltype
#endif

#ifdef TEST_LEX
    YYSTYPE yylval;
    YYLTYPE yylloc;
#else
    extern YYLTYPE yylloc;
    #define YY_USER_INIT yylloc.first_line=1;
#endif
    static char rcsid[] = "$Id: olmenu.l,v 1.1.1.1 1999/09/26 12:34:39 mib Exp $";
%}
%x CMD
%s ACT
%x ENV ENV1 ENV2
ID  ([A-Za-z_$/.0-9-]+)
QSTR    ("[^n"]*")
%%
BACK_SELN               return(BACK_SELN);
COLUMNS                 return(COLUMNS);
DEFAULT                 return(DEFAULT);
DIRMENU                 return(DIRMENU);
END                     return(END);
EXIT                    return(EXIT);
EXIT_NO_CONFIRM         return(EXIT_NO_CONFIRM);
FLIPDRAG                return(FLIPDRAG);
FLIPFOCUS               return(FLIPFOCUS);
FULL_RESTORE_SIZE_SELN  return(FULL_RESTORE_SIZE_SELN);
INCLUDE                 return(INCLUDE);
MENU                    return(MENU);
MOVE_DESKTOP            return(MOVE_DESKTOP);
NOP                     return(NOP);
OPEN_CLOSE_SELN         return(OPEN_CLOSE_SELN);
QUIT_SELN               return(QUIT_SELN);
PIN                     return(PIN);
PROPERTIES              return(PROPERTIES);
REFRESH                 return(REFRESH);
REREAD_MENU_FILE        return(REREAD_MENU_FILE);
RESTART                 return(RESTART);
SAVE_WORKSPACE          return(SAVE_WORKSPACE);
SEPARATOR               return(SEPARATOR);
START_DSDM              return(START_DSDM);
STICK_UNSTICK_SELN      return(STICK_UNSTICK_SELN);
STOP_DSDM               return(STOP_DSDM);
TITLE                   return(TITLE);
WINMENU                 return(WINMENU);
WMEXIT                  return(WMEXIT);
[0-9]+              {
                        yylval.num = atoi(yytext);
                        return(INT);
                    }

<ACT>({ID}|{QSTR})+ {
                        BEGIN CMD;
                        yymore();
                    }

({ID}|{QSTR})+      {
                        BEGIN ACT;
                        yylval.str = strdup(yytext);
                        return(LABEL);  /* Label, with quotes */
                    }

<CMD>\n           {
                        yylloc.first_line++;
                        yymore();
                    }

<CMD>n             {
                        yylval.str = strdup(yytext);
                        yylval.str[yyleng-1] = '';
                        yyless(yyleng-1);
                        BEGIN 0;
                        return(EXEC);
                    }

<CMD>.$             {
                        yylval.str = strdup(yytext);
                        BEGIN 0;
                        return(EXEC);
                    }

<CMD>.              yymore();

"<"                 return(*yytext);

">"                 { BEGIN ACT; return(*yytext); }

#.*                 ;

" "                 |

t                  ;

n                  { yylloc.first_line++; BEGIN 0; return(*yytext); }

.                   {
                        BEGIN CMD;
                        yymore();
                    }

<ENV>[^$]+          return((int)yytext);

<ENV>"$"/[A-Za-z0-9_]   BEGIN ENV1;

<ENV>"${"               BEGIN ENV2;

<ENV1>[A-Za-z0-9_]+ {
                        char *s;
                        s = getenv(yytext);
                        BEGIN ENV;
                        if (s!=NULL) return((int)s);
                    }

<ENV2>[^}]+         {
                        char *s;
                        s = getenv(yytext);
                        if (s!=NULL) return((int)s);
                    }

<ENV2>"}"           BEGIN ENV;

<ENV,ENV1,ENV2>.|n { BEGIN ENV; yymore(); }

%%

/* This lexer is nice and simple, but it does have a few
   limitations:
    (a) You cannot use any keywords as labels, eg:
        EXIT    EXIT
        would fail, though
        "EXIT"  EXIT
        is valid
    (b) A command consisting only of digits will cause a
        syntax error. Again, quoting will help.
   The 1st rule that will be matched should be
   one which returns LABEL. This activates the
   state ACT.
   Next, we expect an "action": one or more keywords, or an
   arbitrary command string, or both.
   We scan for keywords, but if we find something else,
   we assume it is a command, and go into the CMD state.
   Since CMD is exclusive, we build up the rest of the
   string, one char at a time.

   The lexer is designed to be fairly flexible, and will
   treat, say:
    My" "Menu
   as a valid, single label (without processing the quotes).

   One of the more subtle points of the lex-specification is the
   handling of INT. It relies on Lex's "first, best match" rule.
   It appears BEFORE the definitions of {ID}, so it RELIES on the
   fact that these definitions do NOT include spaces or "#",
   or anything that would make them read more than a single integer.
   (The same thing applies for the keywords).
   It is part of the reason for reading the rest of EXEC string using yymore()
   The other reason for using yymore() is that it lets us pass the
   command-string as a single token (EXEC), and so we don't have to
   reassemble the command-string within the parser from several smaller
   tokens.
*/

char *expand_env(char *src) {
    YY_BUFFER_STATE yybuff_env;
    YY_BUFFER_STATE yybuff_old;
    char *segment, *result, *bigger;
    int  size, seglen, reslen;
    size = strlen(src) + 80;
    result=(char *)malloc(size);
    *result='';
    reslen = 0;
    BEGIN ENV;
    yybuff_old = YY_CURRENT_BUFFER;
    yybuff_env = yy_scan_string(src);
    yy_switch_to_buffer(yybuff_env);
    while(( segment = (char*)yylex() )) {
        seglen = strlen(segment);
        if( size <= reslen + seglen ) {
            size = reslen + seglen + 1;
            bigger = (char *)malloc(size);
            strcpy(bigger,result);
            free(result);
            result=bigger;
        }
        strcpy(result+reslen,segment);
        reslen += seglen;
    }
    yy_switch_to_buffer(yybuff_old);
    yy_delete_buffer(yybuff_env);
    BEGIN 0;
    return(result);
}