No such method 'made' for invocant of type 'Array

**jeepc** · 05/01/2017, 00h07

Bonne année 2017 avec plein de joli code sans bug ...

La mauvaise nouvelle de ce début d'année ,c'est que je continue mes tests sur Perl6 et ses possibilités d'analyse lexicale/syntaxique.
Et que comme d'habitude, j'ai des questions ...

L'exercice du jour consiste à essayer de transformer dans un ordre sql " select dummy, sequencetoto.nextval from dual " (syntaxe Oracle) en " select dummy, nextval('sequencetoto') from dual " (syntaxe PostgreSQL)

ce que le code suivant réalise plûtot bien :

( même si un caractère blanc disparait entre le dummy et nextval ... )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
cat ./nextval04.pl6 
#!/opt/rakudo-star-2016.10/bin/perl6
use v6;
use Grammar::Tracer;
#use Grammar::Debugger;
 
grammar Test {
    rule  TOP     { [<text>  <nextvaltop> ] <textfin> }
    token nextvaltop {  <sequence> '.'<nextval>  }
    token  sequence { \w+ }
    token  nextval { :i 'nextval' }
    regex text     { .+? }
    regex textfin     { .+ }
}
 
class TestCompute {
    method TOP ($/) { make $<text> ~ $<nextvaltop>.made ~ $<textfin>; }
    method nextvaltop ($/) { make $<nextval> ~ "('" ~ $<sequence> ~ "')"  ; }
}
 
 
say Test.parse('select dummy, totoseq.nextval from dual', actions => TestCompute).made;

ce qui donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
./nextval04.pl6 
TOP
|  text
|  * MATCH "s"
|  nextvaltop
|  |  sequence
|  |  * MATCH "dummy"
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * MATCH "dummy"
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * FAIL
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * MATCH "totoseq"
|  |  nextval
|  |  * MATCH "nextval"
|  * MATCH "totoseq.nextval"
|  textfin
|  * MATCH "from dual"
* MATCH "select dummy, totoseq.nextval from dual"
select dummy,nextval('totoseq')from dual

La où je n'y arrive plus, c'est si je veux transformer plusieurs sequences dans le même ordre, par exemple : " select dummy, sequencetoto.nextval, sequencetiti.nextval from dual " (syntaxe Oracle) en " select dummy, nextval('sequencetoto'),nextval('sequencetiti') from dual "

J'arrive bien à faire obtenir l'AST correspond en modifiant ma grammaire comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
cat ./nextval03.pl6 
#!/opt/rakudo-star-2016.10/bin/perl6
use v6;
use Grammar::Tracer;
#use Grammar::Debugger;
 
grammar Test {
    rule  TOP     { [<text>  <nextvaltop> ]* <textfin> }
    token nextvaltop {  <sequence> '.'<nextval>  }
    token  sequence { \w+ }
    rule  nextval { :i 'nextval' }
    regex text     { .+? }
    regex textfin     { .+ }
}
 
class TestCompute {
    method TOP ($/) { make $<text> ~ $<nextvaltop>.made ~ $<textfin>; }
    method nextvaltop ($/) { make $<nextval> ~ "('" ~ $<sequence> ~ "')"  ; }
}
 
say Test.parse('select totoseq.nextval, dummy, titiseq.NEXTVAL from dual');

ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
./nextval03.pl6 
TOP
|  text
|  * MATCH "s"
|  nextvaltop
|  |  sequence
|  |  * MATCH "totoseq"
|  |  nextval
|  |  * MATCH "nextval"
|  * MATCH "totoseq.nextval"
|  text
|  * MATCH ","
|  nextvaltop
|  |  sequence
|  |  * MATCH "dummy"
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * MATCH "dummy"
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * FAIL
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * MATCH "titiseq"
|  |  nextval
|  |  * MATCH "NEXTVAL "
|  * MATCH "titiseq.NEXTVAL "
|  text
|  * MATCH "f"
|  nextvaltop
|  |  sequence
|  |  * MATCH "dual"
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * MATCH "dual"
|  * FAIL
|  nextvaltop
|  |  sequence
|  |  * FAIL
|  * FAIL
|  textfin
|  * MATCH "from dual"
* MATCH "select totoseq.nextval, dummy, titiseq.NEXTVAL from dual"
｢select totoseq.nextval, dummy, titiseq.NEXTVAL from dual｣
 text => ｢select｣
 nextvaltop => ｢totoseq.nextval｣
  sequence => ｢totoseq｣
  nextval => ｢nextval｣
 text => ｢, dummy,｣
 nextvaltop => ｢titiseq.NEXTVAL ｣
  sequence => ｢titiseq｣
  nextval => ｢NEXTVAL ｣
 textfin => ｢from dual｣

mais si j'essaie de modifier l'AST :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/opt/rakudo-star-2016.10/bin/perl6
use v6;
use Grammar::Tracer;
#use Grammar::Debugger;
 
grammar Test {
    rule  TOP     { [<text>  <nextvaltop> ]* <textfin> }
    token nextvaltop {  <sequence> '.'<nextval>  }
    token  sequence { \w+ }
    rule  nextval { :i 'nextval' }
    regex text     { .+? }
    regex textfin     { .+ }
}
 
class TestCompute {
    method TOP ($/) { make $<text> ~ $<nextvaltop>.made ~ $<textfin>; }
    method nextvaltop ($/) { make $<nextval> ~ "('" ~ $<sequence> ~ "')"  ; }
}
 
say Test.parse('select dummy,totoseq.nextval, titiseq.nextval from dual', actions => TestCompute).made;

j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
No such method 'made' for invocant of type 'Array'
  in method TOP at ./nextval03.pl6 line 16
  in regex TOP at ./nextval03.pl6 line 7
  in block  at /opt/rakudo-star-2016.10/share/perl6/site/sources/88A197C57F6C4623C1071F68DFC42E86CA5F4B4D (Grammar::Tracer) line 21
  in block <unit> at ./nextval03.pl6 line 21

snif ...

Du coup je me demande si ce que je veux faire est bien possible ...

Voilà,

Merci pour votre aide.
Bien cordialement,

**Lolo78** · 05/01/2017, 15h22

Bonjour,

Envoyé par jeepc

Bonne année 2017 avec plein de joli code sans bug ...

Pareillement à toi.

Envoyé par jeepc

La mauvaise nouvelle de ce début d'année ,c'est que je continue mes tests sur Perl6 et ses possibilités d'analyse lexicale/syntaxique.

Bah, c'est plutôt une bonne nouvelle.

Le problème de ton code, je pense, est que, par rapport à ton exemple initial, $<nextvaltop> devient un tableau de résultats, il faut traiter ces résultats un par un.

Je ne peux pas tester pour l'instant, mais essaie de changer ta méthode d'action TOP comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
method TOP ($/) { my $result =  make $<text>[0];
                  $result ~= $_.made ~ " " for $<nextvaltop>;
                  make $result ~= $<textfin>;
                }

Cela devrait résoudre le principal problème, me semble-t-il, mais il se peut qu'il faille revoir légèrement la grammaire pour gérer plus finement les espaces et les virgules (d'ailleurs, tu avais apparemment déjà un problème d'espace dans ton code initial).

Bonne après-midi.

**jeepc** · 05/01/2017, 17h59

Effectivement, c'est déjà beaucoup mieux.
Maintenant faut que j'arrive comprendre

(Je n'ai eu le temps que de tester et de voir le parcours du tableau auquel je n'avais pas pensé, je devrais pouvoir regarder plus en détail demain soir et fermer cette discussion.)

Merci encore pour l'aide.
Bien cordialement,

**jeepc** · 06/01/2017, 10h52

Bon, j'avoue que j'ai du mal à comprendre cette syntaxe. C'est l'utilisation du mot clé make que je ne comprend pas. Pourquoi faut-il écrire "make $<test>[0] " et pas "$<test>[0]"... (Je ne dois pas bien comprendre à quoi correspond "make", je pensais que cela permettait la définition de la méthode make, mais cela doit être autre chose ... )

Sinon, j'ai modifié la grammaire pour améliorer la réécriture de l'ordre SQL:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/opt/rakudo-star-2016.10/bin/perl6
use v6;
 
grammar Test {
    rule  TOP     { [<main>]* <textfin> }
    rule  main     { <text>  <nextvaltop> }
    token nextvaltop {  <sequence> '.'<nextval>  }
    token sequence { \w+ }
    token  nextval { :i 'nextval' }
    regex text     { .+? }
    regex textfin     { .+ }
}
 
class TestCompute {
    method TOP ($/) { my   $result ~= make $_.made for $<main>;
                      make   $result ~= $<textfin>;
                }
    method main ($/) { make $<text> ~ $<nextvaltop>.made ; }
    method nextvaltop ($/) { make $<nextval> ~ "('" ~ $<sequence> ~ "')"  ; }
}
 
say Test.parse('select dummy,totoseq.nextval,dummy,titiseq.nextval from dual', actions => TestCompute).made;

et surprise, cela marche, j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

select dummy,nextval('totoseq'),dummy,nextval('titiseq')from dual

Néanmoins, j'aimerai bien comprendre ce que fait l'instruction make ...

Merci beaucoup pour l'aide apportée qui me permet d'avancer dans mes tests.
Bien cordialement,

**Lolo78** · 08/01/2017, 00h30

Hum, comment expliquer?

D'une part, tu as l'objet reconnu (match object), qui peut être une structure de données assez complexe, générée par la grammaire.

D'autre part, tu as l'AST (absract syntax tree), qui peut être une version simplifiée de l'objet reconnu ou éventuellement complètement autre chose, mais c'est en fait à toi de choisir ce que tu y mets. make permet d'alimenter cet AST, et .made de voir ce qu'il y a dedans.

make affecte son argument à AST et renvoie le résultat. Ce processus a lieu à chaque niveau de l'objet reconnu faisant appel a make, si bien qu'à la fin, l'AST contient les parties de l'objet reconnu (ou toute autre chose si tu codes différemment) que tu as choisies.

Je ne suis pas sûr d'avoir été clair, mais j'espère au moins avoir clarifié en partie.

**jeepc** · 08/01/2017, 02h13

Si, si, c'est clair. En tout cas, c'est moins confus dans mon esprit.

Encore merci pour ton aide et tes explications que j'apprécie beaucoup.

Bien cordialement,

No such method 'made' for invocant of type 'Array [perl6]

Langage Perl

Discussions similaires

Partager

Partager