Vraag JavaScript-parser voor Java [gesloten]


Iedereen kan een goede JavaScript-parser voor Java aanbevelen? Ik geloof dat Rhino kan worden gebruikt, maar het lijkt een overdreven veel te zijn om alleen maar te parsen, of is het de enige fatsoenlijke oplossing? Elke suggestie zou zeer op prijs gesteld worden. Bedankt.


29
2018-06-28 18:47


oorsprong


antwoorden:


Van https://github.com/google/caja/blob/master/src/com/google/caja/parser/js/Parser.java

De onderstaande grammatica is een contextvrije weergave van de grammatica dit   parser parseert. Het is het niet eens met EcmaScript 262 Edition 3 (ES3) waar   implementaties zijn het niet eens met ES3. De regels voor het invoegen van puntkomma's en   de mogelijke terugloop in uitdrukkingen die nodig zijn om goed te kunnen omgaan   backtracking worden grondig in code verwerkt, sinds puntkomma-invoeging   vereist informatie van zowel de lexer als de parser en kan niet worden bepaald   met eindige lookahead.

Opmerkelijke functies

  1. Rapporteert waarschuwingen in een wachtrij waar een fout verdere fouten niet voorkomt, zodat we meerdere fouten in één compile pass kunnen rapporteren in plaats van ontwikkelaars dwingen om een ​​mep te spelen.
  2. Maakt geen gebruik van Firefox-stijl catch (<Identifier> if <Expression>) omdat die niet werken op IE en vele andere tolken.
  3. herkent const aangezien veel tolken dit doen (niet IE) maar waarschuwt.
  4. Staat toe, maar waarschuwt, op trailing comma's in Array en Object constructeurs.
  5. Staat sleutelwoorden toe als identificatienamen maar waarschuwt omdat verschillende tolken verschillende trefwoordensets hebben. Dit stelt ons in staat om een ​​uitgebreide reeks zoekwoorden te gebruiken.

Als u een strikte code wilt parseren, geeft u a PedanticWarningMessageQueue dat   bekeerlingen MessageLevel#WARNING en hoger naar MessageLevel#FATAL_ERROR.


CajaTestCase.js laat zien hoe u een parser instelt, en [fromResource] en [fromString] in dezelfde klas laten zien hoe je een input van de juiste soort krijgt.


12
2018-06-28 19:34



Bij gebruik van Java V1.8 is er een truc die u kunt gebruiken om de Nashorn-implementatie die uit de doos komt, te ontleden. Door te kijken naar de eenheidstests in de OpenSDK-broncode, kunt u zien hoe u de parser alleen gebruikt, zonder alle extra compilatie enz. Te doen ...

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();

Zodra deze code wordt uitgevoerd, beschikt u over de abstracte syntaxisboom (AST) voor de 3 uitdrukkingen in de lijst 'Verklaringen'.

Dit kan vervolgens worden geïnterpreteerd of gemanipuleerd volgens uw behoeften.

Het vorige voorbeeld werkt met de volgende import:

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;

Mogelijk moet u een toegangsregel toevoegen om te maken jdk/nashorn/internal/** beschikbaar.


In mijn context gebruik ik Java Script als een uitdrukkingstaal voor mijn eigen Domain Specific Language (DSL), die ik vervolgens tijdens runtime en gebruik zal compileren naar Java-klassen. Met de AST kan ik de juiste Java-code genereren die de intentie van de Java Script-expressies vastlegt.


Nashorn is beschikbaar met Java SE 8.

De link naar informatie over het verkrijgen van de broncode van Nashorn is hier: https://wiki.openjdk.java.net/display/Nashorn/Building+Nashorn 


11
2018-06-19 12:13



Een eerder antwoord beschrijft een manier om onder de dekens van JDK 8 te komen om JavaScript te ontleden. Ze zijn het nu aan het mainlinen op Java 9. Leuk!

Dit betekent dat u geen bibliotheken hoeft op te nemen, in plaats daarvan kunnen we vertrouwen op een officiële implementatie van de Java-gebruikers. JavaScript-programmatisch parseren is veel gemakkelijker te bereiken zonder in taboo-gebieden van Java-code te stappen.

toepassingen van dit kan zijn waar u JavaScript wilt gebruiken voor een rules-engine die tijdens runtime wordt geparseerd en in een andere taal wordt gecompileerd. De AST laat je de logica 'verstaan' zoals geschreven in de beknopte javascript-taal en genereert dan minder mooie logica in een andere taal of raamwerk voor uitvoering of evaluatie.

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

Samenvatting van de link hierboven:

Definieer een ondersteunde API voor de abstracte syntaxisboom van ECMAScript van Nashorn.

Goals

  • Geef interfaceklassen om synchrone boomknooppunten van Nashorn te representeren.
  • Geef een fabriek om een ​​geconfigureerde parserinstantie te maken, waarbij de configuratie wordt uitgevoerd door de opdrachtregelopties van Nashorn via een API door te geven.
  • Geef een bezoekers-patroon-API om AST-knooppunten te bezoeken.
  • Geef voorbeeld- / testprogramma's om de API te gebruiken.

Niet-doelen

  • De AST-knooppunten vertegenwoordigen begrippen in de ECMAScript-specificatie voor zover mogelijk, maar ze zullen niet precies hetzelfde zijn. Waar mogelijk worden de interfaces van de javac tree API's gebruikt voor ECMAScript.
  • Er zal geen externe parser / tree-standaard of API worden gebruikt.
  • Er is geen parser-API op scriptniveau. Dit is een Java API, hoewel scripts een beroep kunnen doen op Java en daarom gebruik kunnen maken van deze API.

4
2018-03-06 15:20



Dit zijn er twee ANTLR min of meer werkende of complete (zie reacties op dit bericht) grammatica voor EcmaScript:

Van ANTLR Introductie van 5 minuten:

ANTLR leest een taalbeschrijvingsbestand met de naam een ​​grammatica en genereert een aantal broncodebestanden en andere hulpbestanden. De meeste toepassingen van ANTLR genereren ten minste één (en vaak beide) van deze hulpmiddelen:

  • Een Lexer: deze leest een invoerteken of bytestroom (d.w.z. tekens, binaire gegevens, enz.), Verdeelt deze in tokens met behulp van patronen die u opgeeft, en genereert een tokenstroom als uitvoer. Het kan ook een aantal tokens markeren, zoals witruimte en opmerkingen als verborgen met behulp van een protocol dat ANTLR-parsers automatisch begrijpen en respecteren.

  • Een parser: deze leest een tokenstream (normaal gegenereerd door een lexer), en komt overeen met zinnen in uw taal via de regels (patronen) die u opgeeft, en voert typisch een semantische actie uit voor elke gematchte zin (of sub-zin). Elke match kan een aangepaste actie oproepen, tekst schrijven via StringTemplate of een abstracte syntaxisboom genereren voor aanvullende verwerking.


2
2018-06-28 18:50



Voor mij is de beste oplossing het gebruik van eikel - https://github.com/marijnh/acorn onder neushoorn.

Ik denk gewoon niet dat caja aandacht meer krijgt.


1
2018-02-26 15:25



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


0
2017-12-05 16:47