Server for Information Technologies ������ ��������������
������� �������������� ����������
(095) 932-9212, 932-9213, 939-0783
E-mail: [email protected]
������ �������� ����(!) ������������� ���������� CIT Forum CD-ROM

FLEX(1)

���
flex,lex - ����������� ����������

���������

  flex [-bcdfhilnpstvwBFILTV78+ -C[aefFmr] -Pprefix -Sskele-
       ton] [filename ...]

��������
flex(1) - ��� ��������� ��������, ��������������� ��� ����������� ��������� ���������� ������� ������. �� ��������� ���������-��������������� ������������ �� ������� ������ � ��������� ��������� �� ����� ��, ������� �������� � ����������� �����������. ���������� ��������� ������������ ������������� � �������� ������������, ���������� ��������� lex. ������� lex ���������� ��� ��������� � ��������� ������� ������ �� ����� � ������������ � ����. �� �������� ����� ������� ����������� ��������� ��������, ������������� �������������. �������� ���� lex ���������� ���������� ��������� � ��������� ��������. �� ���� ����, ��� ��������� ���������� �� ����� ���������, ������������ lex, ��������������� �������� �������� �� ����������.

������������ ������ ���������� ��������� ��������, ����������� ��� �������������� ��� �������, ������� ����, ���������� ������� ������������. ���������, ������������ ���������, ����������� �� ���������� �������� ������������ �� ����� ��. lex - ��� �� ������ ����, � ������ ���������, �������������� ����� �����������, ������� ��������� ����������� ����� ��.

lex ���������� ��������� � ������� ������������ (���������� � ���� ����� ����������) � ��������� �� ����� ��, ������� �������� yylex. ��������� yylex ���������� ��������� �� ������� ������ (���������� � ���� ����� ��������) � ������������ ����������� �������� ��� ������� ���������, ��� ������ ��� ����������.

���������� ���������, ��������� �� ������������ ����� ����� ��� ������� � ����� ��������� � ����� �����. ��� ����� ��������� ������ ��������� ������:

   %%
   [\t]+$;

��������� �������� �������������� %%, ���������� ������ ��������� � ���� �������. ��� ������� �������� ���������� ���������, ������� �������� ���� ��� ����� ����������� �������� ��� ������ ��������� (��� ����������� ������� \t, � ������������ � ��������� ����� ��) �� ����� ������. ������ ��������� �� �������� ����� ����� ��������� ��� �������, + ���������� ���� ��� ��������� ���������� �������, � ���� $ ��������� �� ����� ������. ������� �������� �� ������������, ������� ���������, ��������� lex, ����� ������ ������������ ��� �������. ��� ��������� ����� ������������. ����� ������������� ����� ������� �������� � ������ ��������� � ������������ ������, �������� ��� ���� �������:

   %%
   [\t]+$;
   [\t]+ printf("");

���������, ��������� �� ����� ���������, ��������� ����� ��� �������: ������������ ��������� ������ �������� � ������ ��������� � ���������, ������� �� ���� ����� ������, ����� ��������� ��������, ������������ ��������.

���������� ��������� lex
���������� ��������� ���������� ����� �����, ������� ������ ���� ������������. ��� �������� ��������� ������� (��������������� �������� � ������������ �������) � ����� ���������� ������� (����������� �� ����������, �������� � ������ �����������). ����� �������� � ����� ������ �������� ���������� ���������. ����� �������, ���������� ���������:

   integer
��������� �������� ������� integer, ��� �� ��� �� ���������, � ���������
   a57D
���� �������� ������� a57D. ���������� ��������� ����� ����������:
   " \ [] ^ - ? . * + I () $ / {} % <>

���� �����-���� �� ���� ������ ������������ ��������, �� ��� ���������� �������� ����� ������ (\). ������ ������ ���������� ��������� ("). �������� ������� ��������� �� ��, ��� ���, ������������ ����� ����� ����������� ���������, �������������� ��� ������� ������. ����� �������

   xyz"++"

��������� ���������� ������� xyz++, ��� �� ��� �� �����������. ���������� ����� ���������� ������� ����� ��������� � �������. ���������, �� ������� �������� ������� ��������� ������. ���������

   "xyz++"

������������ �����������. ����� �������, �������� � ������� ������ �� ���������-�������� ������, ������������ ��� ��������� ������, �� ������������ �� ������������� ������� ������ ������� ������ ����������.

���� ��������� ����� ����� ���� ������������ � ��������� ������, ���� ����� ��� ��������� �������� ����� ����� (\):

   xyz\+\+

��� ����� ����������� ���������� �������������� ���� ���������. �������� ���������� � ������� ����� ���� ����������� ����� ��� ����, ����� �������� � ��������� ������. ������ ������� � ����� ��������� ����������� �������. ����� ������, �� ����������� � ������, ������ ������� � �������. �� ���������� ��������� ������� ������ � �������� ����� ������ (\):

   \n  ���� ����� ������
   \t  ���� ���������
   \b  ������� �� ���� ���� ����� � ��� ���������
   \\  �������� ����� �����

��������� ����� ����� ������ � ���������� ���������, ���� ������������ \n. �� ��������� �������� ������������� ������ ��������� � ��������. �������, ��� ����� ������ ������ �������� ���������. ���������� �� ����� ���������� ����� ���������, �������, ����� ����� ������ � ����� ����������, ������������� ����.

����� lex
�������������� �������� ��������� lex �������������� � ��� ������. ������� �������� ��������� ������������� � ������ �� ������������� ����� ����������������. ����� ��������� (������ � �������������� ������������ ����������� lex) ������������� � �����������. ��������� ��������� ��������� � ����� � ������ lex. yy.c. ���������� �����/������ ������������ � ������� ����������� ���������� ��. ������ � ���������� �������������� � ������� ����� �������� -ll. ��� ������ ������������ ������ ������:

   lex source
   cc lex.yy.c -ll

���������� ��������� ���������� � ���� a.out ��� ������������ �������������. ��� ��������� lex ������ � yacc, ������� � ������� "lex � yacc" ���� ����� � � ����� 6 "YACC: ���������� ������������". ���� ������������ �����-������ lex �� ��������� ���������� ����������� ���������� ��, ������������ lex ��������� ����� �� ������. ���� ���� ����������� �������� input(), output(), unput(), ���������� ����� �� ��������������.

�������� ������� ��������
������ �������� �������� � ������� ���������� ������ [ � ]. �����������

   [abc]

�������� ���� �� �������� a, b ��� c. ������ ���������� ������ ����������� �������� ���������� ������������. ������ ��� ����� ��������������� ��� �����������: �������� ����� ����� (\), ���� (-) � ������ (^). ������ ���� ������ ������������. ��������:

   [a-z0-9<>_]

������ ����� ��������, ���������� ��� �������� �����, �����, ������� ������ � ���� �������������. ������������ ����� ���������� � ����� �������.

������������� ���� ����� ������ ��������, �� ���������� ������������ ���������� �������, �������� ������� ��� �������, ������ �� ���������� �� ���������� � �������� ��������������� ���������. ���� ���������� �������� ���� � ����� ��������, �� ��� ������ ���� ������ ��� ���������. ����� �������:

   [-+0-9]

��������� ��� ����� � ����� ���� � �����. ���� ��������� (^) ������ ���������� � ������ ������� ����� ����� ������. �� ��������� �� ��, ��� �������������� ������ ������������������� � ������ �������� ����������. ����� �������:

   [^abc]

��������� ��� �������, ����� a,b,c, ������� ��� ����������� � ����������� �����, �

   [^a-zA-Z]

��� ����� ������, �� ���������� ������. ����� ����� (\) ������������ �������� ������ ������������ �������� ������ ������ ��������, ������������ � ������. ����� �������, ������� ����� ���� ������� ����������, ���� ����� ���� ������� ����� �����.

�������� ������������� �������
����� (.) ���������� ����� ���� ��������, ����� ������� ����� ������. �������� ������� � ������������ �������, �� ��� ��������� ����������� ���������. ��������:

   [\40-\176]

����������� ��� ���������� ������� � ���� ASCII, � ������������� 40 (������) �� ������������� 176 (������).

�������� �������������� ���������
�������� ������� (?) ��������� �� �������������� ������� ���������. ����� �������

   ab?c

��������� ac ��� abc. �������, ��� �������� ��������� ����� ������� � ������ ������ ���������� �� ��� �������� � ��������� ����������.

�������� ������������� ����������
���������� ������� ������������ ����������� ��������� (*) � ����� (+). ��������:

   a*

��������� ����� ������� ���������������� �������� a, ������� ������, � �� ����� ��� a+ ��������� ���� � ����� ����������� a. ��������:

   [a-z]+
��������� ��� ������� �������� ����, �
   [A-Za-z][A-Za-z0-9]*

��������� ��� ���������-�������� ������ � ��������� ������. �������, ��� ��� �������� ��������� ��� ������������� ��������������� � ������ ����������������.

�������� ����������� � �����������
�������� ������������ ����� (|) ���������� �����������. ��������:

   (ab|cd)

��������� ab ��� cd. �������, ��� ������� ������ ������������ ��� �����������, ���� ��� �� �������� ������������ �� ������� ������. ��������:

   ab|cd
������������ ����������� �������. ������� ������ ������������ ��� ����� ������� ��������� ����:
   (ab|cd+)?(ef)*
������� ��������� ����� �������� �������, ��� abefef, efefef, cdef � cddd, �� �� abc, abcd ��� abcdef.

�������� ����������� �� ���������
lex ���������� ������ ����� ����� ����������� ���������. ��� ����� ������������ ��� ���������� ���������: ���� (^) � ���� ������� ($). ���� (^) - ������ ���� ���������, �� ��������� �������������� ������ � ������ ������ (����� ������� ����� ������ ��� � ������ �������� ������). ��� �� ����� ������������� ������� �������� ������� (^), ���������� ������ ��������, ��� ��� ���������� ����������� ������ ������ ������. ���� ����� ��������� �������� �������� ���� �������, �� ��������� �������������� ������ � ����� ������ (���� �� ��� ����� �� ������� ���� ����� ������). ���� �������� �������� ������� ������� ��������� ����� ����� (/), ������� ��������� �� ����������� ��������. ���������

   ab/cd
��������� ������ ab, ���� �� ��� ���� cd. ����� �������:
   ab$
��� �� �� �����, ���
   ab/\n

����� �������� ����������� �� lex ����� �������� ��������� �������, ������� ����������� � ������� "�������� ����������� �� ������ ���������". ���� ������� ������ ����������� ������ � ������ ���������� ��������������� �������������� lex � ��������� ������� x, �� ��� ������ ���� ��������� � ������� ������:

   <x>
���� �� ������� ��� ��������� ������� ONE ��������� � ������ ������, �� �������� (^) ����� ������������
   <ONE>
��������� ������� ����� �������� ������� � ���� �����.

�������� ���������� ���������
�������� ������ ({ }) ��������� ��� ���������� (���� ��� �������� �����), ��� ����������� ���������� (���� ��� �������� ���). ��������:

   {digit}
���� ���������� ������ �������� � ������ digit � ��������� �� � ������ ����� ���������.

�������� �����������
����������� �������� � ������ ����� ����� lex, ����� ���������.

   a{1,5}
��������, ���� �� 1 �� 5 ����������� ������� a.

�������, ��������� ���� �������� (%) �������� �����������, ��������� �� �������������� �������� ��������� lex.

�������� ��������
����� ��������� �������������� � �������� ������ �� �����, lex ��������� ��������������� ��������. ���� ������ ��������� ��������� ����������� lex, ������� �������� ��� �������� ��������. �������, ��� ���������� �������� �� ���������, ������� �������� ������� ������ �� �����. ��� ����������� ��� ���� ��������, ������� � ��������� ������ �� ��������������. ����� �������, ������������ lex, ������� ������ ���������� ������ ���� ��� ������-���� ������, ������ ��������� �������, ����������� ��� ������. ���� lex ������������ ��������� � yacc, �� ��� ��������� ���������� ���������. �� ������ ������������� ��� ��������, ��� ���������� ����������� ������� ������ � ��������. ����� �������, ������� �������� ����������� ����� ���� �������. ����� �������, ��� ����� �������, ��� ��������������� ����. �������� � �������� �������� ������� ��������� ����� �� �������� ������ � ����� ����������. ����� ������������ �������

   [\t\n];
������� �������� ������������� ���� �������� (������, ���� ���������, ���� ����� ������).

����� �� ��������� ��������, ����� ������������ ������ ������� |, ������� ���������, ��� �������� ��� ������� ������� ������ � �������� ��� ����������. ���������� ������ ����� ���� �� �������� ��������� �������:

   " "      |
   "\t"     |
   "\n"     ;
��� �������� � ���� �� ����������, ������ ������������ � ������ ����. ������� ������ \n � \t �� �����������. ��� ������� ����� ������� �������� ����� ����� ����� ������� �����, �������������� ���������� ����
   [a-z]+
lex ������ ���� ����� �� ������� ���������� ������� � ������ yytext. ���, ����� ���������� ��������� ���, ������������ ������� ����
   [a-z]+printf("%s",yytext);

������� �������� ���������� ������, ���������� � yytext. ������� ����� �� printf(2) ��������� �������� ���������� ��������� � ������. � ���� ������ �������� �������� print string, ��� ���� �������� (%) ��������� �� �������������� ������, s ���������� ��� ���������� ������. ������� �������� ������� �� yytext. ��� ��������� ����������� ������ � �������� ������. ��� �������� ��������� ��������, ��� ����� ���� �������� ����� ECHO. ��������:

   [a-z]+ ECHO;

���������� ����������� �������. ��� ��� �������� �� ��������� �������� ������ ��������� �������, �� ����� ���������� ������: ����� ����� �������, ����������� ������ �������� �� ���������? ����� ������� �����, ����� �������� ������������� �����-�� ������, ������������� ������. ��������, ���� ���� �������, ������� ������������ read, �� ��� ����� ������������ ���������� read, ����������� � bread ��� readjust. ����� �������� �����, ��������� �������

   [a-z]+
���� ������ ����� ��������� �������� �����.

������ ������ ������� ����� ����� ��������� ������, ������� lex ������������ ����� �������������� �������� � ���������� yyleng. ����� ���������� � ����� ���� � ����� ��������, ������� ��������:

   [a-zA-Z]+  {words++;chars+=yyleng;}

����� ���������� ������� �������� � ������, � ��������� ����� ������� ���������� chars. ��������� � ���������� ������� �������������� ������ ����� ����������� ��������� �������:

   yytext[yyleng-1]

������ lex ����� ������, ��� ������� �� ���������� ��������������� ����� ��������. ���������� ��� ���������, ���������� � ���� ��������. ��-������, ����� ���� ������� ������������ yymore(), �������������� ������������ ��������� �������� ��������� � ����� �������� �����. ������ ��������� �������� ���������� ������ �������� ������� ������� � yytext. ��-������, ����� ���� ������� ������������ yyless(n), ������������, ��� �� ��� �������, ����������� ������� ����������, ��������� ����� ������. �� ������ n ��������� ����� ��������, ������������ � yytext. ����� ������ �������, ������� ��� ���� ������������, ������������ ������� �� ����. ��� ������������ ������ ��������� ������, ��� �������� ����������� ���������� (/), �� � ������ �����.

��������, ���������� ����, ������� ���������� ������ ����� ���, ����������� � �������, ��� ���������� ������. ���� � ��� ������ ���� �������� ���� �������, �� ��� ������ �������������� �������� ����� ����� (\). ���������� ���������, ������������ ��� ������ �������������, �������� ������, ������� ���������������� ������:

   \"[^"]* {
      if(yytext[yyleng-1]==`\\`)
        yymore();
       else
        ...normal user processing
       }
��� ����, ���� ����������
   "abc\"def"
�� ����� �������������� ������ ���� ��������
   "abc\
�����, ����� yymore() ��������� ��������� ����� ���������� ������
   "def
� �����. �������, ��� ��������� ���� �������, ����������� ������, ����� ����������� � ����, ��������������� ������� ���������.

������� yyless() � ��������� ��������������� ����� ���� ������������ ��� ��������� ��������� ������. ���������� �������� ����������� �������������� ��������� =-a � ������ �������� ��. ��������, ��� ��� ��������� ����������� ��� =- a ��� ����������� ������. ����� ��������� ��������� �������:

   =-[a-zA-Z] {
      printf("Operator(=-)ambiguous\n");
      yyless(yyleng-1);
      ...action for=-...
      }

����� ���������� ���������, ����� ������� ��������� ����� ����� ������������ �� ������� �����, � �������� ����� ������������ ��� =-.

��������, ����� ������������� ���������� ��� ��� = -a; ����� �������� �����, ������� ���� ����� � ����� ��� �����. ������������� ����� ��������� ���������� ��������:

   =-[a-zA-Z {
      printf("Operator(=-)ambiguous\n");
      yyless(yyleng-2);
      ...action for=...
      }
�������, ��� ��������� � ���� ������� ����� ���� �������� ���
   =-/[A-Za-z]
� ������ ������, �
   =/-[A-Za-z]
�� ������. � ��������, �������� ������� ������� ����, �� ��������� ��������. ��� ��������� ���������������� ��� ������������� � ������������� ����� ��������������. ��� �� �����, � ������ =-3 ����� ������������ �������
   =-/[^\t\n]
� ���������� � ���� ����������, lex ����� ��������� ������ ����� ����������� ������������� �����/������:
  1. input(), ������� ���������� ��������� �������� ������;
  2. output(�), ������� ������� ������ c;
  3. unput(�), ������� �������� ������ c ������� �� ������� �����, ����� ����� ������� ��� � ������� input().

�� ��������� ��� ������������ ��������������� ��� ����������������, �� ������������ ����� �������� �� ������������ ��������. ��� ������������ ������������� ����������� ����� �������� ������� � ����������� ���������, ������� ��� ��� ������ ����������� ��� �������������� ������������. ��� ����� ���� ��������������, ����� ������� ����������� �������� ��� ������� ������ � ������ �������, ������� ������ ��������� ��� ����������� ������. �� ������������ ������ �������� �� ���� ������������� ������ ���� �����������. ������� ��������, ������������ input(), ������ �������� ����� �����. ����� ����� unput() � input() ������ �����������, ����� �������� ������ �� ����� ��������������. lex ������ �� ����� ��������� �������� ������, ���� ��� ��� �� ����������. �� ������ �������, ���������� ����� ����� (/) ��� �������������� ����� �� ��������� �������� ������������� ��������:

   + * ? $

�������� ������ ����� ��������� ��� ������������� ���������, ������� �������� ��������� ������� ���������. ���� ��������������� ����� ��������, ����� ������������ lex. ����������� ���������� lex �������� 100 ��������� ����� ��������.

��� ���� ������������ ���������� lex, ������� ������ ���������� ��������������, - ��� yywrap(), ���������� ������ ���, ����� lex ��������� ����� �����. ���� yywrap() �������� 1, lex ���������� ������� ������ �� ����� �����. ������, ��� �� �����, ������ ������� �������������� ������� ������ �� ������ ���������. � ���� ������ ������������ ������ ������� ������������ yywrap(), ������� ��������� ����� ������� ������ � ���������� 0. ��� �������� lex ���������� ���������. �� ��������� yywrap() ������ ���������� 1.

��� ������������ ����� ������ ��� ������ � ����� ��������� ������, ������� ��������� � �.�. �������, ��� ������ �������� ������� ������� ������� ���������� ����� �����. ������������ ������� ��� - ������������ yywrap(). � ����������������, ���� �� ����������� ����������� ������ input(), �� ������, ���������� ������ ���������, ������ ���������, ��������� �������� 0, ������������ input(), �������������� ��� ����� �����.

��������� ���������������� ���������
lex ����� ������������ ������������� ������������. ���� � ������� ����� �������������� ����� ������ ���������, lex ��������� ��������� �������:

�����������, ��������, ��� ���� ���������� �������:
   integer      keyword action...;
   [a-z]+ identifier action...;
���� �� ����� intergers, ��� �������������� ��� �������������, ������ ���
   [a-z]+
������������ ������ ��������, � �� �����, ���
   integer
������������ ������ 7. ���� �� ����� integer, ��� ������� ������������ 7 ��������, ���������� ������� ����������, ��������� ��� ������ ������. ���-���� ����� �������� (��������, int) �� ������������ ��������� integer, ������� ������������ ������������� ������ ��� ��������������.

������� ������������ �������� �������� ������������� ������ ��������� �����������, ����� ���

   .*
��������. ��������,
   `.*`
����� �� ���������� ������� �������� ������������ ���������� ������ � ��������. �� ��� �������������� ���������� ��� ����������� ������������� ������ ������ � ������� ��������� �������.

�������������� �� ����� ���������

   `first`quoted string here,`second`here
���������
   `first`quoted string here,`second`
�� ���, ��������, �� ��, ��� ���������. ����� ��������� ��������� �������:
   `[^~\n]*`
�������, ��� ��������� ���� �����, ����������� ����� `first` ����������� �������� ������ ���������� ���, ��� �������� ����� (.) �� �������������� ����� ����� ������. ������� ����� ���������� ������ �������������� �� ����� ����� ������. �� ��������� ��������� ��������� ����
   [.\n]+
��� �� �����������: ���������, ��������� lex, ����� �������� ������� ���� ������� ����, ��� ������� ������������ ����������� ������.

�������, ��� lex ������ ��������� ������� �����, �� �������� ��� ��������� ������������� ������� ���������. ��� ������, ��� ������ ������ ��������������� ������ ���� ���. �����������, ��� ���� ��������� ��� she � he �� ������� ������. ��� ����� ������� ��������� ������:

   she   s++;
   he    h++;
   \n    |
   .     ;

��� ��� ��������� ������� ���������� ���, ����� he � she. ������� �������, ��� ����� (.) �� ��������� ���� ����� ������. ��� ��� she �������� he, �� lex �� ����� ����������� ���������� he ������ she: ��������� she, �� ������ � ����� ����� �� ������������.

������ ������������ ����� �������� ���� �������. �������� REJECT �������� ������� � ���������� ������ ������������. ��� �������� ���������� �������, ������� ���� ������ ����� ������������. ������� ��������� �����, ��������������, ������������. ��������, ��� ������������ ������������� ����� ��������� ��� ���������� he. ��� ����� ����� ��������� ������:

   she   {s++;REJECT;}
   he    {h++;REJECT;}
   \n    |
   .     ;

��� ������� - ���������� ������� ���������� ��������. �� �� �������� ����� ��. ����� �������� ������� ���������, ��� �����������. ����� ������� ������������ ����� �������������� ��������� ���������. � ���� ������� ������������ ��� �� ��������, ��� she �������� he, �� �� ��������, � �������� �������� REJECT ������������ he. � ������ ������� ������ �������, ����� ������� ������ ����� � ����� �������.

���������� ��� �������:

   a[bc]+{...;REJECT;}
   a[cd]+{...;REJECT;}
���� �������� ab, �� �������������� ������ ������ �������, ���� ad - ������ ������. ������� ���������� ������ accb �������������� ������� ������� (��� ������� ��������), � ������� - ��� ����. ��������, ���� accd �������������� ������� ������� ��� ������� ��������, ����� ������� ��� ����.

REJECT ������� ������, ����� ����� lex �������� �� ���������� �������� ������, � ����������� ���� ����������� ������������ ��������� ������� ������. ��� �������� ����� ������������� ��� ��������� � ���� ���� �����. ��������, ��� ��������� �������� ������� ������� ������; ����� ������������� ���������� ����, ��� ����� "the" �������� th � he. ������� ���������� ��������� ������ digram. ����� �������� ����� ��������:

   %%
   [a-z][a-z]   {digram[yytext[0]yytext[1]]++;REJECT;}
   .      ;
   \n     ;
��� REJECT ��������� ��� ������� ���� ����, ������������ � ������ �������, � �� ������ ������ �������.

������� �������, ��� REJECT �� ������������� ������� ������ ��������. ��������, �� ���������� ���������� ����������� �������. ��� ������, ��� ���� ������� ������� � ����������� ���������� � ����������� REJECT, �� ��� ��������� �������� �� ������� ������ ������ ������������ input(). ��� ������������ �����������, ������������� �� ����������� ��������� ��� �� ������������������ �����.

�������� ����������� �� ������ ���������
������ ���������� ����� ��������� ������� ����������� ������ � ���������� � ��� � ��������� ����� � �������� �����. ��������, ������������ ����������� ������ ��������� ��������� ������������� � ������������� �� �������� �� ������ ����������. ��� ����� ���� ��������� ���������� ��������. ���������� �������� �������� ������� ����� �������. �������� (^) - ��� �������� ��������������� ���������. �� ���������� ��������������� �������������� ����� �������� ����� ����, ��� �������� ����� ������� ($) ���������� ������ ��������. �������� ��������� ������������ ������ ��������� ����� �� ���� ��������� ��� ����������� ������������, ����������� �������������� �������� ������������ ������� ���������. �� ���� �� ��� ��� �� �������, ��������� ������ ����� �������� ����� ���������� ������ ��������, � ������ ������.

���� ������ ��������� ��� ������� ������ � ���������� �����������:

  1. ������������� ������, ���� ��� �������� �� ����� ����� � ������ �������� ����� ��������� ������.
  2. ������������� � �������� ��������� �������.
  3. ������������� ���������� ����������� ������������, ���������� ���������.

� ������ ������ ���������� �������, ������� ������������ ������������� ��������� �����, � ������� ������������� ������� �����, � ������������� ��������� ��������� ��� ����� ���������. ��� ����� ���� ����, ���� ����������� ���������� �������� ������������. ����� ���� �������� ������ ��������� ��������, ��� ��� lex ������ �� ������������. ��� �� �����, ���� ��� ����� ������� ������ - ��������� lex ��������� ����� � �������� ��������� ���������������� ������� ������. ������ ������� ����� ���� ������������� � ������������ ��������� ��������. ��� ����� �������������� ������ �����, ����� lex ����� ���������� � ���� ��������� �������. ������� ��������� ������� ����� ���� �������� � ����� ������. �������, ���� ������ ������ ��� ��������� ���� �����������, �� ����� ������ ������ ���������� ������� - ��� �������� ��������� ��������� ����������� ������������ � ������������ � ������ �� ������.

��������, ������� ��������� ������: ����������� ������� ������ � ��������, ������� � ������ ������, ������������ � ����� a, ����� magic �� first; ������� magic �� second � ������ ������, ������������ � ����� b; � ������� magic �� third � ������ ������, ������������ � ����� c. ��� ��������� ����� � ������ ����������� ��� ���������.

��� ������ ��������� ������, ��� ����� ����� ��������������� �������:

       int flag;
 %%
 ^a    {flag=`a`;ECHO;}
 ^b    {flag=`b`;ECHO;}
 ^c    {flag=`c`;ECHO;}
 \n    {flag=0;ECHO;}
 magic {
       switch (flag)
       {
       case`a`:printf("first");break;
       case`b`:printf("second");break;
       case`c`:printf("third");break;
       default:ECHO;break;
       }
       }

����� ������ ��� �� ������ ��� ������ ��������� �������, ������ ��������� ������� ������ ���� ������������ lex � ������ ����������� �������

   % Start    name1 name2...
��� ������� ����� ����������� � ����� �������. ����� Start ����� ���� �������� ����������� s ��� S. �� �������� ����� ��������� � ������ ���������, ��������� ������� ������. ��������, �������:
   <name1> expression
������������, ������ ����� lex ��������� � ��������� ������� name1. ����� ����� � ��������� �������, ���� ��������� �������� ��������
   BEGIN name1;
������� ������ ��������� ������� �� name1. ��� �������� � ������� ��������� ����������� ��������
   BEGIN 0
������� ������������� ��������� ������� �������������� lex. ������� ����� ����������� � ���������� ��������� ��������. ��������:
   <name1,name2,name3>
�������� ����������� ���������. ����� �������, ������������ �� � ���������� ��������, ������ �������.

������, ����������� �����������, ����� ���� ������� ���:

   % START AA BB CC
   %%
   ^a     {ECHO;BEGIN AA;}
   ^b     {ECHO;BEGIN BB;}
   ^c     {ECHO;BEGIN CC;}
   \n     {ECHO;BEGIN 0;}
   <AA>magic printf("first");
   <BB>magic printf("second");
   <CC>magic printf("third");
����� ������ ����� ����� ��, ��� � � ���������� ��������, �� �������� lex, � �� ���, ��������������� �������������.

�������� ����������� ���������
�������� ������ ��������� lex:

   { ����������� }
   %%
   { ������� }
   %%
   { ������������ ������������ }

���� ��� ���� ������� ������ �������. ��� ����������� �������������� ����� ���� �� ��� ����������� ������������ � ����� ��������� ����������� � ��� ������ lex. ��� ����� ������� ��� � ������ ����������� ��� � ������ ������.

�������, ��� lex ���������� ������� � ���������. ����� ��������, �� ������������� lex, ���������� � ��������� ���������. ���������� ��� ������ �������� �������:

  1. ����� ������, ������� �� �������� ������ ������� ��� �������� lex, ������������� � ������� ��� ����� ���������, ���������� � ���������, ��������� lex. �������� ���� �� ���������, �������������� ������� ������������ %%, ����� ������� �� ��������� � ����� ������� � ���� ���������; ���� �� ���������� ����� ����� ������� ������������ %%, �� �� ����� ������� � ��������������� ����� ��� ����������� � �������, ���������� lex � ���������� ��������. ���� �������� ������ ��������� ��� ��������� �������� � ������ �������������� ������� ������� lex.

    ��� �������� ������ ���������� ����, ������, ������������ � ������� ��� ����� ��������� � ���������� �����������, ��������� � ������������ ���������. ��� ����� ������������ � ��������� lex ��� � ������������ ����. ����������� ������ ���� �������� �� �������� ����� ��.

  2. ��� ����������� ����� ��������, ����������� ������ %{ � %}, ���������� ���������� ����, ��� ������� ����.������������ �������������. ���� ������ ��������� ���� ������ ���� ���������� �������������, ������� ������ ���������� � ������ �������, � ����������� �����, �� ���������� �������� ��������.

  3. ��� ������������� ����� �������� ������������ %% ���������� ����� ������ lex, �������� �� ������.

�����������, ��������������� ��� lex, �������� �� ������� ������������ %%. ����� ������ ���� ������, �� ����������� ����� %{ � %} ������������ � ������ �������, ��������������� ��� ����������� ���������� ����� lex. ������ ���� ����� ���������:

   ��� �������

��� �������� ������������� ������, �������� ��� "�������", � ��������������� ������. ��� � ������� ������ �����������, �� ������� ����, ����� �������� ��� ������ ���������, ������ ��� ������ ���������� � �����. ������� ����� ���� ������ � ������� � ������� {name}. ��������, ������������� {D} ��� ���� � {E} ��� ������� ���������� ����� ��������� ������� ������������� �����:

     D                    [0-9]
     E                    [DEde][-+]?{D}+
     %%
     {D}+                 printf("inreger");
     {D}+"."{D}*({E})?    |
     {D}*"."{D}+({E})?    |
     {D}+{E}              printf("real");

������ ��� ������� ������������ ��� ������������ �����; � ����� ���������� ���������� ����� � ���������� �����. � ������ ������� ���������� ���� �� ���� ����� ����� ���������� ������; �� ������ - ���� �� ���� ����� ����� ���������� �����. ����� ������� ��������� ��������, ����������� � ����� FORTRAN ��� ���������� ��������� ���� 35.Q.I, ������� �� �������� ����� �����, ������ ������� ������ ��� ����� ����� ������������ ������� ���-��������� �������:

   [0-9]+/"."EQ printf("integer");

������ ����������� ����� ��������� ����� ������ �������, ������� ������� ��������, ������ ��������� �������, ���������� � �������� �������� �� ���������, ������������ ������ ������ lex ��� �������� �������� �������� �������. ��� ����������� ����������� � ������� "������ ���������".

lex � yacc
���� �� ����������� lex ��������� � yacc, �������: ��� ���������� lex ��������� � ��������� � ������ yylex(); ��� ��� ����������� ����������� yacc. ������ ����������� �� ��������� ������� ��������� ���������� lex �������� ��� ������������. �� ���� yacc �������� � ������������ ��� ������� ���������, yacc ����� �������� yylex(). � ���� ������ ��� ������� lex ����� ������������:

   return (token);
������� ���������� �������� ��������������� �������.

������� ������ �������� ������ � ������ ������ yacc - ��������������� �������� ���� lex ��� ����� ��������� ����� yacc, �������� � ��������� ������ ������� ������ yacc ��������� ������:

   #include "lex.yy.c"
�����������, ���������� ����� ��� good, � ����������� ������� - ��� better, ����� ������ ������������������ ������ XENIX ����� ���� �����:
   yacc good
   lex better
   cc y.tab.c-ly-ll

���������� yacc(-ly) ������� ��������� �� �������� ���������� lex, ����� �������� ������� ���������, ���������� ���������� yacc. ��������� �������� lex � yacc ����� ���� ������������ � ����� �������.

� �������� ������� �����, ���������� ���������� �������� ����� � ������������ 3 � ������� �������������� �����, �������� 7. ��� ������ �������� ��������� lex, ������������ ��� ��� ������:

  %%
         int k
  [0-9]+ {
                k=atoi(yytext);
                if(k%7==0)
                  printf("%d",k+3);
                else
                  printf("%d",k);
                }

������� [0-9] ������ ������ ����; atoi (��. atof(2)) - ����������� ����� � �������� � ����������� ��������� � k. �������� ������� (%) ������������ ��� ��������, �������� �� k ������� 7; ���� ��, �� � ���� ����������� 3. ����� ��������, ��� ��� ��������� ����� �������� ������� ������ ���� 49.63 ��� X7

����� ����, ��� ����������� ���������� �������� ���� ������������� �����, ������� ����. ����� �������� �����, ���� �������� ��������� ������ � ���������, ��� ��� �������� ����:

  %%     int k;
  -?[0-9]+      {
                k=atoi(yytext);
                printf("%d",k%7==0?k+3:k);
                }
  -?[0-9.]+           ECHO;
  [A-Za-z][A-Za-z0-9]+     ECHO;

�������� ������, ���������� ���������� ����� ��� ������������ � ����, ����� ���������� ����� �� ���� ��������� ������ � ���������� �� �����. if-else ��� �������� ����� ���������� �������� ���������� ��. ����������� a?b:c ��������: ���� a, �� b, ����� c.

��������� ��������� ���������� �������������� ���������. ��� ������ ����������� ���� ����, ������ ������ ������ ����..

         int lengs[100];
  %%
  [a-z]+ lengs[yyleng]++;
  .      |
  \n     ;
  %%
  yywrap()
  {
  int i;
  printf("Length No. words\n");
  for(i=0;i<100;i++)
  if(lengs[i]>0)
    printf("%5d%10d\n",i,lengs[i]);
  return(1);
  }

��� ��������� ����������� �����������, �� ������ ������ � �������� ������. �� �������� ����� ��� �������� �������. ��������� ������� return(1) ��������, ��� lex ������ ��������� ����. ���� yywrap() ������ ���� ("����"), ��� ������, ��� ������� ��� ������� ������ � ������� ���������� ���� � ���������. ���� yywrap() ������� �� ������� �������� "������", ��������� ������ � ����������� ����.

� �������� ������� �������� ������, �������� ����� ���������, ��������������� ��� �������������� ����� ������� �������� FORTRAN� � ���������. ��� ��� FORTRAN �� ��������� ��������� � �������� �����, ��� ������������ ���������� � ����������� ������ �������, ���������� ��� �������� ������ �����:

     a     [aA]
     b     [bB]
     c     [cC]
     .     .
     .     .
     .     .
     z     [zZ]
�������������� ����� ���������� ������:
   w[\t]*
������ ������� ��������� double precision � real ��� DOUBLE PRECISION � REAL.
     {d}{o}{u}{b}{l}{e}{W}{p}{r}{e}{c}{i}{s}{i}{o}{n}{
       printf(yytext[0]=='d'?"real":"REAL");
       }

�� ���� ��������� ����������� ������������, ����� ��������� �������� ����� ���������. ��� ������ ���������� ���� �������� ���� ������������ �������� ��������.. ��������� ������� �������� �������� ����� �����������, ����� �� ������� �� � �����������:

   ^"  "[^0]    ECHO;

� ������� ��������� ������ ����������� � �������. ��� ������������ ��� ������ ������, ����� �������� ���� ��������, ����� ����� ������, ����� ������� ��� ����. ����� ������ (^) ��������� � ���� ���������. �������� ������ ���������, ������� �������� ��������� ������� �������� �� ������� ��������� � ��������� ������:

     [0-9]+{W}{d}{W}[+-}?{W}[0-9]+                  |
     [0-9]+{W}"."{W}{d}{W}[+-]?{W}[0-9]+     |
     "."{W}[0-9]+{W}{d}{W}[+-]?{W}[0-9]+     {
       /*convert  constants*/
       for(p=yytext;*p!=0;p++)
         {
         if(*p=='d'||*p=='D')
           *p+='e'-'d';
            ECHO;
         }

����� ���������� ��������� � ��������� ������, ��� �������������� � ����� for � ����� ����� ����� "d" ��� "D". ����� ��������� ��������� "'e'-'d'", ��� ��������� �� � ��������� ����� ��������. ���������������� ��������� ��������� �����, ������ ��� ��������� ��������. ����� ���������� ��� ����, ������� ������ ���� ������������� � ����� ������� ��������� "d". ��� ������������ ������� yytext �������� �������� ������������� ���� ������ (����� ���������� ������ ����� �������� �������� ������).

     {d}{s}{i}{n}     |
     {d}{c}{o}{s}     |
     {d}{s}{q}{r}{t}  |
     {d}{a}{t}{a}{n}  |
     ...
     {d}{f}{l}{o}{a}{t}printf("%s",yytext+1);
������ ������ ���� �������� ��������� d �� ��������� a:
     {d}{l}{o}{g}     |
     {d}{l}{o}{g}10   |
     {d}{m}{i}{n}1    |
     {d}{m}{a}{x}1    {
          yytext[0]+='a'-'d';
          ECHO;
          }
��� ���� ������������ �������� ��������� d �� r:
     {d}1{m}{a}{c}{h}{
          yytext[0]+='r'-'d';
          ECHO;
     }
����� �������� ���������� ����� ����, ��� ���� dsinx, � �������� ����������� dsin, ��������� �������� ������� ��������� ����� ������� ����� ��� �������������� � �������� ��������� ���������� �������:
     [A-Za-z][A-Za-z0-9]*     |
     [0-9]+                   |
     \n                       |
     .     ECHO;
�������, ��� ��� ��������� �� �������� ������; ��� �� ��������� � ���������� �������� � FORTRAN � � �������������� �������� ���� � �������� ���������������.

�������� ������� ��������
���������, ��������� lex, ������������ ���������� ����/����� ������ � ������� ����������� input(), output(), unput(). ����� �������, ���������� ������������� � ���� ������������� ����������� lex � ������������ ��� �������� �������� � yytext. ��� ����������� ������������� ������ �������������� ��� ����� �����. ���� ������������ ����������� ����������, �� ����� ��������, ������ ������ �������� ��������� ����, ��������������� ������ �� ������� ���. ������ ����� a �������������� � ��� �� �����, ��� � ���������� ���������:

   'a'
���� ��� ������������� ���������� ����������� ����������� �����-������, ������������� �������, �� �� ���� ���� ������������� lex � ������� ������� �������������. ��� ������� ������ ���������� � ������ ����������� � ������ ���������� ��������, ����������� ������ %T. ������� ������� �� ����� ���������� ����:
   {�����} {������ ��������}
������� ��������� ��������, ��������������� ������� �������. ��������:
   %T
   1     Aa
   2     Bb
   ...
   26    Zz
   27    \n
   28    +
   29    -
   30    0
   31    1
   ...
   39    9
   %T

��� ������� ������������� ������������ ��������� � �������� ���� ����� ������ �� 1 �� 26, ����� ����� ������ - 27, ����� (+) � ������ (-) - 28 � 29, � ���� - ������ �� 30 �� 39. �������� ��������� ����� ����� ������. ���� ������� ��������, �� ������ ������, ������� ����� ��������� � �������� ��� � ���������� ������� ������, ������ ���� � ��� �������. ������ ������������ ��������� 0 � ����������, ���������� �� �������� ������ �����, ��������������� ���������� ������.

������ ���������
����������� ����� ����� ��������� lex:

     {�����������}
     %%
     {�������}
     %%
     {������������ ������������}
C����� ����������� �������� ���������� ��������� ���������:
  1. ����������� � ����� "��� ������ �������".
  2. ���������� ��� � ����� "������ ���".
  3. ���������� ��� � �����
        %{
        ���
        %}
    
  4. ��������� �������, ���������� � �����:
       %S ���1 ���2
    
  5. ������� ������� �������� � �����:
       %T
       ����� ������ ������-��������
       %T
    
  6. ��������� �������� ����������� ������� � �����:
       %x   nnn
    
    ��� nnn - ���������� ����� �����, �������������� ������ �������; x �������� �������� ������ �� ��������� ����������:
    ����� ��������
    p �������
    n ���������
    e ������� ������
    a ��������
    k ����������� ������ ��������
    o ������ ��������� �������

    � ������ ������ ������ ����� ���:

        ���������  ��������
    
    ��� �������� ����� ���� ���������� �� ��������� �������, ���� ������������ �������� ������ ��� ����������� ������. ���������� ��������� � lex ���������� ��������� ���������:
    x ������ "x"
    "x" "x", ���� ���� x - ��������
    \x "x", ���� ���� � - ��������
    [xy] ������ x ��� y
    [x-z] ������� x,y ��� z
    [^x] ����� ����, ����� x
    . ����� ����, ����� ����� ����� ������
    ^x x � ������ ������
    <y>x x, ���� lex ��������� � ��������� ������� y
    x$ x � ����� ������
    x? �������������� x
    x* 0,1,2,... ����������� x
    x+ 1,2,3,... ����������� x
    x|y x ��� y
    (x) x
    x/y x, �� ������ ���� �� ��� ������� y
    {xx} ������� xx �� ������ �����������
    x{m,n} �� m �� n ��������� x
Comments: [email protected]
Designed by Andrey Novikov
Copyright © CIT