IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

EDI et Outils pour Java Discussion :

[ANTLR][JAVACC]implementer une interface


Sujet :

EDI et Outils pour Java

  1. #1
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut [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...

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

    Avez vous une idée ?
    Ni Dieu, ni maître, mais des frites bordel!

  2. #2
    Membre éprouvé Avatar de MarneusCalgarXP
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    911
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 911
    Points : 1 118
    Points
    1 118
    Par défaut
    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 !

    Je ne répond à aucune question technique par MP.

    Si votre problème est réglé, n'oubliez pas Dans tous les cas

  3. #3
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut
    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é" mais j'ai envie de savoir si c'est possible
    Ni Dieu, ni maître, mais des frites bordel!

  4. #4
    Membre éprouvé Avatar de MarneusCalgarXP
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    911
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 911
    Points : 1 118
    Points
    1 118
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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é !

    Je ne répond à aucune question technique par MP.

    Si votre problème est réglé, n'oubliez pas Dans tous les cas

  5. #5
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut
    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
    Ni Dieu, ni maître, mais des frites bordel!

  6. #6
    Membre éprouvé Avatar de MarneusCalgarXP
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    911
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 911
    Points : 1 118
    Points
    1 118
    Par défaut
    Effectivement, donc vu que se placer en amont est impossible, il faut se placer en aval, ce qui est plus simple et plus propre !

    Je ne répond à aucune question technique par MP.

    Si votre problème est réglé, n'oubliez pas Dans tous les cas

  7. #7
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut
    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)

    [edit]méthode équivalente en javaCC reInit [/edit]
    Ni Dieu, ni maître, mais des frites bordel!

  8. #8
    Membre éprouvé Avatar de MarneusCalgarXP
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    911
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 911
    Points : 1 118
    Points
    1 118
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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...

    Je ne répond à aucune question technique par MP.

    Si votre problème est réglé, n'oubliez pas Dans tous les cas

  9. #9
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut
    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 !
    Ni Dieu, ni maître, mais des frites bordel!

  10. #10
    Membre éprouvé Avatar de MarneusCalgarXP
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    911
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 911
    Points : 1 118
    Points
    1 118
    Par défaut
    Ah ok, mais je pense qu'il faut instancier un nouveau Lexer pour chaque fichier...

    EDIT: j'ai modifié mon précédent post !

    Je ne répond à aucune question technique par MP.

    Si votre problème est réglé, n'oubliez pas Dans tous les cas

  11. #11
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut
    J'ai trouvé comment faire pour implémenter mon interface !
    dans la grammaire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    class UNANTLRParser extends Parser("monpackage.ANTLRParser");
    dans le code :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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

    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 !
    Ni Dieu, ni maître, mais des frites bordel!

  12. #12
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut
    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 : 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
     
    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 : 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
     
    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 : 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
     
    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 : 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
     
    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 : 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
     
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    public interface InterfaceParser {
        public void parse() throws Exception;
    }
    du coté de la grammaire au niveau du Parser :
    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
     
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    Ni Dieu, ni maître, mais des frites bordel!

  13. #13
    Membre éprouvé Avatar de MarneusCalgarXP
    Profil pro
    Inscrit en
    Juillet 2006
    Messages
    911
    Détails du profil
    Informations personnelles :
    Âge : 41
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Juillet 2006
    Messages : 911
    Points : 1 118
    Points
    1 118
    Par défaut
    Yep, sympa, mais un peu long

    Je ne répond à aucune question technique par MP.

    Si votre problème est réglé, n'oubliez pas Dans tous les cas

  14. #14
    Membre confirmé Avatar de anitshka
    Inscrit en
    Mai 2004
    Messages
    624
    Détails du profil
    Informations forums :
    Inscription : Mai 2004
    Messages : 624
    Points : 605
    Points
    605
    Par défaut
    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
    Ni Dieu, ni maître, mais des frites bordel!

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Savoir si un objet implement une interface
    Par toure32 dans le forum Delphi
    Réponses: 3
    Dernier message: 17/11/2006, 21h54
  2. [REFLEXION] Connaitre toutes les classes qui implémentent une interface
    Par narmataru dans le forum API standards et tierces
    Réponses: 7
    Dernier message: 25/10/2006, 12h00
  3. [Reflection] Obtenir toutes les classes implémentant une interface
    Par Pill_S dans le forum API standards et tierces
    Réponses: 4
    Dernier message: 20/04/2005, 17h48
  4. [classe anonyme] implementant une interface
    Par stanilas dans le forum Langage
    Réponses: 4
    Dernier message: 30/11/2004, 01h18
  5. [Reflection] Classes implémentant une interface
    Par thibaut dans le forum API standards et tierces
    Réponses: 17
    Dernier message: 29/07/2004, 15h57

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo