p2.y

%{

#include <stdio.h> /* printf() */
#include <string.h> /* strcpy() */
#include "common.h" /* MAX_STR_LEN */
void found( const char *nonterminal, const char *value );
%}

%token KW_PROGRAM KW_BEGIN KW_END KW_USES KW_VAR KW_CONST KW_IF KW_THEN KW_ELSE
%token KW_CHAR KW_STRING KW_INTEGER KW_REAL KW_FOR KW_TO KW_DO KW_FUNCTION
%token KW_PROCEDURE
%token ASSIGN LE
%token<s> IDENT STRING_CONST
%token<d> FLOAT_CONST
%token<i> INTEGER_CONST CHARACTER_CONST

%union
{
    char s[ MAX_STR_LEN + 1 ];
    int i;
    double d;
}

 /* Priorytety operatorów */
%left '+' '-'
%left '*' '/'
%right NEG

%%

 /* program może być pusty (błąd semantyczny), zawierać błąd składniowy lub
    zawierać: nazwę programu (PROGRAM_NAME), sekcję deklaracji (SECTION_LIST)
    oraz blok główny (BLOCK) zakończony kropką */
Grammar: /* empty */ { yyerror( "Empty input source is not valid!" ); YYERROR; }
    | error
    /* !!!!!!!! od tego miejsca należy zacząć !!!!!!!!!!!! */
    | PROGRAM_NAME SECTION_LIST BLOCK '.' { found("Complete program", ""); }
;

 /* Nazwa programu (PROGRAM_NAME) może nie występować lub być postaci:
    słowo kluczowe "PROGRAM" nazwa_programu (IDENT) średnik */
PROGRAM_NAME:
    | KW_PROGRAM IDENT ';' { found( "PROGRAM_NAME", $2 ); }
;

/* lista sekcji (SECTION_LIST) składa się z dowolnej (również zerowej) liczby
    sekcji (SECTION) */
SECTION_LIST:
    | SECTION_LIST SECTION
;

 /* sekcja (SECTION) może być: sekcją deklaracji stałych (CONST_SECT),
    sekcją deklaracji
    zmiennych (VAR_SECT), funkcją (FUNCTION) lub procedurą (PROCEDURE) */
SECTION: CONST_SECT
    | VAR_SECT
    | FUNCTION
    | PROCEDURE
;

 /* SEKCJA CONST */

 /* sekcja CONST (CONST_SECT) zawiera słowo kluczowe CONST, po którym następuje
    lista deklaracji (CONST_LIST) zakończona średnikiem */
CONST_SECT: KW_CONST CONST_LIST ';' { found( "CONST_SECT", "" ); }
;

 /* lista deklaracji (CONST_LIST) zawiera jedną lub więcej deklaracji (CONST)
    rozdzielonych średnikiem */
CONST_LIST: CONST
    | CONST_LIST ';' CONST
;

 /* deklaracja stałej (CONST) składa się z identyfikatora, znaku równości ('=')
    oraz z wartości dosłownej (LITERAL) */
CONST: IDENT '=' LITERAL { found( "CONST", $1 ); }
;

 /* Wartość dosłowna (LITERAL) może być liczbą całkowitą (INTEGER_CONST),
    liczbą rzeczywistą (FLOAT_CONST) lub napisem (STRING_CONST) */
LITERAL: INTEGER_CONST
    | FLOAT_CONST
    | STRING_CONST
;

/* SEKCJA VAR */

 /* sekcja VAR (VAR_SECT) rozpoczyna się słowem kluczowym VAR,
    po którym następuje
    lista deklaracji (VAR_LIST) zakończona średnikiem, np. "Var
    i : Integer; c : Char; */
VAR_SECT: KW_VAR VAR_LIST ';' { found( "VAR_SECT", "" ); }
;

 /* lista deklaracji (VAR_LIST) składa się z jednej lub więcej deklaracji (VAR)
    oddzielonych średnikami */
VAR_LIST: VAR
    | VAR_LIST ';' VAR
;

 /* deklaracja VAR składa się z listy identyfikatorów (IDENT_LIST),
    po której następuje dwukropek i nazwa typu danych (DATA_TYPE) */
VAR: IDENT_LIST ':' DATA_TYPE { found( "VAR", "" ); }
;

 /* lista identyfikatorów (IDENT_LIST) zawiera jeden lub więcej identyfikatorów
    (IDENT) rozdzielonych przecinkami */
IDENT_LIST: IDENT
    | IDENT_LIST ',' IDENT
;

 /* nazwa typu danych (DATA_TYPE) to jedno ze słów kluczowych Integer, Real,
    Char, String */
DATA_TYPE: KW_INTEGER
    | KW_REAL
    | KW_CHAR
    | KW_STRING
;

 /* DEKLARACJA FUNKCJI I PROCEDURY */

 /* deklaracja procedury (PROCEDURE) składa się ze: słowa kluczowego PROCEDURE,
    nagłówka funkcji (FUN_HEAD), listy sekcji (SECTION_LIST)
    oraz bloku (BLOCK) */
PROCEDURE: KW_PROCEDURE FUN_HEAD SECTION_LIST BLOCK { found( "PROCEDURE", $<s>2 ); }
;

 /* deklaracja funkcji (FUNCTION) składa się z: słowa kluczowego FUNCTION,
    nagłówka
    funkcji (FUN_HEAD), dwukropka oraz typu zwracanej przez funkcję wartości
    (DATA_TYPE), listy sekcji (SECTION_LIST) oraz bloku (BLOCK) */
FUNCTION: KW_FUNCTION FUN_HEAD ':' DATA_TYPE SECTION_LIST BLOCK { found( "FUNCTION", $<s>2 ); }
;

 /* nagłówek funkcji (FUN_HEAD) rozpoczyna się identyfikatorem (IDENT),
    po którym w
    nawiasach okrągłych znajdują się parametry formalne (FORM_PARMS) */
FUN_HEAD: IDENT '(' FORM_PARAMS ')' { found("FUN_HEAD", $1); }
;

 /* parametry formalne (FORM_PARAMS mogą być puste
    lub mogą być listą parametrów formalnych (FORM_PARM_LIST) */
FORM_PARAMS:
    | FORM_PARAM_LIST
;

 /* lista parametrów formalnych (FORM_PARAM_LIST) zawiera 1 lub więcej
    parametrów formalnych (FORM_PARM) rozdzielonych przecinkiem */
FORM_PARAM_LIST: FORM_PARAM
    | FORM_PARAM_LIST ',' FORM_PARAM
;

 /* parametr formalny (FORM_PARAM) składa się z listy identyfikatorów
    (IDENT_LIST), dwukropka oraz określenia typu (DATA_TYPE) */
FORM_PARAM: IDENT_LIST ':' DATA_TYPE { found( "FORM_PARAM", "" ); }
;

 /* BLOK INSTRUKCJI */

 /* blok instrukcji (BLOCK) składa się ze słowa kluczowego BEGIN, instrukcji
    (INSTRUCTIONS) oraz słowa kluczowego END. Należy uwzględnić 2 wersje - ze
    średnikiem przed END lub bez niego */
BLOCK: KW_BEGIN INSTRUCTIONS KW_END { found( "BLOCK", "" ); }
;

/* Instrukcje (INSTRUCTIONS) mogą być puste lub moga być listą instrukcji
   (INSTR_LIST) */
INSTRUCTIONS:
    | INSTR_LIST ';'
;

 /* lista instrukcji (INSTR_LIST) może zawierać jedną lub więcej instrukcji
    (INSTRUCTION) rozdzielonych średnikami */
INSTR_LIST: INSTRUCTION
    | INSTR_LIST ';' INSTRUCTION
;

 /* instrukcją (INSTRUCTION) może być: wywołanie funkcji (FUNCT_CALL),
    instrukcja FOR (FOR_INSTR),
    przypisanie (ASSIGN_INSTR), instrukcja warunkowa if (IF_INSTR) */
INSTRUCTION: FUNCT_CALL
    | FOR_INSTR
    | ASSIGN_INSTR
    | IF_INSTR
;

 /* INSTRUKCJE PROSTE i KONSTRUKCJE ZŁOŻONE */

 /* wywołanie funkcji (FUNCT_CALL) składa się z identyfikatora
    oraz parametrów aktualnych
    (ACT_PARAMS) umieszczonych w nawiasach okrągłych. Alternatywną postacią
    wywołania funkcji jest po prostu jej nazwa (IDENT) bez nawiasów. */
FUNCT_CALL: IDENT '(' ACT_PARAMS ')' { found( "FUNCT_CALL", $1); }
    | IDENT { found( "FUNCT_CALL", $1); }
;

 /* parametry aktualne (ACT_PARAMS) mogą być puste lub zawierać listę parametrów
    (ACT_PARAM_LIST) */
ACT_PARAMS:
    | ACT_PARAM_LIST
;

 /* lista parametrów aktualnych (ACT_PARAM_LIST) może zawierać
    jeden parametr aktualny
    (ACT_PARAM) lub składać się z parametrów aktualnych oddzielonych
    od siebie przecinkiem */
ACT_PARAM_LIST: ACT_PARAM
    | ACT_PARAM_LIST ',' ACT_PARAM
;

 /* parametr aktualny (ACT_PARAM) może być: napisem (STRING_CONST),
    liczbą (NUMBER) lub
    wywołaniem funkcji (FUNCT_CALL), które wyjątkowo oznacza również
    identyfikator! */
ACT_PARAM: STRING_CONST { found( "ACT_PARAM", ""); }
    | NUMBER { found( "ACT_PARAM", ""); }
    | FUNCT_CALL { found( "ACT_PARAM", ""); }
;

 /* liczba (NUMBER) może być liczbą całkowitą (INTEGER_CONST)
    lub rzeczywistą (FLOAT_CONST) */
NUMBER: INTEGER_CONST
    | FLOAT_CONST
;

 /* przypisanie (ASSIGN_INSTR) składa się z identyfikatora,
    operatora przypisania (ASSIGN) oraz wyrażenia (EXPR) */
ASSIGN_INSTR: IDENT ASSIGN EXPR { found( "ASSIGN_INSTR", $<s>1); }
;

 /* wyrażenie (EXPR) może być: liczbą lub identyfikatorem, sumą, różnicą,
    iloczynem, ilorazem oraz negacją wyrażeń, a także wyrażeniem w nawiasach.
    Należy uwzględnić wyższy priorytet minusa jednoargumentowego!!!  */
EXPR: NUMBER
    | IDENT
    | EXPR '+' EXPR
    | EXPR '*' EXPR
    | EXPR '-' EXPR
    | EXPR '/' EXPR
    | '-' EXPR %prec NEG
    | '(' EXPR ')'
;

 /* instrukcja FOR (FOR_INSTR) składa się ze słowa kluczowego FOR,
    identyfikatora,
    znaku podstawienia (ASSIGN), danej CONST_VAR, słowa kluczowego
    TO, danej CONST_VAR, słowa kluczowego DO oraz bloku instrukcji
    (BLOCK_INSTR) */
FOR_INSTR: KW_FOR IDENT ASSIGN CONST_VAR KW_TO CONST_VAR KW_DO BLOCK_INSTR { found( "FOR_INSTR", ""); }
;

 /* dana (CONST_VAR) może być liczbą całkowitą lub identyfikatorem */
CONST_VAR: KW_INTEGER
    | IDENT
;

 /* blok instrukcji (BLOCK_INSTR) może być blokiem (BLOCK) lub pojedynczą
    instrukcją (INSTRUCTION) */
BLOCK_INSTR: BLOCK
    | INSTRUCTION
;

 /* instrukcja if */
IF_INSTR: KW_IF EXPR '>' EXPR KW_THEN IF_INSTR_BLOCK { found( "IF_INSTR", ""); }
    | KW_IF '(' EXPR '>' EXPR ')' KW_THEN IF_INSTR_BLOCK { found( "IF_INSTR", ""); }
;

IF_INSTR_BLOCK: INSTRUCTION
    | INSTRUCTION KW_ELSE INSTRUCTION
;

%%


int main( void )
{
    int ret;
    printf( "Autor: Imie i Nazwisko\n" );
    printf( "yytext              Typ tokena      Wartosc tokena znakowo\n\n" );
    ret = yyparse();
    return ret;
}

int yyerror( const char *txt )
{
    printf( "Syntax error %s\n", txt );
}

void found( const char *nonterminal, const char *value )
{ /* informacja o znalezionych strukturach składniowych (nonterminal) */
    printf( "===== FOUND: %s %s%s%s=====\n", nonterminal,
            (*value) ? "'" : "", value, (*value) ? "'" : "" );
}