CODEWITHSUNDEEP
javaantlrexecutionabstract-syntax-tree
Richard Walton
Richard Walton

Reputation: 4785

Converting Antlr syntax tree into useful objects

I'm currently pondering how best to take an AST generated using Antlr and convert it into useful objects which I can use in my program.

The purpose of my grammar (apart from learning) is to create an executable (runtime interpretted) language.

For example, how would I take an attribute sub-tree and have a specific Attribute class instanciated. E.g.

The following code in my language:

Print(message:"Hello stackoverflow")

would product the following AST:

alt text

My current line of thinking is that a factory class could read the tree, pull out the name (message), and type(STRING) value("Hello stackoverflow"). Now, knowing the type I could instanciate the correct class (e.g. A StringAttribute class) and pass in the required attribute data - the name and value.

The same approach could be used for a definition factory, pulling out the definition name (Print), instanciating the Print class, and then passing in the attributes generated from the attribute factory.

Things do get a bit more complicated with a more complicated program:

Program(args:[1,2,3,4,5])
{
    If(isTrue:IsInArray(array:{Program.args} value:5))
    {
        Then {
            Print(message:"5 is in the array")
        } Else {
            Print(message:"More complex " + "message")
        }
    }
}

alt text

ANY/ALL help or thoughts are very welcome. Many thanks.

Previous related questions by me (Could be useful):

  1. How do I make a tree parser
  2. Solving LL recursion problem
  3. Antrl3 conditional tree rewrites

Upvotes: 5

Views: 3703

Answers (4)

Terence Parr
Terence Parr

Reputation: 5962

Here's one with ANTLR -> LLVM:

Upvotes: 2

Lolindrath
Lolindrath

Reputation: 2101

This Tutorial is based on Flex and Bison but at the end he details how he converts his AST to LLVM assembly code, it might be helpful.

Upvotes: 0

Bart Kiers
Bart Kiers

Reputation: 170158

I recommend reading chapter 9, Building High-Level Interpreters, from Language Implementation Patterns by Terence Parr.

EDIT

Okay, to get you through the time waiting for that book, here's what you're (at least) going to need:

  • a global memory space;
  • function spaces (each function space will also have a (local) memory space);

and classes that spring to mind (in UML-ish style):

  • class Interpreter
    • global : MemorySpace
    • functions : Stack<Function>
    • ...

  • class MemorySpace
    • vars : Map<String, Object>
    • ...

  • class Function
    • local: MemorySpace
    • execute(): void
    • ...

Upvotes: 4

duffymo
duffymo

Reputation: 308763

Once you have the AST, all you need is an iterator to walk the tree and the template to emit the objects you want.

Upvotes: 0

Related Questions