Messages

[urcit vstah medzi FIRST(D) a H(D) - to iste aj pre FIRST(C) a H(C)]

a este k tej istej ulohe podotazka urcit vstah medzi FIRST(D) a H(D) - to iste aj pre FIRST(C) a H(C)

any suggestions??

mne to pride ako toto: H(D) = FIRST(D) - e (prazdny symbol)   .. ale nie som si isty ci je rec o tomto

a ohen, mas pravdu s tym checkom, tam nemaju byt 'a' a 'b'
ten switch som s nepochopitelnych dovodou nahradil ifmy    proste chyba okej,   ale errory vyznam urcite maju... ved predsa ked cakas 'a' vyifujes to a zistis ze tam nie je, tak je to chyba, a vypises error

na tie errory som sa pytal, lebo som si nebol isty...  a ohladom toho HY co si pisal predtym by to aj mna zaujimalo... ci pri X ma byt zahrnute HY. dobra poznamka

HY tam nema byt, uz to bolo zodpovedane

[A->{Db l Ca}]

este by som sa vratil k tomuto A->{Db l Ca}


void A(symset K){

check (HD | HC | K);

while((sym) & (HD | HC )){    //tu by tiez nemaly byt 'a' ani 'b' myslim, switch nepusti

 check(HD | HC | K);             //tymto checkom si nie som isty..  jeden taky je uz pred while a navyse podmienka wo while zarucuje ze by zbehol bez
                                          //  chyby.. taze je asi zbytocny
 switch (sym){

  case HD: D(HD | b | HC | K );   //tu by malo byt 'b' ale nie 'a', pretoze 'b' v tejto vetve nasleduje ale 'a' je zase az sa switchom
  if(sym == b)
     getsymbol();
  else
     error(HD | HC | K);        //tu opat nema zmysel 'a' ani 'b'

  case HC: C(HD |HC | a | K);     //tu je to naopak, cize  'b' nie, 'a' ano
  if(sym == a)
       getsymbol();
  else
      error(HD| HC |K);     //tu opat nema zmysel 'a' ani 'b'

  check(HD | HC | K);    /a tento chcek by mal byt ten isty ako pred while
  }
}


co myslite??

[3. Upravte bezkontext gramatiku A-> abC | a{B} na LL(1). Pre upravenu gramatiku spravit syntakticky analyzator pomocou procedur Check a Error.]

Tak ako ma byt ten priklad spravne ?

dalej otazka 3. Upravte bezkontext gramatiku  A-> abC | a{B} na LL(1). Pre upravenu gramatiku spravit syntakticky analyzator pomocou procedur Check a Error.

ten prevod tu uz bol, cize  A -> a (bC | {B})

no ja myslim ze toto je OK :

void A(symset K){

if(sym == a)
   getsymbol();
else
   error(b | HB | K);

check(b | HB | K);

switch (sym){
   case b:
       getsymbol();
       C(K);
       break;
   case HB:
       while(sym & HB){
           B(HB | K);
           check(HB | K);
       }
       break;
   default: break;     
}

}

X -> A[B|C] E 

X(symbolset K){

A(HB | HC | HE | K);

check(HB| HC | HE | K);

if(sym in (HB or HC) ) {
   switch(symbol){
      case HB: B(HE| K); break;
      case HC: C(HE| K); break;
      default: error(HE | K);break;               //nie je tento error zbytocny??
   }
}

E(K);

}

       break;
   default:                    //tu ma zmiatlo to ze v tej alternative moze nastat aj prazdna vetva, cize case HD nastane len ak tam bude
       if(!(sym & K))         //aspon jedno volanie B ale ak by to bol koniec retazca, tak by ten klasicky default vypisal error,
           error(K);           //co by nebolo korektne... jedine co ma napadlo ako osetrenie je takato podmienka.. nazory??
}

}

Tam do toho defaultu daj len break; , lebo ano, moze nastat aj prazdna vetva, cize error nie je namieste. Do toho switcha uz vdaka tomu checku pred nim nepride nic co tam nema ist, cize ta podmienka v defaulte by bola zbytocna ajtak.

vidis, to ma nenapadlo, jake jednoduche fajn, diks

[3. Upravte bezkontext gramatiku A-> abC | a{B} na LL(1). Pre upravenu gramatiku spravit syntakticky analyzator pomocou procedur Check a Error.]

dalej otazka 3. Upravte bezkontext gramatiku  A-> abC | a{B} na LL(1). Pre upravenu gramatiku spravit syntakticky analyzator pomocou procedur Check a Error.

ten prevod tu uz bol, cize  A -> a (bC | {B})

a synt anal

void A(symset K){

if(sym == a)
   getsymbol();
else
   error(b | HB | K);

check(b | HB | K);

switch (sym){
   case b:
       getsymbol();
       C(K);
       break;
   case HB:
       while(sym & HB){
           B(HB | K);
           check(HB | K);
       }
       break;
   default:                    //tu ma zmiatlo to ze v tej alternative moze nastat aj prazdna vetva, cize case HD nastane len ak tam bude
       if(!(sym & K))         //aspon jedno volanie B ale ak by to bol koniec retazca, tak by ten klasicky default vypisal error,
           error(K);           //co by nebolo korektne... jedine co ma napadlo ako osetrenie je takato podmienka.. nazory??
}

}

a ohen, mas pravdu s tym checkom, tam nemaju byt 'a' a 'b'
ten switch som s nepochopitelnych dovodou nahradil ifmy    proste chyba okej,   ale errory vyznam urcite maju... ved predsa ked cakas 'a' vyifujes to a zistis ze tam nie je, tak je to chyba, a vypises error

ok, este mi zopar veci zo zotavenia nie je jasne, takze otazka do plena:

A -> X [a Y] {Z}

A(symbolset K){

X(a | HY | HZ | K);

check(a| HZ | K);

if(sym == a ) {
   getsymbol();
   Y(HZ | K);
}

check(HZ | K);
while (sym & (HZ)){
   Z(HZ |K);
   check(HZ | K);
}


}

hned hore v check(a | HZ | K);  nema byt HY pretoze sa Y v [a Y] vyskytuje az za a, cise je tam if a tak dalej... s tym suhlasim, aj z prednasok mi to takto vyplynulo..

ale ako je to s volanim X(a | HZ | HY | K); ?? ma alebo nema tam byt HY ?  ma zmysel ze sa bude zotavovat na Y, ked nenajde v retazci 'a' ?

co si o tom myslite?

[A->{Db l Ca}]

Este ma zaujima ten syntakticky analyzator so zotavenim pre jazyk LL(1): A->{Db l Ca} kde H(D) a H(C) su zname.

void A(symset K){

check(HD | b | HC | a | K);

while(sym& (HD | HC)){
   if(sym & HD){
   D(HD | b | HC | a | K );
   if(sym == b)
      getsymbol();
   else
      error(HD | b | HC |a| K);
   }
   if(sym & HC){
   C(HD | b |HC | a | K);
   if(sym == a)
        getsymbol();
   else
       error(HD| b |HC |a |K);

   check(HD | b | HC |a| K);
   }
}


nejak takto??
]

[1. Syntakticky analyzator so zotavenim pre jazyk LL(1): A->{Db l Ca} kde H(D) a H(C) su zname. Urcit vstah medzi FIRST(D) a H(D) - to iste aj pre FIRST(C) a H(C)]

mne vyslo tak isto  beer1

eej, parada!! 

1. Syntakticky analyzator so zotavenim pre jazyk LL(1): A->{Db l Ca} kde H(D) a H(C) su zname.
Urcit vstah medzi FIRST(D) a H(D) - to iste aj pre FIRST(C) a H(C)


??

hm vztah medzi first(D) a H(D) ??  nie je to len toto  H(D) = first(D) - E   ?

treba napisat akym postupom (pouzitim akych pravidiel) sme sa dostali k vyslednemu vyrazu a + b - c = d * e  

EDIT: cize potrebujeme bezkontextovu gramatiku

tak skusim

a+b-c=d*e

expr -> eq [("+" | "-" | "*" ) expr]
eq -> id ["=" id]
id -> ("a" | "b" | ... | "z" )


             expr
          /    |    \
         eq   "+"   expr
        /          /   |    \
     id        eq    "-"    expr
     /        /            /   |    \
   "a"      id          eq   "*"   eq
            /         /  |  \          \
          "b"       id  "="  id         id
                   /             \          \
                "c"             "d"        "e"


heh no neviem.. len moja dedukcia z uvedeneho   

nasiel som peknu prezentaciu, ale neviem to aplikovat na ten konkretny priklad

www.cs.vsb.cz/kot/soubory_animaci/a-deriv_strom.pdf

to je vlastne reprezentacia syntaktickej analyzy zhora nadol, obrazok na strane 87 v skriptach

uf no nejak mi to nezapina... a skripta nemam.. ak  by ste na to prisli tak sem s tym

viete niekto co je ten derivacny strom??  ak hej, ukazka k prikladu vyssie by bola fajn

nasiel som daco take, ale neviem ako to funguje

wooohooooooooou  

viete niekto co je ten derivacny strom??  ak hej, ukazka k prikladu vyssie by bola fajn

aky je rozdiel medzi znakom kolmosti a omegou??  ked hovorime o typoch samozrejme

ze Kolmost je z mnoziny omega ,
kolmost znamena to , ze nastal chybny vypocet (este overim v prednaskam )

kolmost je AnyType vsak?? proste vsetky typy.. ale co je omega?

naopak , omega je anytype a kolmost je prvok z mnoziny anytype ktory ako definuje zlyhanie vypoctu

aha, okej, zle som cital.. dik:)

aky je rozdiel medzi znakom kolmosti a omegou??  ked hovorime o typoch samozrejme

ze Kolmost je z mnoziny omega ,
kolmost znamena to , ze nastal chybny vypocet (este overim v prednaskam )

kolmost je AnyType vsak?? proste vsetky typy.. ale co je omega?

aky je rozdiel medzi znakom kolmosti a omegou??  ked hovorime o typoch samozrejme

[3. Su operacie +,-,* vsetky maju rovnaku prioritu a asociuju sprava a operacia = neasociuje a ma vacsiu prioritu ako ostatne tri. Identifikatory su jedno male pismeno. Treba napisat gramatiku. Potom k vyrazu a+b-c=d*e namalovat syntakticky a derivacny strom a napisat prefixny tvar.]

3. Su operacie +,-,* vsetky maju rovnaku prioritu a asociuju sprava a operacia = neasociuje a ma vacsiu prioritu ako ostatne tri. Identifikatory su jedno male pismeno. Treba napisat gramatiku. Potom k vyrazu a+b-c=d*e namalovat syntakticky a derivacny strom a napisat prefixny tvar.

?                    idem kreslit


aka bude priaorita ?

a+ ( b - ( ( c = d ) * e ) )   ?

jou priorita myslim ze sedi

gramatika :

expr -> eq [("+" | "-" | "*" ) expr]
eq -> id ["=" id]
id -> ("a" | "b" | ... | "z" )


synt strom:

          +
      /       \
    a         -
             /   \
            b      *
                  /   \
                =      e
              /  \
             c    d


prefix :   +a-b*=cde

ale co je derivacny strom??

[2.) bola dana funkcia "function F(x : real) : integer". Tato funkcia bola definovana v ramci funkcie H, ktora bola volana vo funkcii G. Funkcia F sa volala s parametrom F(1.5+2). Bolo treba napisat nieco s tabulkou symbolov, stav pred vykonanim tela a po vykonani, stavy premennych, atributov.. spominalo sa tam nieco s klauzulou begin..]

2.) bola dana funkcia "function F(x : real) : integer". Tato funkcia bola definovana v ramci funkcie H, ktora bola volana vo funkcii G.
Funkcia F sa volala s parametrom F(1.5+2). Bolo treba napisat nieco s tabulkou symbolov, stav pred vykonanim tela a po vykonani, stavy premennych, atributov..
spominalo sa tam nieco s klauzulou begin..
(zrejme strana 82 v skriptach)

anyone ?

neviem co s tymto

toto netusim ani v naznakoch

[1)A -> c["*"|"-"A] kde c je cele cislo prepiste toto pravidlo aby vyhovovalo EBNF aby bolo mozne vygenerovat: 5*4-1 a 5*4-1*3potom napisat hodnoty ake vyjdu po uskutocneni tych prikladova napisat postfixne formy 5*4-1 a 5*4-1*3]

1)
A -> c["*"|"-"A] kde c je cele cislo prepiste toto pravidlo aby vyhovovalo EBNF aby bolo mozne vygenerovat: 5*4-1            a    5*4-1*3
potom napisat hodnoty ake vyjdu po uskutocneni tych prikladov
a napisat postfixne formy 5*4-1            a    5*4-1*3


to by malo byt A -> c[("*" | "-") A]  vsak??  

a aka je asociativita?? zprava?

TRUE / FALSE ?

[3.) Navrhnite jednym pravidlom deklaraciu premennych Vars ak definicia zacina klucovym slovom var, potom nasleduje nenulovy pocet nazvov premennych, za nimi dvojbodka a nasledovny typ T.]

3.) Navrhnite jednym pravidlom deklaraciu premennych Vars ak definicia zacina klucovym slovom var, potom nasleduje nenulovy pocet nazvov premennych, za nimi dvojbodka a nasledovny typ T.


malo byt nejak tak:

Vars -> "var" id { "," id } " : " T                   //id - tak oznacoval Kolar premenne

zostrojit syntakticky analyzator aj so zotavenim pre procedure Vars(k:symset)

ako by ste riesili ?

v tej ulohe nie je nic o ciarkach, takze "," by som vynechal....  na zotavenie idem kuknut

to s tym vyberanim pred zatvorku bolo myslene len prenesene.. proste sa na to pozri logicky..  mas A -> aBCd | aBCdeF  ... bud nastane prve alebo druhe... spolocne maju 'aBCd'  cize to nastane urcite, takze  A-> aBCd   , a potom uz bud moze alebo nemusi prist aj to 'eF'   cize   [eF]  

kde je to v skriptach ? officialne sa to vola ako to pravidlo ?

ale ake pravidlo mas na mysli?
to cele je proste prevod z nejakeho LL(k) (ci co to je)  do LL(1)

[1)A -> c["*"|"-"A] kde c je cele cislo prepiste toto pravidlo aby vyhovovalo EBNF aby bolo mozne vygenerovat: 5*4-1 a 5*4-1*3potom napisat hodnoty ake vyjdu po uskutocneni tych prikladova napisat postfixne formy 5*4-1 a 5*4-1*3]

1)
A -> c["*"|"-"A] kde c je cele cislo prepiste toto pravidlo aby vyhovovalo EBNF aby bolo mozne vygenerovat: 5*4-1            a    5*4-1*3
potom napisat hodnoty ake vyjdu po uskutocneni tych prikladov
a napisat postfixne formy 5*4-1            a    5*4-1*3


to by malo byt A -> c[("*" | "-") A]  vsak??  

a aka je asociativita?? zprava?

takze ak napriklad mam   A->aBCdeF|aBCd, vieme ze to nie je gramatika LL(1) lebo v jednom riadku nemoze byt viac krat ten isty terminalny symbol

do LL(1) vyberiem pred zatvorku aBCd a vyjde mi co ...

A-> aBCd ( eF| ? )

A-> aBCd [eF]   dla mna

Ake pravidlo ste pouzili?

to s tym vyberanim pred zatvorku bolo myslene len prenesene.. proste sa na to pozri logicky..  mas A -> aBCd | aBCdeF  ... bud nastane prve alebo druhe... spolocne maju 'aBCd'  cize to nastane urcite, takze  A-> aBCd   , a potom uz bud moze alebo nemusi prist aj to 'eF'   cize   [eF]