ANTLR VS xvm

antlr https://github.com/antlr/antlr4

Download the ANTLR jar from https://www.antlr.org/download/antlr-4.9.2-complete.jar Add the ANTLR jar to your project's classpath. Install the ANTLR Kotlin target by following the instructions at https://github.com/antlr/antlr4/blob/master/doc/targets/Kotlin.md Next, you'll need a Perl grammar file for ANTLR:

Depending on how complex your expressions are, you might consider using something like antlr and writing your own parser for it. Setting up something to handle math and string operations wouldn’t be very hard and then you can control the syntax however you like. You can use a visitor and visit each node in the syntax tree and return the result of each sub-expression.

> ...than it would be to learn the exact syntax and quirks and possibly bugs of someone else's implementation...

Yup. Also, having deep knowledge of the language is required.

SQLite's grammar is neat. Creating a compatible parser would make a fun project. Here's a pretty good example: https://github.com/bkiers/sqlite-parser (Actual ANTLR 4 grammar: https://github.com/bkiers/sqlite-parser/blob/master/src/main... )

Postgres, which tries to be compliant with the latest standards, however...

SQL-2016 is a beast. Not to mention all the dialects.

I'm updating my personal (soon to be FOSS) grammar from ANTLR 3 LL(k) to ANTLR 4 ALL().

I've long had a working knowledge of SQL-92, with some SQL-1999 (eg common table expressions).

But the new structures and extensions are a bit overwhelming.

Fortunately, ANTLR project has ~dozen FOSS grammars to learn from. https://github.com/antlr/grammars-v4/tree/master/sql

They mostly mechanically translate BNFs to LL(k) with some ALL(). Meaning few take advantage of left-recursion. https://github.com/antlr/antlr4/blob/master/doc/left-recursi...

Honestly, I struggled to understand these grammars. Plus, not being conversant with the SQL-2016 was a huge impediment. Just finding a succinct corbis of test cases was a huge hurdle for me.

Fortunately, the H2 Database project is a great resource. https://github.com/h2database/h2database/tree/master/h2/src/...

Now for the exciting conclusion...

My ANTLR grammar which passes all of H2's tests looks nothing like any of the official or product specific BNFs.

Further, I found discrepancy between the product specific BNFs and their implementations.

So a lot of trial & error is required for a "real world" parser. Which would explain why the professional SQL parsing tools charge money.

I still think creating a parser for SQLite is a great project.

can be used to parse

I already posted here about a project, but I could also use help on Mantle. It's a new command framework powered by ANTLR, if that's something you're interested in.

ive been tryng to work with antlr4 and go but it seems that i cant import the runtime, it says that the antlr runtime isnt in the gopath but ive already done go get github.com/antlr/antlr4/runtime/antlr4 and i dont know what to do now, im on windows if anyone knows what to do it would be very helpful. thanks already

An alternate approach is to implement the SQL grammar using parser generators like ANTLR. There are similar open source parser generators in other popular languages.

We will change it a little bit soon, but for now let's look on what's going on there. In general, grammar consists of parser and lexer rules.

I'm just going to warn you in advance that invocation is one of the hardest things in the compiler to make easy. In other words, the nicer your language's "developer experience" is around invocation, the more hell you're going to have to go through to get there. The AST nodes for Name( (NameExpression) and Invoke( (InvocationExpression) alone are 7kloc in the Ecstasy implementation, for example -- but the result is well worth it.

Ecstasy uses message passing automatically behind the scenes for asynchronous calls, but the message passing isn't visible at the language level (i.e. there is no "message object" or something like that visible). Basically, all Ecstasy code is executing on a fiber inside a service, and services are all running concurrently, so from any service realm to any service realm, the communication is by message.

Regarding Ecstasy, we did not set out to build a new language; we actually set out to solve a real world problem. Specifically, we wanted to be able to dramatically improve the density of workloads in data centers, by at least two orders of magnitude in the case of lightly used applications. Our initial goal was to create a runtime design that would support 10,000 stateful application instances on a single server. Let's call it the "a10k" problem 🤣 ... a tribute to the c10k problem from 1999. We refer to our goal as "zero carbon compute", i.e. we want to push the power and hardware cost for an application to as close to zero as possible; you can't reach zero, but you can get close. If we succeed, we will help reduce the electricity used in data centers over the next few decades by a significant percentage.

Parts of Ecstasy are now implemented in Ecstasy. Here's the Lexer, for example.

Ecstasy

A Future reference has the various capabilities that you'd imagine, taking lambdas for thenDo(), whenComplete(), etc. The reference, in the above example, is a local variable, so you just obtain it using the C-style & operator:

FWIW - here is the stage manager code that I referred to.

Ecstasy (xtclang.org): Currently working on session management for a cloud-based HTTP back end. Not exactly compiler or language stuff, but it certainly is exercising the compiler and language.

I prefer to make my AST nodes fairly rich, and let them do the brunt of the work themselves. Instead of the 5 lines of code above, the assignment statement node in Ecstasy is over 1000 LOC. But it handles everything from initial validation through the MLIR emission.

No, not that specific project. It's our own Mid Level Intermediate Representation (or Mid Level Intermediate Language), aka MLIR/MLIL. Here's a snapshot of the operators.