Running lex and yacc on Linux systems

Student accounts

An account has been created for all CS315 students on knuth.ug.bcc.bilkent.edu.tr. As soon as possible, you should login into your account with your initial password and change it by using the passwd command. You should be able to use any ssh client from Windows or Linux machines available in student labs.

Editing files

emacs and vi editors are available on knuth and can be used to edit your lex and yacc source files. If you have your own Linux machine or another environment within which you have lex and yacc installed, you can use your favorite text editor to work on your project.

In some version of linux (e.g., Mandrake) lex is called flex.

Compiling Standalone lex programs

Normally, lex and yacc are used together. However, it is possible to use only lex and create programs that just do lexical analysis. There are two ways of doing this:

If you do not need to include your own custom main() in your code, put the following line at the beginning of your lex specification file:
```
    %option main
  
```
This makes sure that a default main() and yywrap() are created for you.
Suppose you have a lex specification file called example.l. You can use the following commands to obtain an executable and run it:
```
    
    lex example.l
    gcc -o example lex.yy.c
    ./example
    
  
```
If you want to define a more complex main function, you will also need to define yywrap() in your code. In the simplest case, your lex specification file should look like the following:
```
    
    ...definitions...
    %%
    ...rules...
    %%
    ...additional user code...

    main() {
      yylex();
    }
    int yywrap() { return 1; }
    
  
```
You can compile your specification file with the same method as before.

Using lex and yacc together

Once again, there are a number of different ways you can build your lex and yacc specification files with a varying degree of customization. Here are a few notes:

Do not include %option main in your lex specification file. This will cause a default main to be created only for lex and the yacc source will be ignored.
Since you will not be using the default routines provided by %option main, you have to include the definition of yywrap() in your lex specification file. A simple example would look like this:
```
    
    ...definitions...
    %%
    ...rules...
    %%
    ...additional user code...

    int yywrap() { return 1; }
    
  
```
Since on some Linux systems, default libraries are not provided for yacc, we recommend that you define your own main() and yyerror() functions in your yacc specification file. So, the following would be a simple yacc specification file which does this:
```
    
    ...declarations...
    %%
    ...rules...
    %%
    ...additional user code...

    main() {
      return yyparse();
    }
    int yyerror( char *s ) { fprintf( stderr, "%s\n", s); }
    
  
```
For large projects, you could compile lex.yy.c and y.tab.c and link them afterwards. However, for simple cases (and most likely your projects), you could directly include lex.yy.c in the user code section of your yacc specification. Your yacc specification would then look something like the following:
```
    
    ...declarations...
    %%
    ...rules...
    %%
    #include "lex.yy.c"

    ...additional user code...

    main() {
      return yyparse();
    }
    int yyerror( char *s ) { fprintf( stderr, "%s\n", s); }
    
  
```
These custom definitions eliminate the need to link any external libraries. So, assuming your have the specification files example.l and example.y, the following commands would get you a nice executable which hopefully does what you want:
```
    
      lex example.l
      yacc example.y
      gcc -o example y.tab.c
      ./example
    
  
```