Demander à ANTLR de générer un interpréteur de script?

j'écrirais personnellement une grammaire pour générer un programme Java pour chaque script que vous pourriez ensuite compiler (avec votre jar) et exécuter indépendamment... c'est à dire, un procédé en 2 étapes.

par exemple, avec quelque chose comme la grammaire simple suivante (que je n'ai pas testé et je suis sûr que vous auriez besoin d'étendre et d'adapter), vous pourriez remplacer le parser.eval() dans cet exemple,parser.program(); (aussi en remplaçant "BlockSpeak" par" Exp " dans l'ensemble) et il devrait recracher Java code qui correspond au script stdout, que vous pouvez rediriger vers A.java file, Compiler (avec le jar) et exécuter.

BlockSpeak.g:

grammar BlockSpeak;

program 
    @init { System.out.println("//import com.whatever.stuff;\n\npublic class BlockProgram {\n    public static void main(String[] args) {\n\n"); }
    @after { System.out.println("\n    } // main()\n} // class BlockProgram\n\n"); }
    : inss=instructions                         { if (null != $inss.insList) for (String ins : $inss.insList) { System.out.println(ins); } }
    ;

instructions returns [ArrayList<String> insList]
    @init { $insList = new ArrayList<String>(); }
    : (instruction { $insList.add($instruction.ins); })* 
    ;

instruction returns [String ins]
    :  ( create { $ins = $create.ins; } | move  { $ins = $move.ins; } | stack { $ins = $stack.ins; } ) ';' 
    ;

create returns [String ins]
    :  'block' id=BlockId 'at' c=coordinates    { $ins = "        Block " + $id.text + " = new Block(" + $c.coords + ");\n"; }
    ;

move returns [String ins]
    :  'move' id=BlockId 'to' c=coordinates     { $ins = "        BlockController.moveBlock(" + $id.text + ", " + $c.coords + ");\n"; }
    ;

stack returns [String ins]
    :  'stack' id1=BlockId 'on' id2=BlockId     { $ins = "        BlockController.stackBlocks(" + $id1.text + ", " + $id2.text + ");\n"; }
    ;

coordinates returns [String coords]
    :    '(' x=PosInt ',' y=PosInt ')'          { $coords = $x.text + ", " + $y.text; }
    ;

BlockId
    :    ('A'..'Z')+
    ;

PosInt
    :    ('0'..'9') ('0'..'9')* 
    ;

WS  
    :   (' ' | '\t' | '\r'| '\n')               -> channel(HIDDEN)
    ;

(notez que pour des raisons de simplicité, cette grammaire exige des demi-colonnes pour séparer chaque instruction.)

Il y a bien sûr d'autres façons de faire ce genre de chose, mais cela semble le plus simple pour moi.

bon la chance!

mise à Jour

alors je suis allé de l'avant et j'ai "fini" mon post original (en corrigeant quelques bugs dans la grammaire ci-dessus) et en le testant sur un script simple.

Voici la .le fichier java que j'ai utilisé pour tester la grammaire ci-dessus (tiré des talons de code que vous avez affichés ci-dessus). Notez que dans votre situation, vous voudriez probablement faire le nom du fichier script (dans mon code "script.blockspeak") dans un paramètre de ligne de commande. Aussi, bien sûr, le Block et BlockController les cours viendraient plutôt de votre pot.

BlockTest.java:

import org.antlr.v4.runtime.*;

class Block {
    private String name;
    private int xCoord;
    private int yCoord;

    // Other Getters, setters, ctors, etc.
    public Block(int x, int y) { xCoord = x; yCoord = y; }

    public int getXCoord() { return xCoord; }
    public int getYCoord() { return yCoord; }

    public void setXCoord(int x) { xCoord = x; }
    public void setYCoord(int y) { yCoord = y; }

    public void setCoords(int x, int y) {
        setXCoord(x);
        setYCoord(y);
    }
}

class BlockController {
    public static void moveBlock(Block block, int newXCoord, int newYCoord) {
        block.setCoords(newXCoord, newYCoord);
    }

    public static void stackBlocks(Block under, Block onTop) {
        // Stack "onTop" on top of "under".
        // Don't worry about the math here, this is just for an example.
        onTop.setCoords(under.getXCoord() + onTop.getXCoord(), under.getYCoord());
    }
}

public class BlocksTest {
    public static void main(String[] args) throws Exception {
        ANTLRFileStream in = new ANTLRFileStream("script.blockspeak");
        BlockSpeakLexer lexer = new BlockSpeakLexer(in);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        BlockSpeakParser parser = new BlockSpeakParser(tokens);
        parser.program();
    }
}

Et voici les lignes de commandes que j'ai utilisé (sur mon MacBook Pro):

> java -jar antlr-4.4-complete.jar BlockSpeak.g
> javac -cp .:antlr-4.4-complete.jar *.java
> java -cp .:antlr-4.4-complete.jar BlocksTest > BlockProgram.java

C'est le script d'entrée:

script.blockspeak:

block A at (0, 10);                                                                                                                                            
block B at (0, 20);
stack A on B;

Et c'était la sortie:

BlockProgram.java:

//import com.whatever.stuff;

public class BlockProgram {
    public static void main(String[] args) {


        Block A = new Block(0, 10);

        Block B = new Block(0, 20);

        BlockController.stackBlocks(A, B);


    } // main()
} // class BlockProgram

vous devrez alors compiler et exécuter BlockProgram.java pour chaque script.

en réponse à l'une des questions de votre commentaire (#3), Il y a quelques options plus complexes que j'ai d'abord envisagées qui pourraient rationaliser votre "expérience utilisateur".

(A) au lieu d'utiliser la grammaire pour générer un programme java que vous devez ensuite compiler et exécuter, vous pouvez intégrer les appels à BlockController directement dans les actions ANTLR. Où j'ai créé des cordes et les ai passées d'un non-terminal à ensuite, vous pouvez avoir du code java directement en faisant vos commandes de bloc à chaque fois qu'un instruction la règle est reconnu. Cela nécessiterait un peu plus de complexité en ce qui concerne la grammaire ANTLR et les importations, mais c'est techniquement faisable.

(B) Si vous deviez faire l'option A, vous pourriez alors aller plus loin et créer un interactive interpréteur ("shell"), où l'utilisateur est présenté avec un prompt et tape juste les commandes "blockspeak" au prompt, qui sont alors interprétée et exécutée directement, l'affichage des résultats à l'utilisateur.

aucune de ces options n'est beaucoup plus difficile à accomplir en termes de complexité, mais ils nécessitent chacun de faire beaucoup plus de codage qui serait au-delà de la portée d'une réponse de débordement de pile. C'est pourquoi j'ai choisi de présenter un "simple" solution ici.

eval()ExpParser est implémenté par des appels de méthode; c'est juste que les appels ont une syntaxe de raccourci sous la forme d'opérateurs.

comme exercice, changez ExpParser ajout d'un Calculator classe avec (non implémenté) les méthodes d'opérateurs mathématiques, add(),multiply(),divide(), et ainsi de suite, et puis changer les règles d'utilisation de ces méthodes à la place des opérateurs. Ainsi, vous comprendrez la base de ce que vous devez faire pour votre BlockSpeak interprète.

additionExp returns [double value]
    :    m1=multiplyExp       {$value =  $m1.value;} 
         ( '+' m2=multiplyExp {$value = Calculator.add($value, $m2.value);} 
         | '-' m2=multiplyExp {$value = Calculator.subtract($value, $m2.value);}
         )* 
    ;