prettyprinter std of java is

auxillary package "lang.java.ppstd";

*x!0 -> "...";

par:*x -> [<h 0> "(" *x ")"];

compilationUnit(none(),*y,*z) -> [<v 1,0>  *y *z];

compilationUnit(*x,*y,*z) -> [<v 1,0> pck:*x *y *z];

pck:*x -> [<h 1> "package" *x ";"];

type:*x -> [<h 0> in class=type : *x];

modif:*x -> [<h 0> in class=modif : *x];

importDeclarations[**x] -> [<v 0,0> ( [<h 1> "import" [<h 0> **x ";"]])];

typeDeclarations[**x] -> [<v 0,0> (  **x ) ];
semi:typeDeclarations[**x] -> [<v 0,0> (  semi:**x ) ];

semi:fieldDeclarations[**x] -> [<h 2> ""  [<v 0,0> (  semi:**x ) ]];

modifiers[**x] -> [<h 1> (  **x ) ];

classDeclaration(modifiers[],*y,none(),typeNames[],fieldDeclarations[]) -> 
	[<h 1> "class" type:*y "{}" ];
classDeclaration(*x,*y,none(),typeNames[],fieldDeclarations[]) -> 
	[<h 1> modif:*x "class" type:*y "{}" ];
classDeclaration(modifiers[],*y,none(),*t,fieldDeclarations[]) -> 
	[<h 1> "class" type:*y  "implements"  *t "{}" ];
classDeclaration(*x,*y,none(),*t,fieldDeclarations[]) -> 
	[<h 1> modif:*x "class" type:*y  "implements"  type:*t "{}" ];
classDeclaration(modifiers[],*y,*z,typeNames[],fieldDeclarations[]) -> 
	[<h 1> "class" type:*y "extends" type:*z "{}" ];
classDeclaration(*x,*y,*z,typeNames[],fieldDeclarations[]) -> 
	[<h 1> modif:*x "class" type:*y "extends" type:*z "{}" ];
classDeclaration(modifiers[],*y,*z,*t,fieldDeclarations[]) -> 
	[<h 1> "class" type:*y "extends" type:*z "implements" type:*t "{}" ];
classDeclaration(*x,*y,*z,*t,fieldDeclarations[]) -> 
	[<h 1> modif:*x "class" type:*y "extends" type:*z "implements" type:*t "{}" ];
classDeclaration(modifiers[],*y,none(),typeNames[],*u) -> 
	[<v 0,0> [<h 1> "class" type:*y "{" ]  semi:*u "}" ];
classDeclaration(*x,*y,none(),typeNames[],*u) -> 
	[<v 0,0> [<h 1> modif:*x "class" type:*y "{" ]  semi:*u "}" ];
classDeclaration(modifiers[],*y,none(),*t,*u) -> 
	[<v 0,0> [<h 1> "class" type:*y "implements"  type:*t "{" ]  semi:*u  "}" ];
classDeclaration(*x,*y,none(),*t,*u) -> 
	[<v 0,0> [<h 1> modif:*x "class" type:*y "implements"  type:*t "{" ]  semi:*u  "}" ];
classDeclaration(modifiers[],*y,*z,typeNames[],*u) -> 
	[<v 0,0> [<h 1> "class" type:*y "extends" type:*z "{" ] semi:*u "}" ];
classDeclaration(*x,*y,*z,typeNames[],*u) -> 
	[<v 0,0> [<h 1> modif:*x "class" type:*y "extends" type:*z "{" ] semi:*u "}" ];
classDeclaration(modifiers[],*y,*z,*t,*u) -> 
	[<v 0,0> [<h 1> "class" type:*y "extends" type:*z "implements" type:*t "{"]  semi:*u "}" ];
classDeclaration(*x,*y,*z,*t,*u) -> 
	[<v 0,0> [<h 1> modif:*x "class" type:*y "extends" type:*z "implements" type:*t "{"]  semi:*u "}" ];

interfaceDeclaration(modifiers[],*y,typeNames[],*t) ->
	[<v 0,0> [<h 1> "interface" *y "{"]  semi:*t "}" ];
interfaceDeclaration(modifiers[],*y,*z,*t) -> 
	[<v 0,0> [<h 1> "interface" *y "extends" type:*z "{"]  semi:*t "}" ];
interfaceDeclaration(*x,*y,typeNames[],*t) -> 
	[<v 0,0> [<h 1> modif:*x "interface" *y "{"]  semi:*t "}" ];
interfaceDeclaration(*x,*y,*z,*t) -> 
	[<v 0,0> [<h 1> modif:*x "interface" *y "extends" type:*z "{"]  semi:*t "}" ];

semi:interfaceFieldDeclarations[**x] -> [<h 2> "" [<v 0,0> (semi:**x)]];

semi:methodDeclaration(modifiers[],*z,*t,typeNames[],none()) ->
	[<h 0>  [<h 1> type:*z  *t]  ";"] ;
semi:methodDeclaration(modifiers[],*z,*t,typeNames[],block[]) ->
	[<h 0>  [<h 1> type:*z  *t]  "{};"] ;
semi:methodDeclaration(*x,*z,*t,typeNames[],none()) ->
	[<h 0>  [<h 1> modif:*x type:*z  *t]  ";"] ;
semi:methodDeclaration(*x,*z,*t,typeNames[],block[]) ->
	[<h 0>  [<h 1> modif:*x type:*z  *t]  "{};"] ;
semi:methodDeclaration(modifiers[],*z,*t,typeNames[],*v) ->
	[<v 0,0>  [<h 1> type:*z  *t "{"] [<h 2> "" semi:*v] "}"];
semi:methodDeclaration(*x,*z,*t,typeNames[],*v) ->
	[<v 0,0>  [<h 1> modif:*x type:*z  *t "{"] [<h 2> "" semi:*v] "}"];
semi:methodDeclaration(modifiers[],*z,*t,*u,none()) ->
	[<h 0>  [<h 1> type:*z *t "throws" *u] ";"];
semi:methodDeclaration(modifiers[],*z,*t,*u,block[]) ->
	[<h 0>  [<h 1> type:*z *t "throws" *u] "{};"];
semi:methodDeclaration(*x,*z,*t,*u,none()) ->
	[<h 0>  [<h 1> modif:*x type:*z *t "throws" *u] ";"];
semi:methodDeclaration(*x,*z,*t,*u,block[]) ->
	[<h 0>  [<h 1> modif:*x type:*z *t "throws" *u] "{};"];
semi:methodDeclaration(modifiers[],*z,*t,*u,*v) ->
	[<v 0,0>  [<h 1> type:*z  *t "throws" *u  "{" ]
         [<h 2> "" semi:*v] "}"];
semi:methodDeclaration(*x,*z,*t,*u,*v) ->
	[<v 0,0>  [<h 1> modif:*x type:*z  *t "throws" *u "{" ]
         [<h 2> "" semi:*v] "}"];

semi:constructorDeclaration(modifiers[],*t,typeNames[],none()) ->
	[<h 0>  [<h 1> *t]  ";"] ;
semi:constructorDeclaration(*x,*t,typeNames[],none()) ->
	[<h 0>  [<h 1> modif:*x *t]  ";"] ;
semi:constructorDeclaration(modifiers[],*t,typeNames[],*v) ->
	[<v 0,0>  [<h 1> *t "{"] [<h 2> "" semi:*v] "}"];
semi:constructorDeclaration(*x,*t,typeNames[],*v) ->
	[<v 0,0>  [<h 1> modif:*x *t "{"] [<h 2> "" semi:*v] "}"];
semi:constructorDeclaration(modifiers[],*t,*u,none()) ->
	[<h 0>  [<h 1> *t "throws" *u] ";"];
semi:constructorDeclaration(*x,*t,*u,none()) ->
	[<h 0>  [<h 1> modif:*x *t "throws" *u] ";"];
semi:constructorDeclaration(modifiers[],*t,*u,*v) ->
	[<v 0,0>  [<h 1> *t "throws" *u   "{"]
         [<h 2> "" semi:*v] "}"];
semi:constructorDeclaration(*x,*t,*u,*v) ->
	[<v 0,0>  [<h 1> modif:*x *t "throws" *u "{"]
         [<h 2> "" semi:*v] "}"];

fieldVariableDeclaration(modifiers[],*y,*z) ->
	[<h 1> type:*y *z];
fieldVariableDeclaration(*x,*y,*z) ->
	[<h 1> modif:*x type:*y *z];
localVariableDeclaration(none(),*y,*z) ->
	[<h 1> type:*y *z];
localVariableDeclaration(*x,*y,*z) ->
	[<h 1> "final" type:*y *z];

variableDeclarators[*x] -> *x;
variableDeclarators[**x,*y] -> [<h 0> ( **x ",") *y];

typeNames[**x,*y] -> [<h 0> ( **x ",") *y];

identifier *x -> identitypp(*x);

onDemand(*x) -> [<h 0> *x ".*"];

methodDeclarator(*x,*y) -> [<h 0> *x  *y ];

constructor(*x,*y) -> [<h 0> in class=type :*x  *y ];

parameters[] -> "()";
parameters[*x] -> [<h 0> "(" *x ")"];
parameters[**x,*y] -> [<h 0> "(" [<h 1> ( [<h 0> **x ","] ) *y] ")"];

parameter(none(),*x,*y) -> [<h 1> type:*x *y];
parameter(final(),*x,*y) -> [<h 1> "final" type:*x *y];
arrayof(*x) -> [<h 0> *x "[]"  ];
array(*x)->[<h 0> *x "[]"  ];
arrayInitializer[]->"{}";
arrayInitializer[*x]->[<h 0> "{" *x "}"];
arrayInitializer[**x,*y]->[<hv 0,0,0> "{" ( **x ",") *y "}"];


initializedVariable(*x,*y) -> [<h 0> *x "=" *y];

block[**x] -> [<v 0,0> ( [<h 0> **x] )];
catches[**x] -> [<v 0,0> ( [<h 0> **x] )];
semi:block[**x] -> [<v 0,0> ( semi:**x )];
semi:catches[**x] -> [<v 0,0> ( semi:**x )];
ns:block[**x] -> [<v 0,0> ( **x )];
ns:catches[**x] -> [<v 0,0> ( **x )];
ns:*x -> *x;

*t as binary(*x,*y,*z) ->  [<hv 0,0,0> if leftp(*t,*x)
                                   then par:*x
                                   else *x
                                  end
                                  *y
                                  if rightp(*t,*z)
                                   then par:*z
                                   else *z
                                  end];

cond(*x,*y,*z)->[<h 0> "(" *x ")" "?" *y ":" *z];
instanceof(*x,*y) -> [<h 1> *x "instanceof" *y];

semi:synchro(*x,block[**y]) -> 
  [<v 0,0> [<h 1>  "synchronized" [<h 0> "(" *x ")"] "{"]
        [<h 2> "" [<v 0,0> (  semi:**y )]] "}"];
 


assignment() -> "=";
minusAssignment() -> "-=";
plusAssignment() -> "+=";
timesAssignment() -> "*=";
divAssignment() -> "/=";
modAssignment() -> "%=";
rightShiftAssignment() -> ">>=";
unsignedRightShiftAssignment() -> ">>>=";
leftShiftAssignment() -> "<<=";
andAssignment() -> "&=";
xorAssignment() -> "^=";
iorAssignment() -> "!=";
leftShift() -> "<<";
rightShift() -> ">>";
unsignedRightShift() -> ">>>";
neq() -> "!=";
eq() -> "==";
minus() -> "-";
plus() -> "+";
land() -> "&&";
times() -> "*";
mod() -> "*";
div() -> "/";
and() -> "&";
lor() -> "||";
ior() -> "|";
xor() -> "^";
not() -> "!";
complement() -> "~";
less() -> "<";
lessEq() -> "<=";
gtr() -> ">";
gtrEq() -> ">=";
decr() -> "--";
incr() -> "++";

*z as postfix(*x,*y) -> [<h 0> *x if unip(*z,*y)
                                   then par:*y
                                   else *y
                                  end
                        ];
*z as prefix(*x,*y) -> [<h 0> *x  if unip(*z,*y)
                                   then par:*y
                                   else *y
                                  end
                        ];
*z as unary(*x,*y) -> [<h 0> *x  if unip(*z,*y)
                                   then par:*y
                                   else *y
                                  end
                        ];
*z as cast(*x,*y) -> [<h 0> "(" *x ")"  if unip(*z,*y)
                                   then par:*y
                                   else *y
                                  end
                        ];
integer *x -> identitypp(*x);
linteger *x -> identitypp(*x);
string *x ->  stringpp(*x);
character *x ->  identitypp(*x);
floating *x ->  identitypp(*x);
hexa *x ->  identitypp(*x);

superInvocation(*x) -> [<h 0> "super" *x];
thisInvocation(*x) -> [<h 0> "this" *x];
call(*x,*y) -> [<h 0> *x *y];

newObject(*x,*y,*z,fieldDeclarations[])->[<h 1> "new" [<h 0> type:*y *z]];
newObject(*x,*y,*z,*t)->[<h 1> "new" [<v 0,0> [<h 0> type:*y *z "{"]
                                         semi:*t "}"]];
newArray(*x,*y)->[<h 1> "new" [<h 0> type:*x *y]];
newDim(*x,*y,dims[],arrayInitializer[])-> [<h 1> "new" [<h 0> type:*x *y]];
newDim(*x,*y,dims[],*z)-> [<h 1> "new" [<h 0> type:*x  *y *z]];
newDim(*x,*y,*z,arrayInitializer[])-> [<h 1> "new" [<h 0> type:*x *y *z]];
newDim(*x,*y,*z,*t)-> [<h 1> "new" [<h 0> type:*x *y *z *t]];

dims:dim() -> "[]";
dims:*x -> [<h 0> "[" *x "]"];
dims[**x] -> [<h 0> (dims:**x)];

index(*x,*y) -> [<h 0> *x "[" *y "]"];
access(*x,*y) -> [<h 0> *x "." *y];
return(none()) -> "return";
return(*x) -> [<h 1> "return" *x];

expressions[] -> "()";
expressions[*x] -> [<h 0> "(" *x ")"];
expressions[**x,*y] -> [<h 0> "(" (**x ",") *y ")"];
np:none() -> "";
np:expressions[] -> "";
np:expressions[**x,*y] -> [<h 0> (**x ",") *y];
np:*x -> *x;

semi:try(block[**x],catches[],*y) ->
  [<v 0,0> "try {" [<h 2> "" [<v 0,0> ( semi:**x )]] "}" "finally {"
     [<h 2> "" *y] "}"];
semi:try(*x,catches[],*y) ->
  [<v 0,0> "try"
    [<h 2> ""  *x]
    "finally {"  [<h 2> "" *y] "}"];
semi:try(block[**x],*y,none()) ->
  [<v 0,0> "try {"  [<h 2> "" [<v 0,0> ( semi:**x )]] "}" 
    ns:*y];
semi:try(*x,*y,none()) ->
  [<v 0,0> "try" 
     [<h 2> "" *x] ns:*y];
semi:try(block[**x],*y,*z) ->
  [<v 0,0> "try {"  [<h 2> "" [<v 0,0> (  semi:**x )]] "}" 
      ns:*y "}"
     "finally {"
     [<h 2> "" *z] "}"];
semi:try(*x,*y,*z) ->
  [<v 0,0> "try" 
     [<h 2> "" *x]
     ns:*y
     "finally {"
     [<h 2> "" *z] "}"];
catch(*x,block[]) ->
 [<h 0> "catch" "(" *x ") {}"];

catch(*x,block[**x]) ->
  [<v 0,0> [<h 0> "catch" "(" *x ") {"]
    [<h 2> "" [<v 0,0> (semi:**x )]] "}"];

catch(*x,*y) ->
  [<v 0,0> [<h 0> "catch" "(" *x ")"]
    [<h 2> ""  *y]];

throw(*x) -> [<h 1> "throw" *x];


semi:if(*x,block[**y],none()) ->
  [<v 0,0> [<h 1> "if" [<h 0> "(" *x ")"] "{"]
           [<h 2> "" [<v 0,0> ( semi:**y )]]
           "}"];
semi:if(*x,*y,none()) ->
  [<v 0,0> [<h 1> "if" [<h 0> "(" *x ")"]]
           [<h 2> "" semi:*y]];

semi:if(*x,block[**y],*z) ->
  [<v 0,0> [<h 1> "if" [<h 0> "(" *x ")"] "{"]
           [<h 2> "" [<v 0,0> ( semi:**y )]]
           "}else{" 
           [<h 2> "" semi:*z]
           "}"];

semi:if(*x,*y,block[**z]) ->
  [<v 0,0> [<h 1> "if" [<h 0> "(" *x ")"]]
           [<h 2> "" semi:*y]
           "else{" 
           [<h 2> "" [<v 0,0> ( semi:**z )]]
           "}"];

semi:if(*x,*y,*z) ->
  [<v 0,0> [<h 1> "if" [<h 0> "(" *x ")"]]
           [<h 2> "" semi:*y]
           "else" 
           [<h 2> "" semi:*z]
           ];

semi:while(*x,block[**y]) ->
       [<v 0,0> [<h 1> "while" [<h 0> "(" *x ")"]  "{"]
            [<h 2> ""  [<v 0,0> ( semi:**y )]] "}"];

semi:while(*x,*y) ->
       [<v 0,0> [<h 1> "while" [<h 0> "(" *x ")"] ]
            [<h 2> ""  semi:*y]];

semi:do(block[**x],*y) ->
       [<v 0,0> [<h 1> "do"  "{"]
            [<h 2> ""  [<v 0,0> (  semi:**x )]]
           [<h 1> "}" "while" [<h 0> "(" *y ");"]]] ;

semi:do(*x,*y) ->
       [<v 0,0> [<h 1> "do"  semi:*x]
           [<h 1> "while"  [<h 0> "(" *y ");"]]] ;

semi:for(*x,*y,*z,block[]) ->
  [<h 1> "for" [<h 0> "(" np:*x ";" np:*y ";" np:*z ")"] "{}"];
semi:for(*x,*y,*z,block[**t]) ->
  [<v 0,0> [<h 1> "for" [<h 0> "(" np:*x ";" np:*y ";" np:*z ")"] "{"]
           [<h 2> "" [ <v 0,0> ( semi:**t )]] "}"] ;
semi:for(*x,*y,*z,*t) ->
  [<v 0,0> [<h 1> "for" [<h 0> "(" np:*x ";" np:*y ";" np:*z ")"]]
           [<h 2> "" semi:*t]];

semi:case(*x,block[**y]) ->
       [<v 0,0> [<h 1> "case" [<h 0> *x ":"] "{"]
            [<h 2> "" [<v 0,0> ( semi:**y  )]] "}"];
semi:case(*x,*y) ->
       [<v 0,0> [<h 1> "case" [<h 0> *x ":"]]
            [<h 2> "" semi:*y ]];
semi:default(*x) ->
       [<v 0,0>  [<h 0> "default" ":"]
            [<h 2> "" semi:*x ]];

semi:switch(*x,*y) ->
       [<v 0,0> [<h 1> "switch" [<h 0> "(" *x ")"] "{"]
            semi:*y  "}"];

semi:label(*x,*y) -> [<h 1> [<h 0> *x ":"] semi:*y];

semi:*x -> [<h 0> *x ";"];

break(none()) -> "break";
break(*x) -> [<h 1> "break" *x];

continue(none()) -> "continue";
continue(*x) -> [<h 1> "continue" *x];
none() -> "";

arrayMethodDeclarator(*a) -> [<h 0> *a "[" "]"];
staticInitializer(*x) -> [<v 0,0> "static {" [<h 2> "" semi:*x] "}"];
instanceInitializer(*block) ->    [<v 0,0> "{" [<h 2> "" semi:*block] "}"];

void() -> "void";
null() -> "null";
abstract() -> "abstract";
final() -> "final";
native() -> "native";
private() -> "private";
protected() -> "protected";
public() -> "public";
static() -> "static";
synchronized() -> "synchronized";
transient() -> "transient";
volatile() -> "volatile";


end prettyprinter