Messages

ok.. mmnt .. takze tam ako mam ten while { + B +B + B}, ked niekde bude chybat + tak sa to zotavi na VALUE alebo LPAR ?? ked je to tak, tak som ani zadanie spravne nepochopil
ale inac chlape teraz si ma uz uplne poplietol... ja mam ten kod asi uplne inak ako ma byt   napr vo while v error mam v podmienke aj symbol!=SEOF a v tych ostatnych funkciach posielam kde co...funguje mi to pekne, vypisuje co kde chyba, ale co z toho ked ten test aj tak asi nedam... to mam za to ze k tomu pristupujem intuitivne a nie podla ucebnic hehe... potom som mimo hry v takychto veciach

mimochodom H_D = H_C = H_B = H_A = E LPAR | E VALUE pokial sa nemylim...

ta kde je sulo? kto teraz vynesie rozsudok?

cenki, jedine v tom pripade mas totiz neasociativnu operaciu (*).. to vyplyva z gramatiky.. a ked sa Ti uz raz vyskytne * tak ho dalej uz neocakavas... cize neposielas E MUL do druheho d ...


ale to K na konci mi vysvetlite preco to nevadi, ked si za tym tak stojite 

[| K]

thx sulo, konečne dakto kto ujasnil a nie len my čo sme odhadovali myšlienkové pochody nášho pána cvičiaceho.
od ursus:
a->b{"+" b}            //bude: b(PLUS|H_b|K), b(PLUS|H_b|K)
b->c["-" b]             //bude: c(MINUS|H_b|K), b(K)
c->d["*" d]            //bude: d(MUL|H_d|K), d(K)
d->value | "(" a ")"  //bude: a(RPAR)
Takto?

Takto


a->b{"+" b}            //bude: b(PLUS|H_b|K), b(PLUS|H_b|K)
b->c["-" b]             //bude: c(MINUS|H_b|K), b(K)
c->d["*" d]            //bude: d(MUL|H_d|K), d(K)
d->value | "(" a ")"  //bude: a(RPAR | K)

si si tym isty?? ja by som tam K neposielal... v K mas totiz uz od mainu aj SEOF a ked to a-cko volas ked Ti pride "(" .. no a potom predsa nemozes len tak dostat SEOF kym sa Ti neuzavrie zatvorka... okrem toho ostatne symboly sa Ti do K znovu postupne nazbieraju...  ale opravte ma ked sa mylim

[H_D | K]

thx sulo, konečne dakto kto ujasnil a nie len my čo sme odhadovali myšlienkové pochody nášho pána cvičiaceho.
od ursus:
a->b{"+" b}            //bude: b(PLUS|H_b|K), b(PLUS|H_b|K)
b->c["-" b]             //bude: c(MINUS|H_b|K), b(K)
c->d["*" d]            //bude: d(MUL|H_d|K), d(K)
d->value | "(" a ")"  //bude: a(RPAR)
Takto?

jj tiez si myslim akurat

a->b(E PLUS | H_B | K){"+" b(E PLUS | H_B | K)}
b->c(E MINUS | H_C | K)["-" b(E MINUS | H_C | K)]
c->d(E MUL | H_D | K)["*" d(H_D | K)]
d->value | "(" a(E RPAR) ")"

si myslim

BTW. este k 3tej pisomke:
Gramatika:
a ["*" b]
c {"/" d}
bude:
a(E MUL|H_b|K)
b(K)
c(H_Div|H_d|K)
d(H_Div|H_d|K) alebo d(H_d|K) alebo d(K) // ak su tam zatvorky {}
Lebo sa nam trochu rozchadzaju nazory na toto

Pre: X → C {"/" D}
bude volanie pre D:

Code [Select] Expand

D(E DIV | H_D | K);

Lebo po D-čku môžu vrámci pravidla X nasledovať ďalšie "/" a D-čka, keďže je tam cyklus {}.
Pre podmienku [] by už bolo len K.

ok a co presne je to H_d ?? co sa tam nachadza?

ok takze doku...

mam polymorfne MUL_OP (nasobenie, zretazenie)
formalny zapis typovej kontroly by mohol byt nejak takto

MUL_OP: MUL(a,b) => a x b -> T(a,b) E1 : T1  E2 : T2
----------------------------------------------------
             MUL_OP(T1, T2) E : T(T1, T2)

   nejake namietky, navrhy?? opravte ma ked viete

BTW. este k 3tej pisomke:
Gramatika:
a ["*" b]
c {"/" d}
bude:
a(E MUL|H_b|K)
b(K)
c(H_Div|H_d|K)
d(H_Div|H_d|K) alebo d(H_d|K) alebo d(K) // ak su tam zatvorky {}
Lebo sa nam trochu rozchadzaju nazory na toto

zase tie tajomne mnoziny first a follow  ocividne nikto tomu poriadne nerozumie... alebo ste skupi na know-how??

Dokumentácia (podľa prednášok): 
o  Formálny zápis typovej kontroly
o  Špecifikácia typovej kontroly (rozpísať triedy operácií)

Co to je Formalny zapis typovej kontroly ?  Tie cudne veci v prednaske co je medzi nimi ciara ?   

  to fakt treba??  neznasam dokumentaciu! ta nic no idem to pozriet.... 

antil kiprest: diky, asi uz to ide... hadzalo mi to blbe vysledky lebo som volal printTree(Expr());  ,pricom som si mal ulozit do premennej tree=Expr(); a az potom printTree(tree);

A este ako ma vyzerat ta dokumentacia?

dokumentacia?  to fakt neviem.. co take by tam akoze malo byt??

ano, treba sa potrapit aj s printom.

no ok, a ako ma teda vyzerat vypis stromu napriklad pre ten spomenuty vyraz 2*3*4 ?

niektore skupiny maju v zadani c. 4 aj pracu s typom float, nic zlozite

jasne ze nie..  a printTree je tiez sucast zadania??  my sme to cele zadanie mali od vaclavika podane iba ustne a na nic take si nespominam 

Robim zadanie 4 podla tych Kollarovych prezentacii a mam taky problem. Asi mam uz vsetko nakodene ako ma byt  . Funguje mi aj ked v main -e zavolam printTree(Expr()); (pri vstupe napr. 2*3*4 vypise: * 2 * 3 4)

Problem je ze neviem ako mam transformovat ten polymorfny strom na monomorfny, skusal som v tych funkciach(Expr, Mul, Term) volat TypeCheck(tree) a potom Evaluate(tree) ale pretransformuje mi to len jeden podstrom (napr. vstup 2*3*4 (asoc. sprava) : v 3*4 mi zmeni to polymorfne krat(MUL_OP) na int krat(MUL_INT_OP), ale dalsie krat uz to nezmeni, cize vypocet vyrazu bude 12).
Kedy a kde vlastne to Evaluate a TypeCheck treba v kode volat?
Vdaka

EDIT: a este otazka, ak idem napr. nasobit int*float ma to vyhodit Type Error ? Ci iba pri string*int (resp. string*float) ?

polymorfny na monomorfny trasformujes v TypeCheck(tree)... v maine najprv volas expr(), to Ti vrati tree.. mozes si to ulozit do premennej.. potom zavolas (tiez v maine) TypeCheck(tree).. to Ti prerobi strom na monomorfny a vrati Ti typ.. nakoniec volas (opat v maine) Evaluate(tree) to Ti vyhodnoti strom a vrati monotype* cell.. co je vlastne vysledok...   

mimochodom s kym mas cvika?? my sme napriklad float ani nemali... iba int a string.. v kazdom pripade pri nekompatibilnych typoch by Ti mal typeCheck vratit typ AnyType...

niekto vazne keby ste mali 27/28 slide z osmej prednasky bol by som velmi vdacny

Uf, to presne neviem ale ak mas:
SetType H_Term = E VALUE | E LPAR;
a potom:
#define H_Div H_Term
#define H_Mul H_Div
#define H_Expr H_Mul
tak takto.

heh.. no neviem to zas zavisi od gramatiky.. ale to Ti vazne vravel vaclavik ze takto to ma byt?? myslim ten priklad predtym...
odhliadnuc od tych mnozin H_... aspon tie b-cka

a->b(H_b|E PLUS|K){"+" b(K|E PLUS)}
b->c(H_b|E MINUS|K)["-" b(K|E MINUS)]
c->d(H_d|E MUL|K)["*" d(K)]
d->value | "(" a(E RPAR|K) ")"

dla mna

[moze my niekto please vysvetlit ake mnoziny budem posielat do tych dalsich funkcii?]

moze my niekto please vysvetlit ake mnoziny budem posielat do tych dalsich funkcii?

napriklad pre
a->b{"+" b}
b->c["-" b]
c->d["*" d]
d->value | "(" a ")"

okej cize napr pre b

int b(K){
 leftOp = c(??);
 if(blabla){
   ...
   rightOp = b(??);
 }
}
proste ako z gramatiky z fleku urcim co tam mam posielat? thx
najskor asi mierene na miselku kedze pan V. to "zabudol" vysvetlit

Podla pana V. som pri odovzdavani pochopil ze:
a->b(H_b|E PLUS|K){"+" b(K)}
b->c(H_b|E MINUS|K)["-" b(K)]
c->d(H_d|E MUL|K)["*" d(K)]
d->value | "(" a(E RPAR|K) ")"

a co je to H_b a H_d

co vlastne moze obsahovat ten string ? (ked mam zadanie */)  ma zacinat malym pismenom a po nom mozu nasledovat aj velke pismena aj znaky ako $%# ??
resp akym znakom by mal koncit string??

musi zacinat malym pismenom a potom to uz je jedno ake znaky pojdu... a konci to ako cislo bud tam das znamienko alebo enter a tym ukoncis vstup... :-)))

cize hocijake znaky okrem * a / tam mozu byt jo?? ale ono je to vlastne fuk.. do zdrojaku mi cumiet aj tak nebude.. spravim na velke a male pismena a mf... 

co vlastne moze obsahovat ten string ? (ked mam zadanie */)  ma zacinat malym pismenom a po nom mozu nasledovat aj velke pismena aj znaky ako $%# ??
resp akym znakom by mal koncit string??

njo, ja tak robim, aj ked si myslim ze je to jedno predsa

akurat ze tam mas nove typy ktore by Ti syn analyzator vypisoval ako chybu, ak by si ho nerozsiril.. ale inak je to jedno, mas pravdu..

btw neviete niekto jednoducho vysvetlit na co ma ten syntakticky strom vlastne sluzit??? resp ako ma fungovat, co ma riesit...  neviem si pomoct ale to zadanie mi pripada ako keby sa dalo vyriesit zopar ifmi na zaklade typu prveho operandu... int alebo string...a davaj nasobim alebo zretazujem 

aj mna to napadlo... podla mna by sa to dalo takto spravit... :-)

nj ale s tym keby som prisiel za vaclavikom rovno sevas by mi povedal

njo, ja tak robim, aj ked si myslim ze je to jedno predsa

akurat ze tam mas nove typy ktore by Ti syn analyzator vypisoval ako chybu, ak by si ho nerozsiril.. ale inak je to jedno, mas pravdu..

btw neviete niekto jednoducho vysvetlit na co ma ten syntakticky strom vlastne sluzit??? resp ako ma fungovat, co ma riesit...  neviem si pomoct ale to zadanie mi pripada ako keby sa dalo vyriesit zopar ifmi na zaklade typu prveho operandu... int alebo string...a davaj nasobim alebo zretazujem 

k tomu 4temu zadaniu.. vaclavik na cviku hovoril ze na vstup len syntakticky spravne retazce.. to znamena ze to mame dorabat do 2ky, kde este nie je syntakticka analyza??

no nemam dobreho slova k dneskajsku

taze nic z toho?? vidis si si mohol radsej pospat 

kto by mi vedel vysvetlit polopatisticky to tretie zadanie? :/

co konkretne??

mimochodom z tych follow a first som tiez debil, nevie mi to niekto vysvetlit co to vlastne su za mnoziny a kde sa v kode vyskytuju??  z tych materialov som to akosi nechytil

okej som mimo, podla coho a kde davam ake parametre pre check a error ? 

pre check(int n, SetType K) davas parameter n index chybovej hlasky z mnoziny

napr

char *errmsg[]={
                "Ocakava sa hodnota alebo lava zatvorka (",
                "Ocakava sa operator /",
                "Ocakava sa operator * alebo /",
                "Ocakava sa operator *",
                "Ocakava sa operator * alebo prava zatvorka )",
                "Ocakava sa operator alebo prava zatvorka"
                };

a K je mnozina symbolov, ktore su na danom mieste pripustne..

check to iste dalej posiela do error(...) v pripade ze symbol ktory cekujes nepatri do mnoziny K