Give instructions to the Java parser/lexer

Question

Is there any way to give instructions directly to the parser and lexar from the java code level? If not, how could one go about doing this at all?

The issue is that I want to have the parser evaluate a variable, back up, then assign the value of that variable as an Object name. Like this:

String s = "text";

SomeClass (s) = new SomeClass();

parser reads--> ok, s evaluates to be "text"... parser backtracks, while holding "text" in memory and assigns "text" as the name of the new instance of SomeClass, such that one can now do this:

text.callSomeMethod();

I need to do this because I have to instantiate an arbitrary number of objects of SomeClass. Each one has to have a unique name, and it would be ideal to do something like this:

while (someArbitrarySet.hasNext()) {
    String s = "token" + Math.random();
    SomeClass (s) = new SomeClass();
    (s).callSomeMethod();
}

I hope this makes sense...

Answer 1

What you're asking for is what some languages call MACROS. They're also sometimes known as preprocessor definitions, or simply "defines".

A decision was made to not have includes and macros and the like in Java because it introduces additional code maintenance concerns that the designers concluded was going to cause code that would not have been in the style they wanted.

However, just because it's not built into the compiler doesn't mean you couldn't add it to your build script.

As part of your build, you copy all files to a src-comp directory, and as you do, replace your tokens as they're defined.

I don't recommend doing it, but that doesn't mean it isn't possible.

Answer 2

What you describe (creating new named variables at runtime) is possible in interpreted languages like JavaScript, Lua, Bash, but not with a compiled language like Java. When the loop is executed, there is no source code there to manipulate, and all named variables have to be defined before.

Apart from this, your variables don't need a "unique" name, if you are using them sequentially (one after another), you could just as well write your loop as this:

while (someArbitrarySet.hasNext()) {
    SomeClass sC = new SomeClass();
    sC.callSomeMethod();
}

If you really need your objects at the same time, put them in some sort of data structure. The simplest would be an array, you could use a Collection (like an ArrayList) or a Map (like CajunLuke wrote), if you want to find them again by key.

In fact, an array (in Java) is nothing else than a collection of variables (all of the same type), which you can index by an int.

(And the scripting languages which allow creating new variables on runtime implement this also with some kind of map String → (anything), where this map is either method/script-local or belonging to some surrounding object.)

---

You wrote in a comment to the question (better add those things to the question itself, it has an "edit" button):

Without getting into too many details, I'm writing an application that runs within a larger program. Normally, the objects would get garbage-collected after I was done with them, but the larger program maintains them, thus the need for a unique name for each. If I don't give each a unique name, the old object will get overwritten, but it is still needed in the context of the greater program.

So, you want to retain the objects to avoid garbage collection? Use an array (or List or anything else).

The thing is, if you want your larger program to be able to use these objects, you somehow have to give them to this larger program anyway. And then this program would have to retain references to these objects, thereby avoiding garbage collection. So it looks you want to solve a problem which does not exist by means which do not exist :-)

Answer 3

Not really an answer to the question you asked, but a possible solution to your problem: using a map.

Map variables = new HashMap();
while (someArbitrarySet.hasNext()) {
    String s = "token" + Math.random();
    variables.put(s, new SomeClass());
    variables.get(s).callSomeMethod();
}

That way, you can use the "variable name" as the keys into the map, and you can get by without messing with the lexer/parser.

I really hope there is a way to do specifically what you state in Java - it would be really cool.

Answer 4

No. That's not possible.

Even if you could I can't think on a way to invoke them, because there won't be compiling code that could successfully reference them.

So the options are the one described by CanjuLuke or to create your own java parser, probably using ANTRL sample Java grammar and hook what you need there.

Consider the map solution.

Answer 5

This is answered in How do you use Java 1.6 Annotation Processing to perform compile time weaving? .

In short, there is an annotation processing tool that allows you to extend java syntax, and create DSLs that compile to java annotations.

Under JDK 1.5 you had to use apt instead of javac, but under 1.6, these are affected by the -processor flag to javac. From javac -help:

-processor <class1>[<class2>,<class3>...]Names of the annotation processors to run; bypasses default discovery process
-processorpath <path>      Specify where to find annotation processors