Recently, I wrote a GPP macro for a counting loop.

 Java lacks a loop to only express »repeat the following
 statement n times« and not add any other designation.

 The following prints »alpha« 6 times.
 Two such loop control macors are nested.

public class Main
{ public static void main ( final java.lang.String[] args )
 { REPEAT( 2 )
   REPEAT( 3 )
   java.lang.System.out.println( "alpha" ); }}

 The code generated is:

public class Main
{ public static void main ( final java.lang.String[] args )
 { for(int SYM1=( 2 );(SYM1--)!=0;)
   for(int SYM2=( 3 );(SYM2--)!=0;)
   java.lang.System.out.println( "alpha" ); }}

 and I did it as follows. gpp does not contain a symbol name
 generator, but is so versatile that one can write it on
 the fly using the powerful »defeval« and »eval« meta-macros:

<#define REPEATNAME|0>
<#define NEXTSYM|<#defeval REPEATNAME|<#eval 1+<#REPEATNAME>>>>
<#define REPEAT|<#NEXTSYM>for(int SYM<#REPEATNAME>=(#1);(SYM<#REPEATNAME>--)!=0;)>

 I have defined another gpp-mode, where I can write definitions like:

$define BLOCK new java.lang.Runnable(){ public void run(){$1}}

$define IN_EDT javax.swing.SwingUtilities.invokeLater($1)

 Then, to execute any statement in the EDT:

$define INEDT IN_EDT(BLOCK($1))

 Debug-print where we are:

$define LOCATE do{ java.lang.System.out.print( new java.lang.Throwable().getStackTrace()[0].toString() + ": " );  }while(false)

 Debug-display a reference variable with its name, type and value:

$define DISPLAY do{ LOCATE(); java.lang.System.out.println( "\"$1\" =( " +((( $1 )== null )? "null" :( $1 ).getClass().getName() )+ " )\"" +( $1 )+ "\"." ); }while(false)

 Drawback for the aficionados of Eclipse and similar IDEs:
 The IDE will not recognice some of the macro syntax.

Why? As long as Java syntax stays backward compliant all macros
creating code for old syntax will work.

Thanks for that although the last release was in 2004. :(

Greetings,
Marco.

With macros its possible to create new abstraction layers into the java
programming language without the need of parsers. For instance it would
be possible to create Singletons (or other paradigms) without the need
of knowing implementation details. Another example is the usage of
shortcuts for syntatic constructs. If I need to handle a lot of
integers it could be more understandable to say

for(int i : 1..5)

instead of

for(int i=1; i++; i<=5)

As one could see in LISP there are a lot of applications for this.

Greetings,
Marco.