web-dev-qa-db-fra.com

Analyseur Javascript pour Java

Tout le monde peut recommander un analyseur Javascript décent pour Java? Je crois que Rhino peut être utilisé, mais il semble exagéré de ne faire que l’analyse syntaxique ou est-ce la seule solution décente? Toute suggestion serait grandement appréciée. Merci. 

javajavascriptparsing
30
xybrek

De https://github.com/google/caja/blob/master/src/com/google/caja/parser/js/Parser.Java

La grammaire ci-dessous est une représentation sans contexte de la grammaire this analyseur analyse. Il n'est pas d'accord avec EcmaScript 262 Edition 3 (ES3) où les implémentations ne sont pas d’accord avec ES3. Les règles pour l’insertion de points-virgules et le possible retour en arrière dans les expressions nécessaires pour gérer correctement les retours en arrière sont commentés en détail dans le code, depuis l’insertion de points-virgules requiert des informations à la fois du lexer et de l'analyseur et n'est pas déterminable avec lookahead fini.

Caractéristiques remarquables

  1. Signale les avertissements dans une file d'attente où une erreur n'empêche pas d'autres erreurs, afin que nous puissions signaler plusieurs erreurs en une seule étape de compilation au lieu d'obliger les développeurs à jouer à whack-a-mole.
  2. Ne pas analyser le style catch (<Identifier> if <Expression>) dans Firefox, car ceux-ci ne fonctionnent pas sur IE et sur de nombreux autres interpréteurs.
  3. Reconnaît const puisque beaucoup d'interprètes le font (pas IE) mais avertissent.
  4. Permet, mais avertit, sur les virgules de fin dans les constructeurs Array et Object.
  5. Autorise les mots-clés en tant que noms d'identifiant mais avertit, car différents interprètes ont des ensembles de mots-clés différents. Cela nous permet d'utiliser un ensemble de mots-clés expansif.

Pour analyser du code strict, transmettez une PedanticWarningMessageQueue que convertit MessageLevel#WARNING et ci-dessus en MessageLevel#FATAL_ERROR.

CajaTestCase.js montre comment configurer un analyseur, et [fromResource] et [fromString] dans la même classe montrent comment obtenir une entrée du type approprié.

12
Mike Samuel

Lors de l’utilisation de Java V1.8, il existe une astuce que vous pouvez utiliser pour analyser l’implémentation Nashorn fournie. En examinant les tests unitaires dans le code source OpenSDK, vous pouvez voir comment utiliser uniquement l'analyseur, sans effectuer toute la compilation supplémentaire, etc.

Options options = new Options("nashorn");
options.set("anon.functions", true);
options.set("parse.only", true);
options.set("scripting", true);

ErrorManager errors = new ErrorManager();
Context context = new Context(options, errors, Thread.currentThread().getContextClassLoader());
Source source   = new Source("test", "var a = 10; var b = a + 1;" +
            "function someFunction() { return b + 1; }  ");
Parser parser = new Parser(context.getEnv(), source, errors);
FunctionNode functionNode = parser.parse();
Block block = functionNode.getBody();
List<Statement> statements = block.getStatements();

Une fois ce code exécuté, vous obtiendrez l’arbre de syntaxe abstraite (AST) pour les 3 expressions de la liste 'déclarations'.

Cela peut ensuite être interprété ou manipulé selon vos besoins.

L'exemple précédent fonctionne avec les importations suivantes:

import jdk.nashorn.internal.ir.Block;
import jdk.nashorn.internal.ir.FunctionNode;
import jdk.nashorn.internal.ir.Statement;
import jdk.nashorn.internal.parser.Parser;
import jdk.nashorn.internal.runtime.Context;
import jdk.nashorn.internal.runtime.ErrorManager;
import jdk.nashorn.internal.runtime.Source;
import jdk.nashorn.internal.runtime.options.Options;

Vous devrez peut-être ajouter une règle d'accès pour rendre jdk/nashorn/internal/** accessible.

Dans mon contexte, j'utilise Java Script en tant que langage d'expression pour mon propre langage DSL (Domain Specific Language) que je compilerai ensuite en classes Java au moment de l'exécution et de l'utilisation. AST me permet de générer le code Java approprié qui capture l'intention des expressions de script Java.

Nashorn est disponible avec Java SE 8.

Le lien vers des informations sur l'obtention du code source de Nashorn est ici: https://wiki.openjdk.Java.net/display/Nashorn/Building+Nashorn

11
Luke Machowski

Une réponse précédente décrit un moyen de passer sous les couvertures de JDK 8 pour analyser javascript. Ils l’intègrent maintenant dans Java 9. Nice!

Cela signifiera que vous n'avez pas besoin d'inclure de bibliothèques, mais que nous pouvons compter sur une implémentation officielle des développeurs Java. Analyser JavaScript par programme est beaucoup plus facile à réaliser sans entrer dans des zones taboues du code Java.

Applications peut être l'endroit où vous souhaitez utiliser javascript pour un moteur de règles analysé et compilé dans un autre langage au moment de l'exécution. Le AST vous permet de "comprendre" la logique telle qu'elle est écrite dans le langage javascript concis, puis de générer une logique moins jolie dans un autre langage ou un autre cadre pour exécution ou évaluation.

http://openjdk.Java.net/jeps/236

Résumé du lien ci-dessus:

Définissez une API prise en charge pour l'arborescence de syntaxe abstraite ECMAScript de Nashorn.

Buts

  • Fournissez des classes d'interface représentant les nœuds d'arbre de syntaxe Nashorn.
  • Fournissez une fabrique pour créer une instance d'analyseur configurée, la configuration étant effectuée en transmettant les options de ligne de commande Nashorn via une API.
  • Fournissez une API de modèle de visiteur pour visiter les nœuds AST.
  • Fournissez des exemples de programmes/tests pour utiliser l'API.

Non-objectifs

  • Les nœuds AST représenteront les notions de la spécification ECMAScript dans la mesure du possible, mais elles ne seront pas exactement les mêmes. Dans la mesure du possible, les interfaces de l'API de l'arborescence javac seront adoptées pour ECMAScript.
  • Aucun analyseur/standard d'arborescence externe ni API ne sera utilisé.
  • Il n'y aura pas d'API d'analyseur de niveau script. Ceci est une API Java, bien que les scripts puissent appeler en Java et donc utiliser cette API.
4
Luke Machowski

Voici deux ANTLR plus ou moins fonctionnels ou complets (voir les commentaires sur ce post) grammaires pour EcmaScript: 

De ANTLR 5 minute intro :

ANTLR lit un fichier de description du langage appelé grammaire et génère un certain nombre de fichiers de code source et d’autres fichiers auxiliaires. La plupart des utilisations de ANTLR génèrent au moins un (et souvent les deux) de ces outils:

  • Un Lexer: Ceci lit un caractère d'entrée ou un flux d'octets (caractères, données binaires, etc.), le divise en jetons à l'aide des modèles que vous spécifiez et génère un flux de jetons en sortie. Il peut également signaler que certains jetons, tels que les espaces et les commentaires, sont masqués à l'aide d'un protocole que les analyseurs syntaxiques ANTLR comprennent et respectent automatiquement.

  • Un analyseur: ceci lit un flux de jetons (normalement généré par un lexer), associe les phrases de votre langue via les règles (modèles) que vous spécifiez, et effectue généralement une action sémantique pour chaque phrase (ou sous-phrase) trouvée. Chaque correspondance peut appeler une action personnalisée, écrire du texte via StringTemplate ou générer un arbre de syntaxe abstraite pour un traitement supplémentaire.

2
miku

Pour moi, la meilleure solution consiste à utiliser gland - https://github.com/marijnh/acorn sous rhino. 

Je ne pense tout simplement pas que caja attire plus l'attention. 

1
Matthew Kime

EcmaScript 5 Parser pour Java https://github.com/DigiArea/es5-model

0
user452425