parser.y

%{
/****************************************************************************
parser.y
ParserWizard generated YACC file.
Author: Agnieszka Kuberska
Date: 29 pazdziernik 2013
****************************************************************************/

#include <stdio.h> /* printf() */
#include <string.h> /* strcpy() */
#include "common.h" /* MAX_STR_LEN */
#if defined( PG )
#include <conio.h> /* getch() */
#include "lexer.h" /* tylko dla Parser Generatora */
#endif
 /* informacja o znalezionych strukturach sk³adniowych (nonterminal) */
void found( const char *nonterminal, const char *value );
 /* przykladowe wywolanie found( "DEKLARACJA", "" ); */
%}

 /***************************************************************************/
 /*           declarations section - place any declarations here            */
 /***************************************************************************/

 /* DEKLARACJA TOKENÓW */
%token KW_CHAR KW_UNSIGNED KW_SHORT KW_INT KW_LONG KW_FLOAT KW_VOID KW_FOR KW_DOUBLE KW_IF
%token INT_NUMBER FLOAT_NUMBER IDENT TEXT_CONST KW_ELSE
%token INC LE

%union
{ /* DEKLARACJA TYPU TOKENÓW */
    char s[ MAX_STR_LEN + 1 ]; /* pole tekstowe dla nazw itp. */
    int i; /* pole ca³kowite */
    double d; /* pole zmiennoprzecinkowe */
}

 /* Priorytety operacji arytmetycznych '+' '-' '*' '/' 'NEG' */
%left '+' '-'
%left '*' '/'
%right NEG

%type <s> FUN_HEAD IDENT
%%

 /***************************************************************************/
 /* rules section - place your YACC rules here (there must be at least one) */
 /***************************************************************************/

 /* STRUKTURA PROGRAMU W C-- */

 /* program mo¿e byæ pusty (b³¹d semantyczny), zawieraæ b³¹d sk³adniowy lub
    sk³adaæ siê z listy sekcji (SECTION_LIST) */
Grammar: { yyerror( "Plik jest pusty" ); YYERROR; }
    | error
    |SECTION_LIST
    /* !!!!!!!! od tego miejsca nale¿y zacz¹æ !!!!!!!!!!!! */
;
 /* lista sekcji sk³ada siê przynajmniej z 1 sekcji (SECTION) */
SECTION_LIST: SECTION_LIST SECTION
    | SECTION
;

 /* sekcja mo¿e byæ deklaracj¹ (S_DECLARATION) lub funkcj¹ (S_FUNCTION) */
SECTION: S_DECLARATION
    | S_FUNCTION
;

 /* DEKLARACJE DANYCH */


 /* deklaracja danych sk³ada siê z okreœlenia typu (DATA_TYPE) oraz listy
    zmiennych (VAR_LIST) zakoñczonych œrednikiem */
S_DECLARATION: DATA_TYPE VAR_LIST ';' {found("deklaracja zmiennych", "");}
;

 /* typ mo¿e byæ jednym z typów prostych: char, unsigned char, short, unsigned short,
    int, unsigned int, unsigned, long, unsigned long, float, double */
DATA_TYPE: KW_CHAR
    | KW_UNSIGNED KW_CHAR
    | KW_SHORT
    | KW_UNSIGNED KW_SHORT
    | KW_INT
    | KW_UNSIGNED KW_INT
    | KW_UNSIGNED
    | KW_LONG
    | KW_UNSIGNED KW_LONG
    | KW_FLOAT
    | KW_DOUBLE
;


 /* lista zmiennych sk³ada siê przynajmniej z jednej zmiennej (VAR).
    Wiêksza liczba zmiennych powinna byæ oddzielona przecinkiem */
VAR_LIST: VAR
    |VAR_LIST ',' VAR
;


 /* zmienna jest identyfikatorem lub identyfikatorem z podstawieniem wartoœci
    pocz¹tkowej, która mo¿e byæ wyra¿eniem arytmetyczno-logicznym (EXPR) lub
    napisem (TEXT_CONST) */

VAR: IDENT
    |IDENT '=' FLOAT_NUMBER
    |IDENT '=' INT_NUMBER
    |IDENT '=' TEXT_CONST
;

 /* DEKLARACJE FUNKCJI */

 /* deklaracja funkcji sk³ada siê z okreœlenia typu zwracanego przez funkcjê
    (DATA_TYPE lub KW_VOID), nag³ówka funkcji (FUN_HEAD) oraz cia³a funkcji
    (BLOCK). UWAGA! Nale¿y stworzyæ dwie oddzielne regu³y dla DATA_TYPE oraz KW_VOID */
S_FUNCTION: DATA_TYPE FUN_HEAD BLOCK {found("deklaracja funkcji", "");}
    |KW_VOID FUN_HEAD BLOCK {found("deklaracja funkcji", "");}
;

 /* nag³ówek funkcji rozpoczyna siê identyfikatorem (IDENT), po którym w
    nawiasach okr¹g³ych znajduj¹ siê argumenty formalne (ARG_FORMS) */
FUN_HEAD: IDENT '(' ARG_FORMS')'
;

 /* argumenty formalne mog¹ byæ s³owem kluczowym void lub list¹ parametrów
    formalnych (ARG_FORM_LIST) */
ARG_FORMS: KW_VOID
;

 /* lista parametrów formalnych mo¿e byæ s³owem kluczowym void lub co najmniej
    jednym argumentem formalnym ARG_FORM (parametry formalne s¹ rozdzielane przecinkiem) */
ARG_FORM_LIST: KW_VOID
;

 /* parametr formalny sk³ada siê z definicji typu (DATA_TYPE) oraz identyfikatora (IDENT) */


 /* blok sk³ada siê z umieszczonych w nawiasach klamrowych listy deklaracji danych (DECL_LIST)
    oraz lista instrukcji (INSTR_LIST) */
BLOCK: '{' DECL_LIST'}'
;

 /* lista deklaracji mo¿e byæ pusta lub sk³adaæ siê z deklaracji (DECLARATION) */
DECL_LIST:
;

 /* lista instrukcji mo¿e byæ pusta lub sk³adaæ siê z instrukcji (INSTRUCTION) */


/* INSTRUKCJE PROSTE i KONSTRUKCJE Z£O¯ONE

 /* instrukcj¹ mo¿e byæ: instrukcja pusta (;), wywo³anie funkcji (FUN_CALL),
    instrukcja for (FOR_INSTR), przypisanie (ASSIGNMENT) zakoñczone œrednikiem,
    zwiêkszenie wartoœci zmiennej (INCR) zakoñczone œrednikiem,
    instrukcja warunkowa (IF_INSTR) lub blok */


 /* wywo³anie funkcji sk³ada siê z identyfikatora oraz argumentów aktualnych (ARG_ACTS)
    umieszczonych w nawiasach okr¹g³ych. Ca³oœæ jest zakoñczona œrednikiem. */


 /* argumenty aktualne mog¹ byæ puste lub zawieraæ listê argumentów */


 /* lista argumentów aktualnych mo¿e zawieraæ jeden argument aktualny (ARG_ACT)
    lub sk³adaæ siê z argumentów aktualnych oddzielonych od siebie przecinkiem */


 /* argument aktualny mo¿e byæ identyfikatorem (IDENT), napisem (TEXT_CONST),
    lub liczb¹ (NUMBER) */


 /* liczba mo¿e byæ liczb¹ ca³kowit¹ lub rzeczywist¹ */


 /* inkrementacja sk³ada siê z identyfikatora oraz operatora inkrementacji (INC) */


 /* przypisanie sk³ada siê z identyfikatora, operatora podstawienia oraz wyra¿enia */


 /* wyra¿enie (EXPR) mo¿e byæ: liczb¹, dodawaniem, odejmowaniem, mno¿eniem, dzieleniem,
    negacj¹ lub wyra¿eniem w nawiasach  */


 /* instrukcja for w uproszczonej wersji */



 /* instrukcja if */


 /* pêtla while .. do */


 /* pêtla do .. while */


%%

 /***************************************************************************/
 /*                            programs section                             */
 /***************************************************************************/

int main( void )
{
    int ret;
    printf( "Autor: Imie i Nazwisko\n" );
    printf( "yytext              Typ tokena      Wartosc tokena znakowo\n\n" );
#if defined( PG ) /* Parser Generator */
    /* poni¿sza inicjalizacja strumieni wy³¹cznie dla Parser Generatora */
    yyin = stdin;
    yyout = stdout;
    yylexerr = stderr;
#endif
    /* wywo³anie parsera */
    ret = yyparse();
#if defined( PG ) /* Parser Generator */
    getch();
#endif
    return ret;
}

#if defined( PG ) /* Parser Generator */
void yyerror( const char *txt )
#else
int yyerror( const char *txt )
#endif
{
    printf( "Syntax error %s", txt );
#if !defined( PG ) /* Parser Generator */
    return( 0 );
#endif
}

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) ? "'" : "" );
}