Приложение б (обязательное) Модуль синтаксического анализатора

%{ unit yaccKR1;

{$o-}

interface

uses lexlib,yacclib,lexKRModul,dialogs;

type

st1=string[1];

st2=string[2];

st3=string[3];

st4=string[4];

st5=string[5];

st7=string[7];

idtype=string[20];

var

i:integer;

m:array [0..250] of string;

%}

%token <st3> key_var

%token <idtype> id

%token <st1> dp

%token <st7> typ

%token <st1> tz

%token <st5> key_begin

%token <st3> key_end

%token <st1> tchk

%token <st1> zpt

%token <st2> prisv

%token <st4> key_read

%token <st1> os

%token <st1> zs

%token <st5> key_write

%token <st5> key_while

%token <st2> key_do

%token <st2> key_if

%token <st4> key_then

%token <st4> key_else

%token <st3> key_and

%token <st2> key_or

%token <st1> sign

%token <st1> mult

%token <st1> division

%token <st1> plus

%token <st1> minus

%token <real> num

%token <st1> space

%type <integer> VARZONE

%type <integer> VARZONE1

%type <integer> LIST_ID

%type <integer> PROGZONE

%type <integer> COMMANDS

%type <integer> COMMAND

%type <integer> PRISVCOM

%type <integer> READCOM

%type <integer> WRITECOM

%type <integer> WHILECOM

%type <integer> IFCOM

%type <integer> ELSECOM

%type <integer> IF_INSTR

%type <integer> BOOL

%type <integer> BOOL_TERM

%type <integer> BOOL_EXPR

%type <integer> BOOL_FACTOR

%type <integer> BOOL_FACTOR1

%type <integer> BLOCK

%type <integer> EXPR

%type <integer> TERM

%type <integer> TERM1

%type <integer> EXPR1

%type <integer> FACTOR

%type <integer> GOAL

%%

GOAL : VARZONE PROGZONE { m[i] := 'goal('+m[$1]+','+m[$2]+')'; $$ := i; inc(i); }

VARZONE : key_var id LIST_ID dp typ tz VARZONE1 { m[i] := $1+'('+$5+'('+$2+m[$3]+')'+m[$7]+')'; $$ := i; inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

VARZONE1 : id LIST_ID dp typ tz VARZONE1 { m[i] := ','+$4+'('+$1+m[$2]+')'+m[$6]; $$:=i; inc(i); }

| { m[i] := '';$$ := i; inc(i); }

LIST_ID : zpt id LIST_ID { m[i] := ','+$2+m[$3]; $$ := i; inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

PROGZONE : key_begin COMMANDS key_end tchk { m[i] := 'progzone('+m[$2]+')'; $$ := i; inc(i); }

COMMANDS : COMMAND tz COMMANDS {If m[$3]<>'' then m[i]:=m[$1]+','+m[$3] else m[i]:=m[$1]+m[$3]; $$ := i; inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

COMMAND : BLOCK { m[i] := m[$1]; $$ := i; inc(i); }

| PRISVCOM { m[i] := m[$1]; $$ := i; inc(i); }

| READCOM { m[i] := m[$1]; $$ := i; inc(i); }

| WRITECOM { m[i] := m[$1]; $$ := i; inc(i); }

| WHILECOM { m[i] := m[$1]; $$ := i; inc(i); }

| IFCOM { m[i] := m[$1]; $$ := i; inc(i); }

PRISVCOM : id prisv EXPR { m[i] := 'prisv('+$1+','+m[$3]+')'; $$ := i; inc(i); }

READCOM : key_read os id zs { m[i] := $1+$2+$3+$4; $$ := i; inc(i);}

WRITECOM : key_write os id zs { m[i] := $1+$2+$3+$4; $$ := i; inc(i); }

WHILECOM : key_while BOOL key_do BLOCK {m[i] := $1+'('+m[$2]+','+$3+'('+m[$4]+'))'; $$ := i; inc(i);}

IFCOM : key_if BOOL key_then IF_INSTR ELSECOM { m[i] := $1+'('+m[$2]+','+$3+'('+m[$4]+')'+m[$5]+')'; $$ := i; inc(i); }

ELSECOM : key_else IF_INSTR { m[i] := ','+$1+'('+m[$2]+')'; $$ := i;inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

IF_INSTR : IFCOM { m[i] := m[$1]; $$ := i; inc(i); }

| BLOCK { m[i] := m[$1]; $$ := i; inc(i); }

BOOL : BOOL_FACTOR BOOL_TERM { m[i] := m[$1]+m[$2]; $$ := i; inc(i); }

| BOOL_FACTOR BOOL_EXPR { m[i] := m[$1]+m[$2]; $$:=i; inc(i); }

BOOL_TERM : key_and BOOL { m[i] := $1+m[$2]; $$ := i; inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

BOOL_EXPR : key_or BOOL { m[i] := $1+m[$2]; $$ := i; inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

BOOL_FACTOR : os BOOL_FACTOR1 zs { m[i] := $1+m[$2]+$3; $$ := i; inc(i); }

BOOL_FACTOR1 : FACTOR sign FACTOR { m[i] := m[$1]+$2+m[$3]; $$ := i; inc(i); }

BLOCK : key_begin COMMANDS key_end { m[i] := m[$2]; $$ := i; inc(i); }

EXPR : TERM EXPR1 { m[i] := m[$1]+m[$2]; $$ := i; inc(i); }

TERM : FACTOR TERM1 { m[i] := m[$1]+m[$2]; $$ := i; inc(i); }

TERM1 : mult FACTOR TERM1 { m[i] := '*('+m[$2]+','+m[$3]+')'; $$ := i; inc(i); }

| division FACTOR TERM1 { m[i] := '/('+m[$2]+','+m[$3]+')'; $$ := i; inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

EXPR1 : plus TERM EXPR1 { m[i] := '+('+m[$2]+','+m[$3]+')'; $$ := i; inc(i); }

| minus TERM EXPR1 { m[i] := '-('+m[$2]+','+m[$3]+')'; $$ := i; inc(i); }

| { m[i] := ''; $$ := i; inc(i); }

FACTOR : num { m[i] := floattostr($1); $$ := i; inc(i); }

| id { m[i] := $1; $$ := i; inc(i); }

%%

(*$I Ilex.pas*)

end.