"Compiling principle" lex lexical analyzer

first, the purpose of the experiment

A lexical analyzer is designed and implemented to understand the principle of compiler principle morphemes Method Analyzer.

Ii. contents of the experiment

By designing and implementing a lexical analyzer in your familiar language, this parser outputs the parsed program segments in the required format.

Request an analysis of the program fragment:

[Delphi] View plain copy const a=10;   var b,c;     Procedure P;     Begin C:=b+a;      End    Begin read (b);     While b#0 does begin call P;writeln (2*C); read (b); End end.
The program fragment is stored in the example.txt.

third, the experimental steps

1, the classification of various words in Pl\0 grammar:

(1) Reserved words: const, VAR, procedure, begin, end, if, then, while, do, read, call, write, Writeln

(2) Constant: consists of 0-----9 of these numbers

(3) Identifier: A string of letters and numbers that begin with a letter

(4) Operator: +,-,*,/,:=,>=,<=,#

(5) Delimiter:, 、.、 (,),;

2. correspond all kinds of words to Lex:

(1) Reserved words:

Reservedword [Const|var|procedure|begin|end|if|then|while|do|read|call|write|writeln], because it is not case-sensitive in Lex, the reserved word is written as:

Reservedword [cc][oo][nn][ss][tt]| [VV] [AA] [rr]| [PP] [RR] [OO] [CC] [EE] [DD] [UU] [RR] [ee]|

[BB] [EE] [GG] [II] [nn]| [EE] [NN] [dd]| [II] [ff]| [TT] [HH] [EE] [nn]| [WW] [HH] [II]

[LL] [ee]| [DD] [oo]| [RR] [EE] [AA] [dd]| [CC] [AA] [LL] [ll]| [WW] [RR] [II] [TT] [EE]

[WW] [RR] [II] [TT] [EE] [LL] [NN]

(2) Constant:

Constant ([0-9]) +/*0---9 These numbers can be repeated */

(3) Identifier:

Identfier [A-za-z] ([a-za-z][0-9]) *

(4) Operator:

Operator \+|-|\*|\/|:=|>=|<=|#|=/* in Lex, operators with special meanings are added escape characters \, such as +, * and *,/

(5) Delimiter:

delimiter [, \.;\ (\)]

3. The lexical parser for the pl/0 language requires skipping delimiters (such as spaces, carriage returns, tab characters), and the corresponding Lex definition as:

Delim ["" \n\t]

whitespace{delim}+

4. make some rules for Lex:

{Reservedword}   {count++;p rintf ("\t%d\t (1, '%s ') \ n", Count,yytext);} /* Set rules for reserved words, output settings */

{operator} {count++;p rintf ("\t%d\t (2, '%s ') \ n", Count,yytext);}

{delimiter} {count++;p rintf ("\t%d\t (3, '%s ') \ n", Count,yytext);}

{constant} {count++;p rintf ("\t%d\t (4, '%s ') \ n", Count,yytext);}

{Identfier} {count++;p rintf ("\t%d\t (5, '%s ') \ n", Count,yytext);}

{whitespace} {/* do nothing*/}/* Encounter spaces, do nothing */

5, write sub-program:

Voidmain ()

{

printf ("Lexical Analyzer output type description: \ n");

printf ("1: reserved word \ n");

printf ("2: operator \ n");

printf ("3: Delimiter \ n");

printf ("4: Constant \ n");

printf ("5: identifier \ n");

printf ("\ n");

Yyin=fopen ("Example.txt", "R");

Yylex (); /* Start the analysis*/

Fclose (Yyin);

System ("pause");/* Pause */

}

Intyywrap ()

{

return 1;

}

When Lex finishes reading the input file, it calls the function Yywrap. Returns 0 if 1 indicates that the program's work has been completed.

Iv. Source code for Implementation [CPP]   View plain copy%{       # include <stdio.h>        #include  <stdlib.h>         int count = 0;  %}       Delim  [" " \n\t]    whitespace {delim}+    operator \+|-|\*|\/|:=| >=|<=|#|=   reservedword [cc][oo][nn][ss][tt]| [VV] [AA] [rr]| [PP] [RR] [OO] [CC] [EE] [DD] [UU] [RR] [ee]| [BB] [EE] [GG] [II] [nn]| [EE] [NN] [dd]| [II] [ff]| [TT] [HH] [EE] [nn]| [WW] [HH] [II] [LL] [ee]| [DD] [oo]| [RR] [EE] [AA] [dd]| [CC] [AA] [LL] [ll]| [WW] [RR] [II] [TT] [ee]| [WW] [RR] [II] [TT] [EE] [LL] [nn]