ZAVOD ZA ELEKTRONIKU, MIKROELEKTRONIKU, RAUNALNE I INTELIGENTNE SUSTAVE

FAKULTET ELEKTROTEHNIKE I RAUNARSTVA

SVEUILITE U ZAGREBU

Melita Mihaljevi

Seminarski rad iz predmeta

Automati, formalni jezici i jezini procesori I
Zadatak broj 47

Zagreb, 2007.

Seminarski rad iz predmeta Automati, formalni jezici i jezini procesori I

Student: Melita Mihaljevi
Matini broj studenta: 0036411392
Zadatak broj 47:
Implementirati na raunalu program koji za zadanu kontekstno neovisnu gramatiku
gradi odgovarajui potisni automat( L(M) = L(G)), prema algoritmu datom na predavanju (u
udbeniku).

Sadraj
1. Uvod.................................................................................................................................4
2. Opis algoritma..................................................................................................................5
2.1. Svoenje produkcija gramatike na Greibachov normalni oblik..................................................5
2.2. Pretvorba gramatike u potisni automat........................................................................................5
2.3. Simulacija PA..............................................................................................................................6
3. Programsko rjeenje.........................................................................................................7
3.1. Svoenje produkcija gramatike na Greibachov normalni oblik:................................................8
3.2. Konstrukcija PA..........................................................................................................................9
3.3. Simulacija PA............................................................................................................................10
4. Primjeri...........................................................................................................................10
4.1. Primjer 1....................................................................................................................................10
4.2. Primjer 2....................................................................................................................................12
5. Zakljuak........................................................................................................................16
6. Dodatci...........................................................................................................................17
6.1. Popis klasa i pripadnih metoda..................................................................................................17
6.2. Hijerarhijska struktura klasa......................................................................................................18
7. Literatura........................................................................................................................19

1. Uvod
Izgradnja potisnog automata iz kontekstno neovisne gramatike mogua je zbog injenice
da kontekstno neovisna gramatika generira jedan od kontekstno neovisnih jezika, te isto
tako za bilo koji kontekstno neovisan jezik L postoji nedeterministiki potisni automat PA M
koji prihvaa praznim stogom N(M)=L. Pretpostavka je da prazni niz nije element jezika L.
Za kontekstno neovisnu gramatiku mogue je sagraditi potisni automat PA koji prihvaa
praznim stogom, a prihvaa jezik koji zadana kontekstno neovisna gramatika generira.
Potisni automat se iz kontekstno neovisne gramatike gradi na sljedei nain:
Neka je zadana gramatika G= (V, T, P, S) koja generira kontekstno neovisan jezik L, a
koja ima produkcije u Greibachovom normalnom obliku (sve produkcije su oblika A->a,
gdje je A element nezavrnih znakova V, a je element zavrnih znakova T, a je iz skupa
nezavrnih znakova, konstruira se PA:
M = ({q}, , , , q, S, )
a) PA ima samo jedno stanje q koje je ujedno i poetno stanje
b) skup znakova stoga jednak je skupu nezavrnih znakova gramatike V
c) skup ulaznih znakova jednak je skupu zavrnih znakova gramatike T
d) poetni znak stoga jest poetni nezavrni znak S
e) skup prihvatljivih stanja je prazan skup
f) PA M prihvaa praznim stogom
Funkcije prijelaza zadaju se na sljedei nain:
(q, a, A) sadri (q, ) ako i samo ako postoji produkcija A -> a
PA M simulira postupak generiranja niza zamjenom krajnje lijevog nezavrnog znaka.
Dokaz da PA M prihvaa niz x praznim stogom ako i samo ako gramatika G generira niz x
provodi se matematikom indukcijom, te je mogue dokazati:
PA M prolazi slijedom prijelaza (q,x,S) > (q,,) ako i samo ako gramatika generira niz x
postupkom zamjene krajnjeg lijevog nezavrnog znaka.
i) Za prazan niz
ii) (q, x, S) > (q, , ) ako i samo ako Sx

2. Opis algoritma
Rjeenje zadatka sastoji se od tri dijela:
1. Svoenje produkcija gramatike na Greibachov normalni oblik
2. Pretvorba gramatike u potisni automat
3. Simulacija potisnog automata izgraenog iz zadane gramatike

2.1. Svoenje produkcija gramatike na Greibachov normalni oblik

Svoenje produkcija gramatike na Greibachov normalni oblik ostvareno je nizom
algoritama koji omoguuju da se gramatika ne sastoji od beskorisnih znakova, jedininih
produkcija, te epsilon produkcija, to omoguuje zadavanje kontekstno neovine gramatike
u bilo kojem obliku (tj. S->, pri emu je niz koji se sastoji od zavrnih i nezavrnih
znakova, ili od znaka epsilon)
Algoritmi za odbacivanje mrtvih znakova i odbacivanje nedohvatljivih znakova, te algoritmi
za odbacivanje epsilon produkcija i jedininih produkcija istovjetni su algoritmima opisanim
u udbeniku, te se izvode tono odreenim redoslijedom. Najprije se izvodi algoritam
odbacivanja mrtvih znakova, zatim nedohvatljivih, te zatim algoritmi odbacivanja epsilon
produkcija i jedininih produkcija. Odabir redoslijeda izvoenja posljednja dva algoritma
nebitan je za krajnji oblik produkcija.
Algoritam za pretvorbu produkcija gramatike u Greibachov normalni oblik poneto se
razlikuje od algoritma navedenog u udbeniku. Algoritam naveden u udbeniku ne koristi
se zbog kompleksnosti izvedbe. Kao pomo izvedenom algoritmu koristi se algoritam
rjeavanja krajnje lijevog nezavrnog znaka takoer prikazan u udbeniku,
Produkcije u Greibachovom obliku su oblika: S->a gdje je niz nezavrnih znakova ili
prazan niz. Algoritam se izvodi na sljedei nain:
1. produkcije koje su oblika A->a ili A->a ( je skup nezavrnih znakova) su u
Greibachovom obliku i dodaju se u listu produkcija u Greibachovom obliku
2. za produkcije oblika A-> primjenjuje se algoritam rjeavanja krajnje lijevog
nezavrnog znaka. Nakon primjene algoritma rjeavanja krajnje lijevog nezavrnog
znaka produkcije su u jednom od dva mogua oblika: A->a pa se dodaju u listu
produkcija u Greibachovom obliku ,ili A ->a, gdje je skup zavrnih i nezavrnih
znakova
3. za sve produkcije oblika A ->a svi zavrni znakovi zamijene se nezavrnim
znakom [b],te se dodaju produkcije [b]->b .
Nakon treeg koraka sve produkcije su u Greibachovom normalnom obliku , pogodnom za
pretvorbu u potisni automat.
2.2. Pretvorba gramatike u potisni automat
U drugom dijelu vri se pretvorba kontekstno neovisne gramatike u potisni automat PA M
koji prihvaa praznim stogom. Kao to je navedeno u tekstu zadatka PA se gradi prema
algoritmu prikazanom na predavanju (u udbeniku), takoer, objanjenom u uvodnom
poglavlju.

2.3. Simulacija PA
Kako se gradnjom potisnog automata iz kontekstno neovisne gramatike stvara
nedeterministiki potisni automat, njegova simulacija je rijeena na sljedei nain:
1. Za svaki uitani znak i za svako trenutno stanje na vrhu stoga provjeri da li postoji
mogunost odabira izmeu dvije ili vie akcija stoga. Idi na korak 3.
2. Ako postoji mogunost odabira izmeu dvije ili vie akcija stoga, odaberi prvu
prijei na korak 3 . Ostale mogunosti spremi na rezervni stog akcija, na ostale
rezervne stogove spremi trenutni niz, trenutno stanje stoga i znak koji je uitan
3. Pokuaj simulirati DPA dok ne uita cijeli niz(uvijek provjeravaj korak 1). Ukoliko
se nakon uitanog niza stog uspio isprazniti niz se prihvaa i zaustavlja se
simulacija. Ukoliko se stog nije ispraznio, ili ne postoje daljnji prijelazi, trenutni DPA
ne prihvaa niz. Sa rezervnih stogova skidaju se informacije o novom DPA kojeg
treba simulirati. Ako je rezervni stog niza prazan nema se to uitati, te se tek tada
donosi odluka da zadani PA ne prihvaa niz.
Ovim algoritmom ostvarena je struktura stabla pri simuliranju NPA. Algoritam je objanjen
na sljedeoj slici:

Slika 1: Simulacija potisnog automata

Kao to prikazuje Slika 1, u trenutku kada imamo mogunost odabira dvije akcije koje e
se izvesti nad stogom, odaberemo prvu a drugu stavimo na rezervni stog. U sljedeem
koraku imamo opet mogunost odabira dvije akcije stoga pa odabiremo prvu , a drugu
stavljamo na rezervni stog. Nakon toga do kraja simuliramo DPA i nakon to prvi DPA ne
prihvaa skidamo sa rezervnog stoga elemente koji sadre informaciju o novom DPA
6

(drugi odabir akcije stoga PA kojeg simuliramo (ljubiasti)), nakon toga simuliramo DPA do
kraja. Kako niti ovaj DPA ne prihvaa moramo se vratiti prema vrhu stabla na prvo gornje
mjesto grananja. Skidamo sa rezervnog stoga informacije o novom DPA (uti), simuliramo
do kraja DPA te ovaj DPA prihvaa i niz se prihvaa. Ako bilo koji DPA prihvati niz, NPA
prihvaa niz i simulacija se zaustavlja. U sluaju da niti jedan DPA ne prihvati niz se ne
prihvaa i simulacija se zaustavlja.

3. Programsko rjeenje
Za programski jezik odabran je Python, prvenstveno zbog toga to je Python objektno orijentiran i dijelom funkcijski programski jezik jednostavne sintakse. Odabran je
programski jezik koji je objektno orijentiran zbog toga to je program dizajniran na objektno
orijentiran nain: mogue je koristiti pojedine dijelove programa neovisno o drugim
dijelovima, smanjeno je nepotrebno ponavljanje koda, te je putem suelja objekta
ostvarena mogunost koritenja metoda jedino imajui saznanja o tome to pojedina
metoda radi, to prima kao argumente i to vraa kao argumente. Hijerarhijska struktura
klasa prikazana je u drugom dodatku na kraju dokumenta.
Svaka klasa u programskom jeziku Python ima metodu __init__koja je konstruktor klase.
Svaka metoda se kreira na nain:
defime_metode(self,argumenti):
tijelometode

Za pristup pojedinoj metodi klase potrebno je postojanje reference na objekt ,a to je

parametar self. Parametar self je parametar koji se uvijek nalazi u popisu argumenata
pojedine metode.Self parametar takoer omoguava koritenje objekata u vie razliitih
metoda. Kod poziva metode ne navodi se parametar self. Primjer kreiranja instanci neke
klase i pozivanje metoda je sljdei:
ime_instance=ime_klase()
foo=ime_instance.ime_metode(argumenti)

U programskom jeziku Python doputeno je viestruko nasljeivanje, tonije nasljeivanje

vie od jedne klase jednostavnim navoenjem klasa od kojih definirana klasa nasljeuje
metode i svojstva:
classnasljedjena(prva_klasa,druga_klasa):
def__init__(self,argumenti):
tijelometode
defmetoda1(self,argumenti):
tijelometode
....

Mogue je naslijeene klase koristiti u izvornom obliku, a mogue ih je prepraviti da rade

na nain koji predvia zadana klasa.
Kako je u tri dijela objanjeno rjeenje problema zadatka, na isti nain ukratko su navedeni
dijelovi programa.

3.1. Svoenje produkcija gramatike na Greibachov normalni oblik:

U ovom dijelu program se sastoji od niza klasa i metoda u klasama kojima se opisuju
elementi gramatike (nezavrni znakovi, zavrni znakovi te skup produkcija). Nezavrni
znakovi kojim se zadaju produkcije su iskljuivo velika slova abecede Zavrni znakovi su
mala slova abecede (u sluaju da se niz koji se ispituje sastoji od brojeva potrebno ga je
zadati slovima koji imaju jednako znaenje kao i zadani brojevi, npr 1=j).
Produkcije gramatike su smjetene u internoj strukturi programskog jezika Python rjenik
(eng. dictionary, mapping) koji slui kao hash tablica gdje su kljuevi nezavrni znakovi
gramatike, s pripadnim desnim stranama produkcije.
Produkcije gramatike zadaju se u obliku S->aA datotekom u kojoj je je svaka produkcija
navedena u jednoj liniji datoteke.
U nastavku teksta ukratko su objanjene pojedine klase, a cjelovit popis klasa i pripadnih
metoda dan je u tablici na kraju dokumenta.
Klasama zavrsni_znakovi i nezavrsni_znakovi definirane su metode za kreiranje listi
zavrnih i nezavrnih znakova, metode koje provjeravaju jesu li pojedini znakovi u listi
zavrnih znakova, odnosno u listi nezavrnih znakova, te ispisuju pojedine liste.
Ekvivalentne metode u obje klase imaju jednaka imena radi jednostavnijeg koritenja.
Klasa produkcije koja je naslijeena klasa klase nezavrni znakovi sadri metode koje
omoguuju dodavanje produkcija gramatike u rjenik produkcije. Dodavanje produkcija u
rjenik produkcije obavlja se pomou metode dodaj_produkciju(koja prima argumente
nezavrni znak i desnu stranu produkcije, a vraa rjenik produkcije) na sljedei nain:
produkcije= {}
...
self.produkcije[nezavrsni]=[]
...
self.produkcije[nezavrsni].append(desna_strana_produkcije)

Kao to se vidi u gornjem primjeru prvo je potrebno instancirati rjenik podataka, zatim
omoguiti da za svaki nezavrni znak moe postojati vie desnih strana produkcije koje
dodajemo u listu, koja je instancirana u drugom redu. Nakon toga, ugraenom metodom
append dodajemo desnu stranu produkcije u rijenik podataka.
Ostale metode koje sadri klasa produkcije su metode za brisanje produkcija, ispis desnih
strana te ispis produkcija gramatike u obliku : { 'nezavrsni_znak':['aB','BC','$'],....} koji je
ekvivalentan produkcijama gramatike u obliku: nezavrni_znak->aB|BC|$
Sljedea klasa izraz omoguava da se iz produkcija oblika A->bC koje su proitane iz
datoteke generiraju produkcije u rijenik podataka. Klasa izraz sadri jednu metodu:
dodaj_u_produkciju koja uitani niz u obliku A->bc razdvaja na lijevu stranu produkcije(
nezavrni znak) i na desnu stranu produkcije, te poziva metodu klase produkcije koja gradi
rijenik podataka. Za svaku proitanu desnu stranu produkcije poziva metodu klase
zavrni_znakovi koja dodaje zavrne znakove u listu zavrnih, te isto tako poziva metodu
klase nezavrsni_znakovi koja dodaje lijeve strane produkcije u listu nezavrnih znakova.
Sljedeih nekoliko klasa implementiraju algoritme za odbacivanje beskorisnih znakova,
rjeavanja epsilon produkcije te jedininih produkcija.
Klasa zivi_znakovi metodom izbaci_mrtve_znakove, te pomonim metodama koje provjeravaju
8

da li se neki znak nalazi u listi ivih implementiraju algoritam za odbacivanje mrtvih

znakova. Nakon izvravanja algoritma u rijeniku produkcije nalaze se samo produkcije koje
sadre ive znakove.
Klasa dohvatljivi_znakovi metodom izbaci_nedohvatljive_znakove te isto tako
pomonim metodama (sline metodama u klasi zivi_znakovi), implementira algoritam
odbacivanja mrtvih znakova. Nakon izvrenja algoritma u rjeniku produkcije nalaze se
produkcije koje u sebi ne sadre beskorisne znakove.
Ostale dvije klase koje su graom vrlo sline prethodno objanjenim klasama su:
epsilon_produkcije sa pripadnom metodama rijesi_epsilon (implementira osnovna dva koraka) i
izbaci_epsilon (odbacuju se na kraju epsilon produkcije koje smo prethodnim algoritmom
rijeili) , te klasa jedinicne_produkcije sa pripadnom metodom izbaci_jedinicne.
Nakon sreivanja produkcija gramatika prethodnim metodama, pristupa se pretvorbi
produkcija u Greibachov normalni oblik.
Klasa greibach sadri dvije metode: metodu krajnje_lijevi koja implementira algoritam
rjeavanja krajnje lijevog nezavrnog znaka, te metodu greibachov_oblik koja implementira
objanjen algoritam pretvorbe produkcija u Greibachov oblik.
Metodom u_greibacha klase greibachov_oblik, generiraju se dva skupa produkcija koja
su u Greibachovom obliku. Skup produkcija u svom ispisu razlikuje se od standardnog
oblika Greibachovih produkcija zato to ne koristi mogunost pretvorbe zavrnih znakova
koji se ne nalaze na krajnje desnom mjestu lijeve produkcije u nezavrne znakove u obliku
Xi, nego ih se ostavlja u zadanom obliku te se u skup produkcija dodaju dodatne
produkcije oblika ['zavrsni']->'zavrsni' u kojima zavrni znak ide sam u sebe(postao je
nezavrni znak izgledom jednak zavrnom znaku).Oblik je uveden radi jednostavnije
konstrukcije potisnog automata.
Nakon pozivanja metode greibachov_oblik sve produkcije su u Greibachovom normalnom
obliku te je mogue konstruirati potisni automat na temelju zadanih produkcija.

3.2. Konstrukcija PA
Konaan skup ulaznih znakova ostvaren je klasom skup_ulaznih koja je nasljeena klasa
od klasa greibachov_oblik. Klasa sadri metodu za dodavanje u skup ulaznih znakova
(ostvarena strukturom liste koja je u Pythonu takoer primitivni tip podataka), koji je jednak
skupu zavrnih znakova gramatike, metodu za ispitivanje je li znak u skupu ulaznih, te
metodu koja omoguava ispisivanje liste ulaznih znakova.
Konaan skup znakova stoga ostvaren je metodom listu_stoga ostvarenom u klasi
radni_stog.

Funkcija prijelaza prijelaz_PA ostvarena je rjenikom (dictionaryem) kojemu su kljuevi

trenutno uitan znak i trenutni znak na stogu, a pridruena im je akcija koja se odvija nad
stogom. Programski ostvarena funkcija prijelaza sadri samo dva ulazna elementa (znak
niza i znak stoga) radi jednostavnosti i injenice da potisni automat ima samo jedno stanje
koje ne utjee na akciju nad stogom. Ispis funkcije prijelaza je u standardnom obliku, npr.
&(q,a,S)=AB. Funkcija prijelaza ostvarena je klasom prijelazi_PA koja sadri
metode:generiraj_prijelazekoja na temelju produkcija u Greibachovom obliku generira
funkciju prijelaza prijelaz_PA. Kako za pojedini ulazni znak i znak stoga moe postojati
vie moguih akcija koje se trebaju obaviti na stogu (ovdje dolazi do izraaja
nedeterminizam PA), akcije se pri generiranju dodaju u listu. Prvo je potrebno inicijalizirati
rijenik, pa zatim listu, te tada dodavati u listu.
9

To inimo na sljedei nain:

prijelaz_PA={}
self.prijelaz_PA[self.znak,self.trenutnoStog]=[]
self.prijelaz_PA[self.znak,self.trenutnoStog].append(self.akcija_stog)

Ako ispiemo produkcije gramatike koji je dan u dodatnom primjeru izbacivanja

beskorisnih znakova iz gramatike, epsilon produkcija i jedininih produkcija , koji je dan u
cijelosti u odlomku Primjeri, izgledati e :
prod{'A':['bcA','$'],'C':['eA','$'],'B':['CD','ad'],'E':['ed',
'ac'],'D':['cDAwB','bDaE'],'S':['bAbE','aABc']}

Druga metoda je funkcija_prijelaza koja ispisuje funkcije prijelaza u standardnom obliku npr.
&(q,a,S)=AB, a koristi se podacima rijenika prijelaz_PA. Ispis funkcije prijelaza dan je u
primjerima.

3.3. Simulacija PA
Simulacija potisnog automata sastoji se od klase simulacija_PA koja se sastoji od dvije
metode: DPA_simulacija i NPA_simulacija. U metodi DPA_simulacija poinje se sa
simulacijom deterministikog potisnog automata. Ukoliko za uitani znak niza i znak sa
vrha stoga postoje dvije ili vie mogunosti prijelaza izabire se prva mogunost, a podaci o
ostalim mogunostima prijelaza spremaju se na stog rezervna (ostvaren podatkovnom
strukturom liste). Na stog se sprema ureena trojka [niz, stog, akcija] koja sadri podatke o
sljedeem DPA kojeg treba simulirati. Ukoliko prethodni DPA ne prihvaa zadani niz
poziva se metoda NPA_simulacija. U njoj se skidaju sa stoga informacije o sljedeem
DPA, ukoliko u tom DPA doe do grananja spremaju se podaci na listu. Nakon svake
simulacije DPA provjerava se rezervni stog i simulacija se izvrava dok ima elemenata na
stogu ili dok DPA ne prihvati niz. U sluaju da DPA prihvati niz, izgraeni potisni automat
prihvaa niz i simulacija se zavrava. Ako se rezervni stog isprazni, a posljednji DPA nije
prihvatio niz, izgraeni potisni automat ne prihvaa niz.

4. Primjeri
U nastavku su dana 3 primjera gramatike za koje se grade pripadni potisni automati. Na
CD-u koji je priloen uz dokumentaciju nalazi se uz kod programa i 2 datoteke s ispitnim
primjerima te datoteka s pripadnim nizovima za testiranje.
4.1. Primjer 1
Primjer 1. dan je samo kao primjer izbacivanja beskorisnih znakova, epsilon i
jedininih produkcija iz zadane gramatike, te pretvorba u Greibachov normalni oblik i
konstrukcija potisnog automata. Primjer je isproban tijekom testiranja programa te nije
zadan posebnom datotekom, ali je dan ispis rezultata.
Neka su zadane produkcije gramatike:
S>bAbE

B>DC

D>cDAwB

S>aABc

B>ad

D>bDae

A>bcA

C>eA

E>ed

10

A>$

C>$

E>ac

Nakon izvravanja programa pozivanjem odgovarajuih metoda ispis je sljedei:

gizmo@mogwai:~$pythontesting.py
produkcije:{'A':['bcA','$'],'C':['eA','$'],'B':['CD','ad'],'E':
['ed','ac'],'D':['cDAwB','bDaE'],'S':['bAbE','aABc']}
zivi{'A':['bcA','$'],'C':['eA','$'],'B':['ad'],'E':['ed','ac'],
'S':['bAbE','aABc']}
dohvatljivi{'A':['bcA','$'],'B':['ad'],'E':['ed','ac'],'S':
['bAbE','aABc']}
bezepsilon:{'A':['bcA','bc'],'B':['ad'],'E':['ed','ac'],'S':
['bAbE','aABc','bbE','aBc']}
bezjedinicnih{'A':['bcA','bc'],'B':['ad'],'E':['ed','ac'],'S':
['bAbE','aABc','bbE','aBc']}

Posljednja produkcija je produkcija koja je spremna na pretvorbu u Greibachov normalni

oblik produkcija koji izgleda:
greibach{'A':['bcA','bc'],'c':['c'],'B':['ad'],'E':['ed','ac'],
'd':['d'],'S':['bAbE','aABc','bbE','aBc'],'b':['b']}

Na temelju produkcija u Greibachovom normalnom obliku kreiramo potisni automat za

zadanu gramatiku. Najprije generiramo listu ulaznih znakova, listu znakova stoga, funkciju
prijelaza,...:
lista_ul['b','c','a','d','e']
lista_stoga:['A','d','B','E','b','S','c']
FUNKCIJAPRIJELAZAPA
&(q,b,A)=cA
&(q,b,A)=c
&(q,a,B)=d
&(q,e,E)=d
&(q,a,E)=c
&(q,b,S)=AbE
&(q,a,S)=ABc
&(q,b,S)=bE
&(q,a,S)=Bc
&(q,b,b)=$
&(q,c,c)=$
&(q,d,d)=$

funkcija{('d','d'):['$'],('b','A'):['cA','c'],('e','E'):['d'],
('a','S'):['ABc','Bc'],('b','S'):['AbE','bE'],('a','E'):['c'],
('a','B'):['d'],('c','c'):['$'],('b','b'):['$']}

Kao to je objanjeno u tekstu ona je samo funkcija uitanog znaka niza i trenutnog znaka
na stogu (jer potisni automat ima samo jedno stanje o kojem ne ovisi akcija koja e se
11

izvriti nad stogom). Ovdje je, takoer mogue primijetiti nedeterminizam izgraenog
potisnog automata. Za pojedine znakove niza i za znak sa vrha stoga mogua je vie od
jedne akcije, npr. za uitani znak 'a', ako se na stogu nalazi 'S'.

4.2. Primjer 2
Gramatika koja generira nizove oblika aibjckdjei . Produkcije zadane gramatike su sljedee:
S>aAe

B>bBd

A>bBd

B>cC

A>aAe

C>cC

C>$

Nakon to je program pozvan generirana je gramatika i pretvorena u normalan Greibachov

oblik su sljedei:
produkcije{'A':['bBd','aAe'],'S':['aAe'],'B':['bBd','cC'],'C':
['$','cC']}
zivi{'A':['bBd','aAe'],'S':['aAe'],'B':['bBd','cC'],'C':['$',
'cC']}
dohvatljivi{'A':['bBd','aAe'],'S':['aAe'],'B':['bBd','cC'],'C':
['$','cC']}
epsilon{'A':['bBd','aAe'],'S':['aAe'],'B':['bBd','cC','c'],'C':
['cC','c']}
jedinicne{'A':['bBd','aAe'],'S':['aAe'],'B':['bBd','cC','c'],'C':
['cC','c']}
greibach{'A':['bBd','aAe'],'C':['cC','c'],'B':['bBd','cC','c'],
'e':['e'],'d':['d'],'S':['aAe']}

Uneseni niz: aabcdee izgraeni potisni automat prihvaa na sljedei nain :

POCETAK['S']
NIZaabcdee
zaulazniznakazaznaknastoguS=['Ae']
STOG:['e','A']
zaulazniznakazaznaknastoguA=['Ae']
STOG:['e','e','A']
zaulazniznakbzaznaknastoguA=['Bd']
STOG:['e','e','d','B']
zaulazniznakczaznaknastoguB=['C','$']
STOG:['e','e','d','C']
nemadefiniranogprijelaza
DPASENEPRIHVACA,POKUSAVAMDALJESIMULIRATI
NPA
NAREZERVNOMSTOGU:['dee',['e','e','d','C'],'$']
STOG:['e','e','d']
ZNAKdakcijad

12

STOG['e','e']ZNAKeakcijae
STOG['e']ZNAKeakcijae
STOG[]DPASEPRIHVACA

Uneseni niz:aabcded izgraeni potisni automat ne prihvaa :

POCETAK['S']
NIZaabcded
zaulazniznakazaznaknastoguS=['Ae']
STOG:['e','A']
zaulazniznakazaznaknastoguA=['Ae']
STOG:['e','e','A']
zaulazniznakbzaznaknastoguA=['Bd']
STOG:['e','e','d','B']
zaulazniznakczaznaknastoguB=['C','$']
STOG:['e','e','d','C']
nemadefiniranogprijelaza
DPASENEPRIHVACA,POKUSAVAMDALJESIMULIRATI
NPA
NAREZERVNOMSTOGU:['ded',['e','e','d','C'],'$']
STOG:['e','e','d']
ZNAKdakcijad
STOG['e','e']ZNAKeakcijae
STOG['e']NPASENEPRIHVACA

4.3. Primjer 3
Za primjer pretvorbe gramatike u potisni automat uzeta je gramatika koja generira nizove
{0,1,2} u kojoj nema uzastopnog ponavljanja niza 01 (zadatak preuzet iz auditornih vjebi
uz dodane mrtve znakove, nedohvatljive , epsilon produkcije te jedinine produkcije):
Produkcije gramatike su:
S>nA|jS|dS|$|D
A>nA|jB|dS|$|E
B>nC|jS|dS|$
C>nA|dS|$
D>E
E>DF
F>njd

uz to dodani su mrtvi znakovi: D i E te nedohvatljiv znak F

Nakon sto pozovemo program ispisi sreivanja gramatike su sljedei:
produkcije{'A':['nA','jB','dS','$','ED'],'C':['nA','dS','$'],'B':
['nC','jS','dS','$'],'E':['DF'],'D':['E'],'F':['njd'],'S':['nA',
'jS','dS','$']}
zivi{'A':['nA','jB','dS','$'],'C':['nA','dS','$'],'B':['nC',
'jS','dS','$'],'F':['njd'],'S':['nA','jS','dS','$']}

13

dohvatljivi{'A':['nA','jB','dS','$'],'C':['nA','dS','$'],'B':
['nC','jS','dS','$'],'S':['nA','jS','dS','$']}
epsilon{'A':['nA','jB','dS','n','j','d'],'C':['nA','dS','n',
'd'],'B':['nC','jS','dS','n','j','d'],'S':['nA','jS','dS','n',
'j','d']}
jedinicne{'A':['nA','jB','dS','n','j','d'],'C':['nA','dS','n',
'd'],'B':['nC','jS','dS','n','j','d'],'S':['nA','jS','dS','n',
'j','d']}
greibach{'A':['nA','jB','dS','n','j','d'],'C':['nA','dS','n',
'd'],'B':['nC','jS','dS','n','j','d'],'S':['nA','jS','dS','n',
'j','d']}

Izgraeni potisni automat je :

listaulaznih:['n','j','d']
['A','C','B','S']
lista_stoga:['A','C','B','S']
FUNKCIJAPRIJELAZAPA
&(q,n,A)=A
&(q,j,A)=B
&(q,d,A)=S
&(q,n,A)=$
&(q,j,A)=$
&(q,d,A)=$
&(q,n,C)=A
&(q,d,C)=S
&(q,n,C)=$
&(q,d,C)=$
&(q,n,B)=C
&(q,j,B)=S
&(q,d,B)=S
&(q,n,B)=$
&(q,j,B)=$
&(q,d,B)=$
&(q,n,S)=A
&(q,j,S)=S
&(q,d,S)=S
&(q,n,S)=$
&(q,j,S)=$
&(q,d,S)=$

Kada se za jednak ulazni niz kao u drugom primjeru simulira trei primjer rezultat
simulacije je sljedei (primjer unoenja niza znakova koji nisu u skupu ulaznih znakova):
POCETAK['S']

14

NIZaabcdee
znakanijeuskupuulaznih

Te se simulacija zaustavlja.
za niz njdnjd (012012):
POCETAK['S']
NIZnjdnjd
zaulazniznaknzaznaknastoguS=['A','$']
STOG:['A']
zaulazniznakjzaznaknastoguA=['B','$']
STOG:['B']
zaulazniznakdzaznaknastoguB=['S','$']
STOG:['S']
zaulazniznaknzaznaknastoguS=['A','$']
STOG:['A']
zaulazniznakjzaznaknastoguA=['B','$']
STOG:['B']
zaulazniznakdzaznaknastoguB=['S','$']
STOG:['S']
NPASENEPRIHVACA

15

5. Zakljuak
Za potrebe prihvaanja kontekstno neovisnih jezika gradi se potisni automat. Ponekad je
jednostavnije napisati gramatiku koja generira odreene jezike te gramatiku pretvoriti u
potisni automat jednostavnim algoritmom, nego napamet graditi potisni automat.
Svoenje gramatike na Greibachov normalni oblik moe biti kompliciranije nego izgradnja
samog potisnog automata, ali zato moemo biti sigurni da smo ukoliko smo dobro
generirali gramatiku obuhvatili sve mogue sluajeve odreenog problema za razliku ako
PA gradimo iz glave. U ovom projektu objanjeni su svi koraci koje je potrebno napraviti da
bi se izgradio potisni automat iz kontekstno neovisne gramatike, te je simulacijom
pokazana da potisni automat izgraen iz kontekstno neovisne gramatike prema zadanim
pravilima prihvaa jezik ako i samo ako ga zadana gramatika generira.

16

6. Dodatci
6.1. Popis klasa i pripadnih metoda
Klasa

Metoda

zavrsni_znakovi

dodaj
_stri
ng

Kratak opis
Za zadani niz znakova u listu dodaje
one koji su zavrni
Dodaje samo jedan znak u listu
zavrnih znakova
Provjerava da li je znak u listi zavrnih
znakova
Ispisuje listu zavrnih znakova
Za zadani niz znakova u listu dodaje
one koji su nezavrni
Dodaje samo jedan znak u listu
nezavrnih znakova
Provjerava da li je znak u listi
nezavrnih znakova
Ispisuje listu nezavrnih znakova
Za zadani nezavrni znak i desnu
stranu dodaje u produkciju
Za zadani nezavrni znak brie
produkciju

dodaj
_si
gn
check_si
gn
i
spi
si
nezavrsni_znakovi

dodaj
_stri
ng
dodaj
_si
gn
check_si
gn
i
spi
s

produkcije

dodaj
_produkci
j
u
obri
si
_produkci
j
u

izraz
zivi_znakovi

dohvatljivi_znakovi

epsilon_produkcije

jedinicne_produkcije

greibachov_oblik

skup_ulaznih

radniStog

prijelazi_PA
simulacija_PA

Za zadani nezavrni znak i desnu

stranu brie desnu stranu zadane
obri
si
_desnu_stranu
produkcije
i
spi
si
Ispisuje produkcije
dodaj
_u_produkci
j
u
Iz stringa stvara rijecnik produkcija
dodaj
_zi
v
Dodaje znak u listu zivih
i
s_zi
v
Provjerava da li je znak u listi zivih
provj
eri
_l
i
stu
Ispisuje listu zivih znakova
Implementacija algoritma za izbacivanje
i
zbaci
_m rtve_znakove
mrtvih znakova
dodaj
_dohvatl
j
i
vi
Dodaje znak u listu dohvatljivih
Provjerava da li je znak u listi
i
s_dohvatl
j
i
v
dohvatljivih
provj
eri
_l
i
stu
Ispisuje listu dohvatljivih znakova
Implementacija algoritma za
i
zbaci
_nedohvatl
j
i
ve_znakove izbacivanjem nedohvatljivih znakova
Provjerava da li je zadana produkcija
i
s_epsi
l
on
epsilon
Implementacija algoritma bez brisanja
ri
j
esi
_epsi
l
on
epsilon produkcija
Brisanje epsilon produkcija nakon
i
zbaci
_epsi
l
on
primjene algoritma
i
s_j
edi
ni
cna
Provjera da li je produkcija jedinina
Implementacija algoritma za izbacivanje
i
zbaci
_j
edi
ni
cne
jedinicnih produkcija
Implementacija algoritma za rjeavanje
kraj
nj
e_l
i
j
evi
krajnje lijevog nezavrnog znaka
Primjena koraka 2 i 3 za pretvorbu u
u_grei
bacha
Greibachov normalni oblik
l
i
stu_ul
azni
h
Gradi listu ulaznih znakova
Provjerava nalazi li se znak u skupu
check_znak
ulaznih
i
spi
si
Ispisuje listu ulaznih znakova
l
i
stu_stoga
Gradi listu znakova stoga
Provjerava da li je znak u listi znakova
check_znak
stoga
dodaj
_naStog
Dodaje niz znakova na stog
i
spi
si
_radni
Ispisuje izgled stoga
ski
ni
Skida jedan element sa stoga
Provodi akciju stoga na temelju funkcije
akci
j
a_stog
prijelaza PA
trenutno_stog
Ispisuje trenutni znak na vrhu stoga
Na temelju produkcija u Greibachovom
generi
raj
_pri
j
el
aze
obliku generira funkciju prijelaza
funkci
j
a_pri
j
el
aza
Ispisuje generiranu funkciju prijelaza
DP A_si
m ul
aci
j
a
Ako izgraeni PA nije NPA simulira DPA
Ako je NPA , nakon odabira DPA prelazi
NP A_si
m ul
aci
j
a
na NPA simulaciju

17

6.2. Hijerarhijska struktura klasa

zavrsni_znakovi

nezavrsni_znakovi

produkcije
izraz

zivi_znakovi

dohvatljivi_znakovi

epsilon_produkcije

jedinicne_produkcije

greibachov_oblik

prijelazi_PA

radniStog

simulacija_PA

18

skup_ulaznih

7. Literatura
1. S. Srblji, Jezini procesori 1, Element, Zagreb, 2000.
2. Wikipedia, URL: http://en.wikipedia.org/wiki/Python_(programming_language),
(2.1.2007)
3. Funkcijsko programiranje u Pythonu,
URL: http://fly.srk.fer.hr/~ipozgaj/etc/tekstovi/fpup.html (30.12.2006)
4. Introduction to OOP with Python,
URL: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-method
(4.1.2007)

19