Converting Antlr syntax tree into useful objects

Question

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:

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")
        }
    }
}

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

Previous related questions by me (Could be useful):

Bart Kiers · Accepted Answer · 2010-02-09T15:49:21.143

4

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
- ...

edited Feb 09 '10 at 15:49

answered Feb 07 '10 at 19:20

Bart Kiers

166,582
36
299
288

Thanks, I bought the book. Should arrive in the next few days. Hmm...stuck until then :| – Richard Walton Feb 08 '10 at 23:21
Book arrived today. Looks like the sort of stuff I need. Many thanks for the recommendation – Richard Walton Feb 11 '10 at 12:54

score 2 · Answer 2 · answered Feb 17 '10 at 18:16

2

Here's one with ANTLR -> LLVM:

answered Feb 17 '10 at 18:16

Terence Parr

5,912
26
32

score 0 · Answer 3 · answered Feb 07 '10 at 15:56

0

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

answered Feb 07 '10 at 15:56

duffymo

305,152
44
369
561

Are you aware of any examples which explain this concept better? Thanks – Richard Walton Feb 07 '10 at 18:05
Yes, the ANTLR book has a chapter on templates and AST. – duffymo Feb 07 '10 at 21:55

score 0 · Answer 4 · answered Feb 09 '10 at 16:16

0

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.

answered Feb 09 '10 at 16:16

Lolindrath

2,101
14
20

Converting Antlr syntax tree into useful objects

4 Answers4

Linked