Online grammar editor based on ANTLR

[KvanTTT]

There are a lot of services for online regex writing and testing: https://regex101.com/, https://regexr.com/, https://www.regextester.com/, and so on. They allow everyone to write and test any regular expression very easily.

On the other hand, there are services that allow parsing, analyzing, and compiling specified programming languages: https://sharplab.io/, https://astexplorer.net/, https://godbolt.org/

But there are no services that allow creating parsers right from the browser and based on grammar.

I suggest creating such a service based on ANTLR parser generator.

The service will have at least two text fields. The left one contains an editor for grammar. The right one contains an editor for parse input. Also, yet another field can display a parse tree. The service will allow grammar editing and obtaining result parsers in different languages.

If implemented such a service may provide the following benefits:

• Productivity:
  • Everyone can pick a grammar from grammars repository and instantly generate a parser in one of many languages. It's not necessary to install the tool and to figure out how it works. Just select grammar and get a parser.
  • It's easy to create a prototype of simple language or prototype a feature in existing language right in a browser.
• Education:
  • A teacher can use such a service in a lecture to demonstrate how context-free grammars work.
  • A student can play with service during practice.
• Community:
  • Everyone can fix grammar and send a pull request to the official grammars repository.

By the way, a similar service exists but for binary parsing: https://ide.kaitai.io/ It would be great to have a service for text parsing!

A much simpler but also useful idea is about HTTP API. Everyone can just get generated parser by sending request and grammar to the cloud grammar generator.

[parrt]

Yep, very similar to what I'm thinking. I drew this a while back

[KvanTTT]

I also sketched a desktop application that looks like the following way (maybe it's a bit overkill but it's the first version and it can be simplified and improved):

Sources are available here: DAGE

I suggest using the following grammar processing stages:

• Basic grammar syntax checks, rules collecting using visitor or listener (client or server)
• Grammar semantics checks and parser generation for certain runtime using ANTLR tool (server)
• Generated code semantics checks and parser compilation or interpretation using compilied app (server)
• Text parsing and text syntax errors collecting using compilied app (server or client)

The first stage can be implemented either on client or on server, other staged can be implemented only on server because they requires JVM runtime. The last stage can be implemented on server, but also on client for JS runtime.

I suggest using Kotlin for the service implementation since it has good compatibility with Java and it can be compiled both to JVM or to JavaScript (Kotlin multiplatform).

[Serhioromano]

do you have executable?

[KvanTTT]

I'll try to fix CI or upload binaries to you directly.

[parrt]

any chance we can use kotlin to get a full js-only version of antlr tool?

[KvanTTT]

Good question, I haven't tried to compile the full tool to JS. In theory it's possible, but I'm not sure about dependecies.

Anyway, I think server backend is also very desirable for testing generated lexers/parsers with available runtimes.

[ftomassetti]

@parrt in my (limited) experience with having Multiplatform Kotlin projects, yes, that is possible however the JS code obtained is very difficult to work with from JS. Kotlin compiled to JS works well for writing apps but not libraries as it mangles names and do other things that make it a pain to use it. Perhaps things improved with the recent version of Kotlin and refinement to their JS compiler.

[KvanTTT]

Does it work with dependencies? ANTLR 4 depends on ANTLR 3 and other libraries. I haven't tried Kotlin MP yet.

[kaby76]

There are only a few online parser tools, which is a sad state we are in. I was writing a web-based Antlr tool, but I haven't been able to get far because of too many other higher priorities. I would try to avoid writing an Antlr tool running on a server, and instead try to use WebAssembly from the Java classes--which is what I was trying to do. I would also highly recommend not using the ancient Antlr4, Antlr4.Runtime, Antlr4.ToolGenerator code. It does not support current grammars.

[KvanTTT]

I would try to avoid writing an Antlr tool running on a server, and instead try to use WebAssembly from the Java classes--which is what I was trying to do.

Why? It won't be possible to test if runtime code works correctly, it significantly reduces convenience.

I would also highly recommend not using the ancient Antlr4, Antlr4.Runtime, Antlr4.ToolGenerator code. It does not support current grammars.

Yes, it makes sense.

[kaby76]

You can "test" the generated code by using the "interpreter" Parser class from the tool, the same as with the Intellij plugin.

[kaby76]

That said, I have to add that my WebAssembly implementation (Blazor) was slow.

[KvanTTT]

I didn't say I'm going to use "interpreter". I'm going to use real compilation or interpretation that is partially implemented in DAGE, it's possible.

[ericvergnaud]

Why would you want to go through all that trouble ? Just run the tool on AWS Lambda. What we need in the browser is a grammar editor with syntax checking, but that’s a small portion of the tool, especially if the latter is delegated to the backend Envoyé de mon iPhone

…

Le 21 mai 2022 à 21:21, Terence Parr ***@***.***> a écrit :  any chance we can use kotlin to get a full js-only version of antlr tool? — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you are subscribed to this thread.

[kaby76]

I guess I don't understand some of the requirements for this online tool.

• "Everyone can pick a grammar from grammars repository and instantly generate a parser in one of many languages." Right now I can go on a machine (Linux or Windows/msys2) and do git clone https://github.com/antlr/grammars-v4.git; cd grammars-v4/whatever-grammar-you-want; trgen -t whatever-target-you-want; cd Generated; make and I have a fully functioning application for the grammar in the target language and target OS. Why would I want to offer to generate target source code files for parser and lexer online, then offer the developer to download the generated files, write a driver program in the target language locally and build locally? Is the purpose of the online tool to offer an online model of developing a program that has an Antlr grammar? Is the online tool going to allow the developer to add source files, restructure the application?
• "install the tool". I never understand why it is so hard to click on a link and download a file, but I do see it constantly in StackOverflow. The Antlr tool requires no "installation"--isn't it just there in the downloads directory? But, it does require to download and unpack a JRE, which is almost as simple as downloading the Antlr tool jar file itself. You don't even need to put the JRE on you path variable, no JAVA_HOME setting, no classpath setting. That said, people can't even download files (see this recent SO question).

[parrt]

@ericvergnaud my main concern with running on AWS lambda is the financial risk because there's no limit and people could just ping that service with a for-loop and consume $100,000 overnight.

@kaby76 yeah, my new antlr4 python script really seems to work and I think it's going to be the easiest way for non- java people. Even for me, from the command line I'm going to use that script to play around.

[KvanTTT]

Right now I can go on a machine (Linux or Windows/msys2) and do git clone https://github.com/antlr/grammars-v4.git; cd grammars-v4/whatever-grammar-you-want; trgen -t whatever-target-you-want; cd Generated; make and I have a fully functioning application for the grammar in the target language and target OS.

It contains several steps instead of one and it requires installed JVM runtime.

Why would I want to offer to generate target source code files for parser and lexer online, then offer the developer to download the generated files, write a driver program in the target language locally and build locally?

Somtimes I just want to check a user's grammar without setuping. In this case online tool is the best choice.

Is the online tool going to allow the developer to add source files, restructure the application?

Probably yes, but now I don't imagine all detail.

I never understand why it is so hard to click on a link and download a file, but I do see it constantly in StackOverflow.

I understand you but I also understad users that have troubles with installation. They might not want to intall Java or other additional dependencies or deal with installation.

[parrt]

The hard part is not downloading stuff I think. With Java it's making sure you've got things in the class path and all of that. I'm working on this Python script, since most people have python installed already, that automatically downloads your requested version of antlr and installs a JRE if necessary. I tried it and it works on Windows Linux and Mac:

#3702

Could also be replicated in JavaScript if people wanted to build a local node.js server that serviced JavaScript on a webpage implementing an interactive tool like this. Or, node.js could simply call the python script.

The server could be something anybody can run or we could have a service sitting on a public server.

[parrt]

My main interest in a web based tool or even a local single page app is (1) debugging grammars w/o needing intellij and (2) allowing collaboration so people can submit bugs with a grammar, input, and associated state from a parse.

[parrt]

Part of this is education and increasing adoption of the tool because there's an easy way to try stuff out, as @KvanTTT says.

[yososs]

Question.

• How many edit steps in the lexer and parser definition files?
• How many files can be saved for testing?
• How many test files can be validated at the same time?
• (Can the quality of grammar be quantified and measured?)

[parrt]

Presumably you could edit as many times as you want like a mini development environment. I think each "page" for this grammar lab would allow either X.g4 or XParser.g4/XLexer.g4 combined but just one "language".

I would imagine also that we would use one input file a time for testing

I haven't ever thought about grammar quality but certainly the profiler helps to understand the behavior.

[parrt]

I just tried implementing a webpage that would operate like the antlr plugin for intellij/jetbrains.

Dynamically loading code is easy now with the import statement but I could not get it to pull in new code; I think with some tricks I can get it to pull in new code but it would be redefining functions and I think the heap would just keep getting bigger as the old versions of the code would not get collected.

There isn't a parser interpreter for JS like in some of the other target and so I can't pull in the new parser as just data. :(

Ideas are welcome. At the moment, I need a server that runs the Java antlr tool to generate parsers. Also because I cannot reload those parsers, I need that tool to also do the parsing and send the results back to the webpage. unpleasant but doable.

Suggestions welcome. JS/TS seems like a reasonable language but the ecosystem import/requires/node-vs-browser etc... Seems to be a God awful mess.

[parrt]

I used an argument that changed every reference to pull in the new code and it does seem to pull in and execute the new script:

<!DOCTYPE html> 
<html>
<script>
var x = 0;
function doit() {
  x = x + 1;
  m = import('/gen/myparser.js?arg='+x); // sees different file so repeats import
  m.then(module => {
      module.parse('world');
    });
}
</script>

<body>
<button onclick="doit()">Click</button>
</body>
</html>

[mike-lischke]

In fact, most of the necessary pieces for this project exist already.

1. A building framework like React, Preact, Vue etc. to build the web application. It takes care for transpilation, bundling, resource loading and so on.
2. A code editor based on Monaco editor (this one's for MySQL/JS/TS/PY, but can be adjusted to support ANTLR instead).
3. Support classes for code completion, code hints, renaming, formatting and so on.
4. Parsing services running in a web worker, for error checking and to support editor features as mentioned in 3).
5. Executing a grammar using the generated interpreter data in a grammar interpreter. This avoids the need to have the user create a project with generated files and execute input there.
6. Parse tree rendering.
7. A tree/grid for navigation, showing profiling results and other tabular data.

Obviously all these parts need adjustments to fit into this new ANTLR Playground tool, but at least they are all web-ready. No need to invent the wheel again.

The main challenge IMO is the generation of the interpreter data, as it requires a running ANTLR tool. For now this could be done as mentioned here already, maybe limiting the number of executions per time unit (to avoid high costs). My TS port of ANTLR4 could help out here later to have this run entirely in the browser (using web workers for time consuming tasks). But it's currently in a very early state, so this will take some time until it's ready.

[parrt]

Interpretation is the only thing that will work across all grammars. The problem we have is that currently I don't think there's a js implementation of the parser and lexer interpreter has there is in Java, which means pushing the actual parsing to a server connected over a socket. boo...

Even if the entire tool could be put into typescript or JavaScript we would still need the interpreter.

We should be careful that the typescript version is not a fork but one that is automatically generated from the main "java truth".

[mike-lischke]

The problem we have is that currently I don't think there's a js implementation of the parser and lexer interpreter has there is in Java

I'm not sure what you mean @parrt. The runtime contains the LexerInterpreter and ParserInterpreter classes. I only extended the parser interpreter to allow grammar debugging.

[parrt]

Weird. i looked for it in js target this weekend and didn't see it. must have missed it! That would solve a lot of issues

[mike-lischke]

The JS target is not complete (neither is antlr4ts) but they are complete enough to allow their use in normal scenarios. And antlr4ts (like the C++ runtime) contain the interpreter classes.

[parrt]

ah. good to know the interp exists.

[ericvergnaud]

I expect you’ll find it very hard to have a decently responsive UI without delegating parsing, analysis and checking to a worker. That would remove entirely the constraint you are mentioning when selecting a UI framework. Also, have cou considered ace as an alternative to monaco ?

…

Le 13 juin 2022 à 15:23, Mike Lischke ***@***.***> a écrit : With that decision you are constraining yourself very much. But after all this is your idea. Good luck! — Reply to this email directly, view it on GitHub <#3717 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAZNQJD3FJD6BTIWF4AMBSDVO4Y6VANCNFSM5WCO7PGQ>. You are receiving this because you commented.

[mike-lischke]

Is that a reply to me or Ivan? Or some of it for me and the rest for him? :-)

[parrt]

For my part, I'm looking at the antlr-related bits but would also like to figure out a decent web-based mechanism. I immediately thought of borrowing bits of VScode/monaco but wasn't sure I could spend the energy to learn yet another IDE framework haha.

[parrt]

What a great discussion we have here! We are also rich in possible implementation strategies! haha. We also have at least three potential proj owners/leaders: me, @KvanTTT, and @mike-lischke.

Possibilities

Mike: with your VSCode plugin, could we turn that into an isolated application or webpage that contacted an antlr-tool-service running either locally or remotely to process grammar and generate interpreter data?

As @KvanTTT pointed out, with all of the dependencies converting the complete tool chain to JavaScript/TS could be problematic. I'm guessing that launching a local service is the simplest approach to extract interpreter data.

I looked at the vscode/monaco stuff and that would be a huge learning task for me so I'm guessing I'm not gonna go down that path personally, but if somebody wants to launch this and use VSCode I'm totally happy with that.

In the end, I think we should have a very modest goal, which makes it a fairly simple problem. We're not trying to build a full development environment. In my view, this is really a debugger and learning tool:

1. Means creating a simple JavaScript single-page app with a text box for the grammar and some output panes. In future, these widgets could be replaced with real editor text box widgets
2. Vue.js or something to trigger events between them.
3. An antlr-tool-service would run locally as a server and provide interpreter data and possibly generate visual parts trees or whatever.
4. The JS target would run the parse in interpreter mode (borrowing the interpreter part from @sharwell's antlr4ts via MIT license).
5. We could have an executable that would launch the service and open a webpage for instant gratification
6. In addition, a webpage and Service could be available on the web for even faster instant gratification

Grammar sharing

Another component is the idea of sharing 40 bugging or education purposes. In other words, someone finds a problem with the parse or wants to demonstrate some thing to another person. Just like link shorteners, people could click a button to get Sharing link, but this would require a publicly visible server that saved grammars and input so that others could launch using that link.

My natural inclination at this point would be to simply start building something now that we have some understanding the primary roadblocks. I'm not saying I should necessarily be this person, but my first whack at the problem would be to simply create a python flask-based server that installed java/antlr (using https://github.com/antlr/antlr4-tool) then answered calls to process grammars. Next, a webpage to send grammars to the server for processing upon keystroke or button push. It wouldn't be pretty but it would be running within a few days. That would give us something concrete to evaluate and discuss.

[mike-lischke]

Mike: with your VSCode plugin, could we turn that into an isolated application or webpage that contacted an antlr-tool-service running either locally or remotely to process grammar and generate interpreter data?

There's VS Code for the web, which even can use some of the desktop VS Code extensions, Unfortunately, mine is not among them, as it requires Node.js functionality (processes, file system).

As @KvanTTT pointed out, with all of the dependencies converting the complete tool chain to JavaScript/TS could be problematic.

The only dependency is Java. That ANTLR4 requires some ANTLR3 and ST4 classes is not a blocking stone. Those classes belong to the same problem class like converting ANTLR4 itself to TS.

I'm guessing that launching a local service is the simplest approach to extract interpreter data.

A python app can open a web socket on the host of the web application and listen for commands coming from the web interface (which connects to this socket). It can handle the Java invocation to generate interpreter data and it can store the snapshots on disk which are needed for the web links for the playground. It can even provide access to all existing grammars (running get commands against Github) and provide enumeration for that to show a grammar tree in the UI (if wanted).

Thinking this further, the python server could handle everything what's done in the backend part of my extension: interpreter data generation, error checking, grammar file handling (interdependencies), helper functions for the UI providers (symbol retrieval, code completion, RRD generation, ATN graph generation, sentence generation, debugging) etc. Check the facade.ts file for all the features. This file is the interface between FE and BE. In the playground version this file would instead generate websocket requests and convert the received data from the websocket to something the FE can process.

With this approach you would never need a TS version of ANTLR4.

[mike-lischke]

If you want to spare you the time to convert the TS code to Python, you can of course run Node.js on the host and have it handle the websocket requests from the FE. This would have the benefit that you can use my TS code almost unchanged, including the Java invocation, data generation etc.

[mike-lischke]

We also have at least three potential proj owners/leaders: me, @KvanTTT, and @mike-lischke.

How chance wants it, I'm currently working full time on a web application like we discuss here. So I would be the perfect candidate to write the FE. However, the few hours spare time I have are dedicated to my other projects already. Everybody only has so much time, right :-)

[parrt]

Excellent info Mike. Thank you. Hmm...yeah, if I get the motivation maybe I will try to bang out some kind of prototype for people to criticize.

[parrt]

I just remembered the cool debugger built by @jean-bovet that we had for antlrworks (antlr3):

https://www.antlr3.org/works/

I think that would be very useful to have as well. The way it worked was a profiling/tracing parser listener tracked every action by the parser and then we used a time traveling debugger idea to move forward and backwards during parsing.

[mike-lischke]

ANTLRWorks was where I started from for my VS Code extension. So most of the features (and some more) exist already in the extension.

[whitten]

Could you elaborate on the idea of a time-traveling debugger idea?
Is there source code to know how to do this, and is it applicable to languages generated with ANTLR too?

[parrt]

Sure. As we march through the parser, let's keep track of the rules matched and the tokens matched. Then that trace can be sent to and interface that let you move forward and backwards and watch a cursor move through the grammar and input

[parrt]

Crap. Trying to learn js/ts and cobble together bits from antlr4ts / mike's stuff seems a sloooow road. Been converting ts to js to use js target but no doubt my efforts will take weeks to start running.

Maybe I should try pure antlr4ts and see if I can get working browser?

[mike-lischke]

Don't deal directly with JS. All you need can be done using TS and is proven to run in a browser environment. I'd suggest to start with one of the modern web app build tools (React, Vue etc., personally I know React pretty well, so I could provide help for that) and create an initial web app. This will set up all the pieces that are necessary to transpile TS, bundle it, bundle all resources (like images + CSS) and so on. Once that is in place you can start adding parser stuff. Usually 3rd party packages (like antlr4ts) are installed as node module and automatically bundled with the app, so that you get a fully self contained web app that doesn't need any 3rd party download from other web sources.

[mike-lischke]

The SourceContext class is at the heart of the grammar file management. There's one context per grammar file (be it parser-only, lexer-only or combined). It knows which other grammars are imported (via import or tokenVocab) and provides most of the services available for a grammar (code generation, code completion, sentence generation, debugging and so on). There are functions to test lexing and parsing using the interpreter. These functions are currently used for the sentence generation unit tests.

[mike-lischke]

Btw. the SourceContext class uses Node.js functionality (processes, filesystem, path handling, virtual machine), which will not work in a browser. But that's actually not needed. Instead it should run in a local Node.js process and communicates with the web app via websockets (as explained above).

[mike-lischke]

For a head start I recommend using Create React App (aka. CRA), which will give you a fully set-up dev environment in just a couple of minutes. More work is needed to learn React (JSX), but for this project you don't need to dive in deeply.

[parrt]

Yeah, all of this is a huge transaction cost to run some experiments. I would use Vue over React though because apparently it's a lot simpler and I tried it out already. But that's for another day. I was going to start with a trivial set of raw text boxes. I've decided that there's no way in hell I'm going to try to get all of these pieces to work together (plus use non-standard antlr4ts)... I could spend the next three weeks trying to figure all of this shit out. Instead, I'm going to shove everything to a server and send all of the parsing and debugging information back to the webpage. This is just a prototype so I'm OK if it's all thrown out...

[parrt]

OK now we're getting somewhere...

See https://github.com/antlr/antlr4-lab

With a simple web form like this:

the new JSON parse tree stuff sends back information from the server we can use to Display information about the parse:

[parrt]

Working on a prototype...When you hit “RUN”, server gets grammar/input/startrule and returns big wad of results/errors etc… I quietly rebuild input window text with items to add tool tips for hover info on each token in input. Does not affect input text display :) works like magic. MUUUUCH simpler than working with intellij. screenshot shows hover tooltip when cursor is over “able”.

[mike-lischke]

@parrt I played a bit with Github.dev today and I think I can make my ANTLR4 extension ready for the web. Users would then use e.g. https://github.dev/antlr/grammars-v4 to open any grammar and play with it. Not fully what @KvanTTT had in mind, but requires almost no work from your side. Just a thought...

[kaby76]

@parrt Thanks. My mistake. I see there is some code to decide what to display in the perf table, between LL vs strong LL perf numbers which are different. I was only printing LL decision info. The values look fine between C# and Java.

[parrt]

Cool. You can run any example you want via Java interp with pip install antlr4-tools (see https://github.com/antlr/antlr4-tools) then run antlr4-parse (though you have to have 4.10.2-SNAPSHOT installed locally at moment). That way you could compare what my interp thinks vs C#'s.

[mike-lischke]

@mike-lischke not only ATN generation but also syntax/semantics errors checking that is very important.

@KvanTTT That's already possible in the vscode extension (to a certain degree) without running the ANTLR4 tool.

[KvanTTT]

How is it implemented without running java tool? Are all errors and warnings covered?

[mike-lischke]

The extension has a parser for grammars, so it can report certain errors (via own error listeners + semantic checks), but not all (for example mutual left recursion). Debugging is possible by running the interpreter with the generated ATN. It does not require to generate a parser from a grammar. This limits action code to JS, however, but if such code is given (at least for predicates) it will be executed as part of the interpreter run, via dynamic evaluation. Currently this is done using a Node.js JS VM, which would obviously not work in a browser, so this will probably have to use eval or a dynamic Function instance.

[parrt]

Better buttons, shows token preview. Also got show/hide profile button:

---

Profile info and tree:

[kaby76]

Yay, I got the same numbers:

$ trperf -i "xy = 3+foo;" | column -t
line 1:6 token recognition error at: '+'
line 1:7 extraneous input 'foo' expecting ';'
Time to parse: 00:00:00.0407932
Decision  Rule     Invocations  Time      Total-k  Max-k  Fallback  Ambiguities  Errors
0         program  1            0.103778  2        2      0         0            2
1         stat     1            0.000587  2        2      0         0            2
2         def      0            0         0        0      0         0            0
3         def      0            0         0        0      0         0            0
4         expr     1            0.000187  1        1      0         0            1
5         expr     0            0         0        0      0         0            0
6         expr     1            0.034175  1        1      0         0            1
7         func     0            0         0        0      0         0            0

[parrt]

You can try http://lab.antlr.org if you like :)

[parrt]

Ok, a msg appears now upon bad start rule :)

[Serhioromano]

Please give a link to your github project I'll participate.
Also I have something like this

But after I click RUN it strips new lines

[Chaoses-Ib]

Please give a link to your github project I'll participate.

It's at https://github.com/antlr/antlr4-lab

[parrt]

Added issue antlr/antlr4-lab#5

[parrt]

SVG would be nice so it can be printed out

added issue antlr/antlr4-lab#6

[whitten]

I'm interested in multiple parses from an ambiguous grammar.
like I want a grammar rule that
says expr :- expr + num
and another one that
says: expr :- expr + 0

The idea is that if I build up a grammar bottom up from examples of
the language, I can have specialized recognition for cases that are
special, or that are notable but have the general rule to take care of the
input on a fall back case.

Or maybe generate rules that are special cases, and only afterward,
I'll then be able to analyze the generated grammar and see if they can
be handled by a general case that has to be learned.

I like http://lab.antlr.org because it lets me "doodle" with a grammar
before I pin it down. But I don't know if this lets me use procedures like
GetAllPossibleParseTrees mentioned on this page: https://www.antlr.org/api/JavaTool/org/antlr/v4/tool/GrammarParserInterpreter.html

Are my goals too hard for the tool as currently implemented ?
Thanks,
Dave Whitten
713-870-3834

[parrt]

Hi! ANTLR does not give you general "all interpretation" parses, however I will do so for a specific decision. In other words, we do not keep around all interpretations so that we avoid exploding trees. At a decision point however it does detect ambiguities and can tell you what those are.

[parrt]

Got SVG trees in now. See antlr/antlr4-lab#6

[parrt]

Testing new @antlr/core tag. Did you see this Tom?

[teverett]

yup

[parrt]

woot! fancy tech

[kaby76]

Hi All, I prototyped some UI in antlr4-lab to add a control for loading a grammar from grammars-v4. If anyone is interested, you can see what it looks like over here. Comments welcomed.

[ericvergnaud]

Hi,On top of Ken’s proposal, various ideas that come to mind:- upload a grammar from an existing g4- download a grammar as g4- provide a ‘combined’ tab to avoid the probable confusion re Lexer/parse with newbiesEnvoyé de mon iPhoneLe 4 oct. 2022 à 12:23, Ken Domino ***@***.***> a écrit : Hi All, I prototyped some UI in antlr4-lab for adding a control for loading a grammar from grammars-v4. If anyone is interested, you can see what it looks like over here. Comments welcomed. —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you commented.Message ID: ***@***.***>

[KvanTTT]

Fix grammar and suggest a pull request to the repository.

[kaby76]

Here's what that grammars-v4 select now looks like:

As I mentioned elsewhere, I can flip through grammars and check out at the performance profile for the input really quickly. So, this could be a really useful tool.

Right now there's one select control for selecting a grammar plus one input. I'm wondering about whether there should be two select controls, one select for the grammars like "abb", "abnf", "cpp", etc., positioned by the "lexer/parser" tabs, and a second select for the various examples in the examples/ directory for the grammar, positioned over by the "Input" tab on the right-hand side.

With all these great ideas, we're going to run out of real estate.

BTW, does anyone know how zoom over the parse tree drawing is supposed to work? I have a standard Windows desktop with two mouse buttons and one wheel.

[ericvergnaud]

May I suggest that the grammar selector would fit more naturally above the lexer/parser tabs ?

…

Le 4 oct. 2022 à 19:35, Ken Domino ***@***.***> a écrit : Here's what that grammars-v4 select now looks like: <https://user-images.githubusercontent.com/11389451/193885307-3e9079b0-cc06-4f43-9886-3721a45693d6.png> As I mentioned elsewhere, I can flip through grammars and check out at the performance profile for the input really quickly. So, this could be a really useful tool. Right now there's one select control for selecting a grammar plus one input. I'm wondering about whether there should be two select controls, one select for the grammars like "abb", "abnf", "cpp", etc., positioned by the "lexer/parser" tabs, and a second select for the various examples in the examples/ directory for the grammar. With all these great ideas, we're going to run out of real estate. BTW, does anyone know how zoom over the parse tree drawing is supposed to work? I have a standard Windows desktop with two mouse buttons and one wheel. — Reply to this email directly, view it on GitHub <#3717 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAZNQJCMRQAKOX4YICQ4QALWBRTEJANCNFSM5WCO7PGQ>. You are receiving this because you commented.

[kaby76]

Yep. I just moved that. Now working out the input select control.

All the links to the grammars and input are placed in one giant table in the client. So it's not exactly "live", but is when a grammar is selected cause the client downloads with the scaped links.

[hagen666]

Jupyter maybe a choice but the antlr-lab is more convenient.
Here is a jupyterlab link:
https://developer.huaweicloud.com/develop/aigallery/notebook/detail?id=9ea7f844-2a05-49d0-b117-1260f65ef87d
It may be helpful for antlr learners.

[parrt]

That is pretty cool. Thanks for passing it along.