[cpl] Diferenta in substring in dispatch

[Alin Radulescu]

Buna seara,

Imi cer scuze pentru ca ce urmeaza va fi extrem de lung si detaliat, dar
incerc sa explic cat mai detaliat dubiile mele, in speranta ca va fi mai
usor sa observati o greseala in felul in care gandesc.


Am o curiozitate pentru cazul urmator:

[           substring            . id ]
[ id [       expr        , expr] . id ]
[ id [operatie_de_scadere, expr] . id ]
[ id [     id - id       ,  id ] . id ]
              ^
Problema mea  |  e aici (minusul)
Pentru simplitate, consideram:
[ string [ a - b, c ] . length ]

Consider ca in momentul in care avem:
Stiva: [ string [ a
Lookahead: -
Este conflict. In acest moment se parsa una din urmatoarele:
a) primul argument al unui dispatch pe ID-ul string:
[<id> <expr>]
acest prim argument este tot un dispatch.
b) obiectul pentru care se va face dispatch pe o metoda:
[<expr>.<id>]
acest obiect este un substring.

a) se va face shift.
Consideram ca se va apela metoda "string" cu argumentul ce va fi intors de
dispatchul interior (pe care il parsam acum).
iar dispatch-ul interior va intoarce rezultatul apelului metodei "a" cu
argumentul minus_unar

b) se va face reduce.
inca incercam sa construim expresia dinaintea punctului. stim ca este un
substring pentru ca deja am parsat "string[a".
se pare ca primul argument al substringului va fi operatie de scadere. Va
trebui sa reducem "a"-ul de pe stiva la operand stang al operatiei de
scadere.


Sper ca deja ati observat ceva gresit in logica mea. Daca nu
Pasii pe care i-am urmat:

1. Stiva goala.
Lookahead : '['
Shift pe toate regulile de dispatch si static dispatch

2. Stiva: '['
Lookahead: ID
Shift pe regulile de static dispatch (dar nu ne intereseaza asta acum).
Shift pe regulile de dispatch: [<expr>.<id> args] si [<id> args]
                                  ^
                                  | si pe toate expresiile care incep cu ID
                                  | si se poate sa se faca dispatch pe ele
deci doar regula de substring de forma: <id>[<expr>, <expr>]

3. Stiva: '[' ID
Lookahead: '['
Poate fi un dispatch pe ID iar acum incepe argumentul 1, care este tot un
dispatch
exemplu: [ ID argument_care_este_tot_dispatch ]
Deci shift pe toate regulile de (static) dispatch
De asemenea poate fi expresia substring in dispatch
[expr.id args], deci [ substring.<id> args ],
   deci [ ID [ expr, expr ].id args ]
             ^ Pot urma toate expresiile ce pot fi
             | argumente valide pentru substring

4. Stiva: '[' ID '['
Lookahead: ID
In continuare poate face parte din primul argument al unui dispatch pe un
ID:
exemplu: [ID argument_care_este_tot_dispatch_si_care_incepe_cu_id ]
sau      [ ID [ID argumente_sau_nu] ]
Deci shift pe regula de dispatch

In continuare poate fi primul argument al unui substring.
Shift pe toate expresiile care incep cu ID si sunt argumente valide pentru
substring.
[ ID [ expresie_care_intoarce_un_index_si_incepe_cu_ID , expr ] ]

5. Stiva '[' ID '[' ID
Lookahead: '-'
Poate fi inceputul unui prim argument al dispatchului interior (un minus
unar)
[ ID [ID argument_minus_unar] ]
Poate fi mijlocul unei operatii de scadere, care este primul argument din
substring
[ ID [operatie_de_scadere_care_incepe_cu_id, arg] ]

Pot sa reduc ID-ul ca argument stang al operatiei de scadere.
Pot sa fac shift si sa consider ca incepe primul argument din dispatch: un
minus unar.

Presupun ca solutia ar fi sa nu putem face reduce in aceasta situatie.
Adica sa nu pot reduce o operatie de scadere intr-un substring pana nu
ajung la virgula.
I don't know, I'm lost.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://cursuri.cs.pub.ro/pipermail/cpl/attachments/20161110/114f9233/attachment.html>