[ANTLR][JAVACC]implementer une interface

Version imprimable

18/08/2006, 16h36
anitshka

[ANTLR][JAVACC]implementer une interface

Bonjour :)

Voila j'ai 2 parser, un fait en JAVACC et un fait en ANTLR. Je souhaite garder les 2 à disposition dans mon application et je souhaite faire en sorte que mon utilisateur puisse utiliser l'un ou l'autre.
Pour cela je voudrais que mes parser implémentent la même interface et c'est la d'ou vient le problème.

Je n'ai pas encore trouver dans la doc de ANTLR comment faire pour que ma classe de Parser générée implémenent l'interface nécessaire...:oops:

Et il me reste encore a chercher du coté de javaCC ...

Avez vous une idée ?
18/08/2006, 16h45
MarneusCalgarXP

Je serais toi, je ne chercherais pas en amont mais plutot en aval : faire un wrapper qui permet d'utiliser indifféremment l'une et l'autre !
18/08/2006, 16h54
anitshka

Citation:

Envoyé par MarneusCalgarXP

Je serais toi, je ne chercherais pas en amont mais plutot en aval : faire un wrapper qui permet d'utiliser indifféremment l'une et l'autre !

Ca c'est la deuxième solution mais vu qu'on peux remonter des exception choisi je me suis dit qu'il etait certainement possible de faire implémenter par une interface de notre choix ... Dans le genre "je cherche le compliqué" :mouarf: mais j'ai envie de savoir si c'est possible
19/08/2006, 02h20
MarneusCalgarXP

A priori, dans ANTLR, il est possible de déclarer ta classe comme tu veux, y compris en définissant les interfaces. Je ne l'ai pas sur ce poste donc je ne peux pas tester, mais ça doit ressembler à un truc du style:

Code:

class MyLexer extends Lexer implements MyInterface;

Par contre, je ne connais pas du tout JavaCC donc je ne pourrais pas te renseigner de ce côté !
19/08/2006, 17h43
anitshka

lors de m'interprétation du fichier il me dit qu'il ne comprend pas ce qu'il y a apres Lexer... en gros le implement il en voulais pas je retesterai lundi :D
21/08/2006, 10h08
MarneusCalgarXP

Effectivement, donc vu que se placer en amont est impossible, il faut se placer en aval, ce qui est plus simple et plus propre !
21/08/2006, 14h24
anitshka

Par contre je ne sais pas (et je trouve ca déjà dommage si ca n'existe pas )
Y a t il une méthode permettant de réinitialiser le flux d'entree pour le parseur sans devoir en réinstancier un en lui passant un Lexer qui va bien ...:?

Car ca veux dire que je dois déclarer une nouvelle instance a chaque fois que j'en ai besoin (et c'est souvent souvent):oops:

[edit]méthode équivalente en javaCC reInit [/edit]
21/08/2006, 15h01
MarneusCalgarXP
Pourquoi as-tu besoin de réinitialiser le flux d'entrée ? Normalement, en une passe, tu as tous les tokens !!!

Ce que tu peux faire, c'est stocker les tokens dans un Vector ou quelque chose dans le style, ca t'évitera de ré-analyser l'ensemble du texte à chaque fois !!!
De plus, ca te permettra de faire une méthode générique pour wrapper les 2.

Par exemple, tu te définis une classe
Code:

1 2 3 4 5 6 MonToken * texte * longueur * position dans le texte et/ou n° de ligne * type de token
Et dans ton wrapper, tu te fais une interface du style:
Code:

1 2 3 4 public interface IMonLexer { Vector getTokens(String filename); }
et tu implémentes 2 classes qui héritent cette interface, la 1° en utilisant un lexer de ANTLR, la 2° en utilisant la classe équivalente de JavaCC...
21/08/2006, 15h04
anitshka

non c'est que j'ai certe un parseur unique mais pour des dizaines de fichiers... donc c'est mon flux d'entree que je souhaite changer !
21/08/2006, 15h08
MarneusCalgarXP

Ah ok, mais je pense qu'il faut instancier un nouveau Lexer pour chaque fichier...

EDIT: j'ai modifié mon précédent post !
21/08/2006, 16h36
anitshka
J'ai trouvé comment faire pour implémenter mon interface !
dans la grammaire :
Code:

1 2 class UNANTLRParser extends Parser("monpackage.ANTLRParser");
dans le code :

Code:

public abstract class ANTLRParser extends LLkParser implements MonInterface

Ensuite il me reste a déclarer mes signatures de méthodes dans mon interface et de les impléméneter dans mes différents parseurs :D

Pour ce qui est du fait de changer mon flux d'entrée sans déclaré une nouvelle instance de mon lexer puis de mon parser la je sèche encore... mais doit y avoir un moyen de contourner l'affaire !

Y avais bien un moyen !
Merci a mon chef :) je reste toujours impressionnée quand il s'approche de mon écran

Bon voici la réponse à "Comment éviter de déclarer une nouvelle instance de parser a chaque nouveau reader à analyser avec ANTLR"
Y a certainement possibilité de le faire plus joli mais voila une solution qui fonctionne

Voila pour le Lexer :

Code:

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
 
public class ResetableANTLRLexer extends antlr.CharScanner{
 
    public ResetableANTLRLexer() {
        this(new ResetableLexerSharedInputState());
    }
 
    public ResetableANTLRLexer(InputBuffer cb) {
        super(cb);
    }
 
    public ResetableANTLRLexer(LexerSharedInputState sharedState) {
        super(sharedState);
    }
 
    public antlr.Token nextToken() throws TokenStreamException {
        return null;
    }
 
    public void setReader(Reader reader){
        ((ResetableLexerSharedInputState)inputState).setReader(reader);
    }
 
    protected static class ResetableLexerSharedInputState extends LexerSharedInputState {
        public ResetableLexerSharedInputState(Reader reader) {
            super(reader);
        }
 
        public ResetableLexerSharedInputState() {
            super(new StringReader(""));
        }
 
        public void setReader(Reader reader) {
            reset();
            input = new CharBuffer(reader);
        }
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public abstract class MonANTLRLexer extends ResetableANTLRLexer{
 
    protected MonANTLRLexer () {
        super();
    }
 
    protected MonANTLRLexer (InputBuffer cb) {
        super(cb);
    }
 
    protected MonANTLRLexer (LexerSharedInputState sharedState) {
        super(sharedState);
    }
 
    public void setReader(Reader reader) {
        super.setReader(reader);
    }
}

dans la grammaire au niveau du Lexer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
class MonLexer extends Lexer("monpackage.MonANTLRLexer");
 
options {
  charVocabulary = '\0'..'\377';
  testLiterals=false;    // don't automatically test for literals
  k=2;                   // two characters of lookahead
}
 
tokens {
  CLASS             = "class"   ;
  FALSE             = "false"   ;
  TRUE              = "true"    ;
  NEW               = "new"     ;
}
 
// Define some methods and variables to use in the generated parser.
{
  public MonLexer(){
    this(new ResetableLexerSharedInputState());
  }
}

Pour le coté parser

Code:

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
 
public class ResetableANTLRParser extends LLkParser {
 
    public ResetableANTLRParser(ResetableANTLRLexer lexer) {
        super(new MyParserSharedInputState(new TokenBuffer(lexer)), 1);
    }
 
    public ResetableANTLRParser(int k_) {
        super(k_);
    }
 
    public ResetableANTLRParser(ParserSharedInputState state, int k_) {
        super(state, k_);
    }
 
    public ResetableANTLRParser(TokenBuffer tokenBuf, int k_) {
        super(tokenBuf, k_);
    }
 
    public ResetableANTLRParser(TokenStream lexer, int k_) {
        super(lexer, k_);
    }
 
    public void setReader(Reader reader) {
        ((MyParserSharedInputState) inputState).setReader(reader);
    }
 
    protected static class MyParserSharedInputState extends ParserSharedInputState {
        public MyParserSharedInputState(TokenBuffer tokenBuffer) {
            input = tokenBuffer;
        }
 
        public void setReader(Reader reader) {
            ResetableANTLRLexer scanner = (ResetableANTLRLexer) input.getInput();
            input.reset();
            scanner.setReader(reader);
        }
    }
}

Code:

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
 
public abstract class MonANTLRParser extends ResetableANTLRParser implements InterfaceParser {
    public MonANTLRParser (CharScanner lexer) {
        super(new MyParserSharedInputState(new TokenBuffer(lexer)), 1);
    }
 
    public void setReader(Reader reader) {
        super.setReader(reader);
    }
 
    public MonANTLRParser(int index) {
        super(index);
    }
 
    public MonANTLRParser(ParserSharedInputState state, int index) {
        super(state, index);
    }
 
    public MonANTLRParser(TokenBuffer tokenBuf, int index) {
        super(tokenBuf, index);
    }
 
    public MonANTLRParser(TokenStream lexer, int index) {
        super(lexer, index);
    }
}

du coté de l'interface :

Code:

1
2
3
4
 
public interface InterfaceParser {
    public void parse() throws Exception;
}

du coté de la grammaire au niveau du Parser :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class MonParser extends Parser("monpackageder.MonANTLRParser");
options {
  defaultErrorHandler = false;      // Don't generate parser error handlers
}
 
// Define some methods and variables to use in the generated parser.
{
  public MonParser(MonLexer lexer) {
     super(lexer);
  }
 
  //methode de mon interface
  public void parse() throws Exception{
    return mainParse();
  }
}

à l'utilisation :

Code:

1
2
3
4
5
6
7
8
9
 
        MonLexer monLexer = new MonLexer();
        MonParser parser = new MonParser(monLexer);
 
        parser.setReader(reader1);
        parser.parse();
        //use resetable functionnality
        parser.setReader(reader2);
        parser.parse();

Et voila on dirai presque de la magie ! mais c'est résolu :D

22/08/2006, 14h59
MarneusCalgarXP

Yep, sympa, mais un peu long ;)
22/08/2006, 15h12
anitshka

Citation:

Envoyé par MarneusCalgarXP

Yep, sympa, mais un peu long ;)

Je suis d'accord mais vu qu'on a plusieurs parseurs avec des lexer différents qui sont appelé plusieurs fois de suite et bah finalement y a pas grand chose a recoder entre 2 solutions ;)