cs2j/CSharpTranslator/resources/java.stg

group JavaPrettyPrintTemplates;

itsmine(now, includeDate) ::= <<
//
//
// This file was translated from C# to Java by CS2J (http://www.cs2j.com).
//
// This code is to be used for evaluation of the CS2J tool ONLY.
//
// For more information about CS2J please contact cs2jcontact@scorm.com
<if(includeDate)>
//
// Translated: <now><\n>
<endif>
//

>>

package(now, includeDate, packageName, imports, comments, modifiers, type, endComments) ::= <<
<itsmine(now=now,includeDate=includeDate)>
<if(packageName)>package <packageName>;<endif>

<comments; separator="\n">
<imports>

<type>

<endComments; separator="\n">
>>

import_template(ns) ::= "import <ns>;"

// ******* CLASSES ***********

class(modifiers, comments, attributes, name, typeparams, extends, imps, body) ::= <<
<comments; separator="\n">
<modifiers(modifiers)>class <name> <typeparams> <extends> <imps>
{
    <body>
}
>>

iface(modifiers, comments, attributes, name, imps, body) ::= <<
<comments; separator="\n">
<modifiers(modifiers)>interface <name> <imps>
{
    <body>
}
>>

class_body(entries) ::= <<
<entries; separator="\n">
>>

class_member(comments, member) ::= <<
<comments; separator="\n">
<member>
>>

constructor(modifiers, name, params, exceptions, body, bodyIsSemi) ::= <<
<modifiers(modifiers)><name>(<params; separator=", ">)<if(exceptions)> throws <exceptions; separator=", "><endif> <if(bodyIsSemi)>;
<else>
<body>
<endif>
<\n>
>>

static_constructor(modifiers, body, bodyIsSemi) ::= <<
<modifiers(modifiers)><if(bodyIsSemi)>;
<else>
<body>
<endif>
<\n>
>>

method(modifiers, typeparams, type, name, params, exceptions, body, bodyIsSemi) ::= <<
<modifiers(modifiers)><typeparams> <type> <name>(<params; separator=", ">)<if(exceptions)> throws <exceptions; separator=", "><endif> <if(bodyIsSemi)>;
<else>
<body>
<endif>
<\n>
>>

field(modifiers, type, field, comments, init) ::= "<comments><modifiers(modifiers)><type> <field>;"

variable_declarators(varinits) ::= "<varinits; separator=\", \">"
variable_declarator(typename,init) ::= "<typename><if(init)> = <init><endif>" 

primary_expression_start_parts(start,follows) ::= "<start><follows>"

type_param_constraint(param, constraints) ::= "<param> extends <constraints; separator=\" & \">"

fixed_parameter(mod,type,name,def) ::= <<
<mod> <type> <name><if(def)> = <def><endif>
>>

varargs(type,name) ::= <<
<type>... <name>
>>

identifier(id, id2) ::= "<id><if(id2)>::<id2><endif>"

statement_list(statements) ::= <<
<statements; separator="\n">
>>

statement(statement) ::= <<
<statement>
>>

annotation(modifiers, comments, attributes, name, body) ::= <<
<comments; separator="\n">
<modifiers(modifiers)>@interface <name>
{
    <body>
}
>>

//***** local var declarations:

local_variable_declaration(type,decs) ::= "<type> <decs>"
local_variable_declarator(name, init) ::= "<name><if(init)> = <init><endif>"

return(exp) ::= "return <exp>;"
throw(exp) ::= "throw <exp>;"

// ******* ENUMS ***********

enum(modifiers,comments, attributes, name, body) ::= <<
<comments; separator="\n">
<modifiers(modifiers)>enum <name>
{
    <body>
}
>>

enum_body(values) ::= "<values; separator=\",\n\">"

enum_member(comments, value) ::= <<
<comments; separator="\n">
<value>
>>

type(name, rs, stars, opt) ::= "<name><rs><stars><opt>"
namespace_or_type(type1, type2, types) ::= "<type1><if(type2)>::<type2><endif><if(types)>.<types; separator=\".\"><endif>"

modifiers(mods) ::= "<if(mods)><mods; separator=\" \"> <endif>"

type_parameter_list(items) ::= <<
\<<items; separator=", ">\>
>>

extends(types) ::= "<if(types)>extends <types; separator=\", \"><endif>"
imps(types) ::= "<if(types)>implements <types; separator=\", \"><endif>"

// ******* STATEMENTS *******
if_template(comments, cond, then, thenindent, else, elseindent, elseisif) ::= <<
<comments; separator="\n">
if (<cond>)
<block(statements = then, indent = thenindent)>
<if(else)>
else<if(elseisif)> <block(statements = else)><else>

<block(statements = else, indent = elseindent)>
<endif>
<endif> 
>>

while(comments,cond,block) ::= <<
<comments; separator="\n">
while (<cond>)
<block(statements = block)>
>>

do(comments,cond,block) ::= <<
<comments; separator="\n">
do
<block(statements = block)>
while (<cond>);
>>

for(comments,init,cond,iter,block,blockindent) ::= <<
<comments; separator="\n">
for (<init>;<cond>;<iter>)
<block(statements = block, indent=blockindent)>
>>

foreach(comments,type,loopid,fromexp,block,blockindent) ::= <<
<comments; separator="\n">
for (<type> <loopid> : <fromexp>)
<block(statements = block,indent=blockindent)>
>>

try(comments,block, blockindent, catches, fin) ::= <<
<comments; separator="\n">
try
<block(statements = block, indent=blockindent)>
<catches>
<fin>
>>

catch_template(type, id, block, blockindent) ::= <<
catch (<type> <id>)
<block(statements = block, indent = blockindent)>
>>

fin(block, blockindent) ::= <<
finally
<block(statements = block, indent = blockindent)>
>>


switch(comments,scrutinee, sections) ::= <<
<comments; separator="\n">
switch(<scrutinee>)
{
    <sections>
}
>>

switch_section(labels,statements) ::= <<
<labels; separator="\n">
    <statements; separator="\n">

>>

case(what) ::= <<
case <what>: 
>>

default_template() ::= <<
default: 
>>

lock(comments,exp,block, indent) ::= <<
<comments; separator="\n">
lock(<exp>)
<block(statements = block, indent = indent)>
>>

yield(comments,exp) ::= <<
<comments; separator="\n">
yield <if(exp)>return <exp><else>break<endif>;
>>

keyword_block(comments,keyword,block, indent) ::= <<
<comments; separator="\n">
<keyword>
<block(statements = block, indent = indent)>
>>

block(statements, indent) ::= <<
<if(indent)>
    <statements>
<else>
<statements>
<endif>
>>

braceblock(statements) ::= <<
{
    <statements; separator="\n">
}
>>

// ******* EXPRESSIONS *******

cast_expr(type, exp) ::= "(<type>)<exp>"
construct(type, args, inits) ::= "new <type>(<args>)<if(inits)> /* [UNIMPLEMENTED] <inits> */<endif>"
array_construct(type, args, inits) ::= "new <type><if(args)>[<args>]<endif><if(inits)><inits><endif>"
array_initializer(init) ::= "{ <init> }"
application(func, funcparens, args) ::= "<optparens(parens=funcparens,e=func)>(<args>)" 
index(func, funcparens, args) ::= "<optparens(parens=funcparens,e=func)>[<args>]" 
stackalloc(type, exp) ::= "stackalloc <type>[<exp>]"
typeof(type) ::= "<type>.class"

cond(condexp,condparens,thenexp,thenparens,elseexp,elseparens) ::= <<
<if(condparens)>(<endif><condexp><if(condparens)>)<endif> ? <if(thenparens)>(<endif><thenexp><if(thenparens)>)<endif> : <if(elseparens)>(<endif><elseexp><if(elseparens)>)<endif>
>>

// ******* TYPES ***********
void() ::= "void"

// ******* MISC ***********

optparens(parens, e) ::= "<if(parens)>(<endif><e><if(parens)>)<endif>"
parens(e) ::= "(<e>)"
rank_specifiers(rs) ::= "<rs>"
op(comments,pre,op,post,preparen,postparen,space) ::= <<
<comments; separator="\n">
<if(pre)><if(preparen)>(<endif><pre><if(preparen)>)<endif><space><endif><op><if(post)><space><if(postparen)>(<endif><post><if(postparen)>)<endif><endif>
>>
member_access(comments,pre,op,access,access_tyargs,preparen) ::= <<
<comments; separator="\n">
<if(preparen)>(<endif><pre><if(preparen)>)<endif><op><access_tyargs><access>
>>
assign(lhs,lhsparen,assign,rhs,rhsparen) ::= "<if(lhsparen)>(<endif><lhs><if(lhsparen)>)<endif> <assign> <if(rhsparen)>(<endif><rhs><if(rhsparen)>)<endif>"
generic_args(args) ::= "\<<args>\>"
parameter(annotation,param) ::=  "/* <annotation> */ <param>"
inline_comment(payload, explanation) ::= "/* <explanation> <payload> */"
commalist(items) ::= "<items; separator=\", \">"
dotlist(items) ::= "<items; separator=\".\">"
//list(items,sep) ::= "<items;separator=sep>"
list(items,sep) ::= <<
<items;separator=sep>
>>
seplist(items,sep) ::= <<
<items;separator=sep>
>>

unsupported(reason, text) ::= "/* [UNSUPPORTED] <reason> \"<text>\" */"


// ******* UTILITY ***********
string(payload) ::= "<payload>"

verbatim_string(payload) ::= <<
"<payload; separator="\" + \n\"">"
>>
Add template file to control Java pretty printing 2010-11-10 19:03:09 +01:00			`group JavaPrettyPrintTemplates;`

			`itsmine(now, includeDate) ::= <<`
			`//`
			`//`
			`// This file was translated from C# to Java by CS2J (http://www.cs2j.com).`
			`//`
			`// This code is to be used for evaluation of the CS2J tool ONLY.`
			`//`
			`// For more information about CS2J please contact cs2jcontact@scorm.com`
			`<if(includeDate)>`
			`//`
			`// Translated: <now><\n>`
			`<endif>`
			`//`

			`>>`

add import and modify package templates for imports 2011-01-07 16:14:17 +01:00			`package(now, includeDate, packageName, imports, comments, modifiers, type, endComments) ::= <<`
Add template file to control Java pretty printing 2010-11-10 19:03:09 +01:00			`<itsmine(now=now,includeDate=includeDate)>`
convert predefined types, optional package name, verbatim strings, 2010-12-03 20:17:40 +01:00			`<if(packageName)>package <packageName>;<endif>`
Add template file to control Java pretty printing 2010-11-10 19:03:09 +01:00
Build packages from each top level type in the file. Emit comments :) 2010-11-13 19:11:47 +01:00			`<comments; separator="\n">`
add import and modify package templates for imports 2011-01-07 16:14:17 +01:00			`<imports>`

Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`<type>`
Pass information between driver and parsers via public properties. Pass isLast flag to Pretty Print to print all remaining comments. Be sure to process file sin the same order as C# source 2010-11-15 11:47:32 +01:00
			`<endComments; separator="\n">`
Add template file to control Java pretty printing 2010-11-10 19:03:09 +01:00			`>>`
support for straightforward enums 2010-11-16 13:51:43 +01:00
add import and modify package templates for imports 2011-01-07 16:14:17 +01:00			`import_template(ns) ::= "import <ns>;"`

Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`// ***** CLASSES *********`

fix some precedence booboos 2010-12-13 16:27:06 +01:00			`class(modifiers, comments, attributes, name, typeparams, extends, imps, body) ::= <<`
Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`<comments; separator="\n">`
fix some precedence booboos 2010-12-13 16:27:06 +01:00			`<modifiers(modifiers)>class <name> <typeparams> <extends> <imps>`
Emit interfaces and structs (as class) Don't emit all comments again when multiple classes in a file 2010-11-18 14:23:17 +01:00			`{`
			`<body>`
			`}`
			`>>`

			`iface(modifiers, comments, attributes, name, imps, body) ::= <<`
			`<comments; separator="\n">`
			`<modifiers(modifiers)>interface <name> <imps>`
Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`{`
			`<body>`
			`}`
			`>>`

collect comments as we go, and emit collected comments periodically, emit (some of) field declarations 2010-11-20 15:29:39 +01:00			`class_body(entries) ::= <<`
			`<entries; separator="\n">`
			`>>`

			`class_member(comments, member) ::= <<`
			`<comments; separator="\n">`
			`<member>`
			`>>`

structs need default constructors 2010-12-21 17:11:10 +01:00			`constructor(modifiers, name, params, exceptions, body, bodyIsSemi) ::= <<`
			`<modifiers(modifiers)><name>(<params; separator=", ">)<if(exceptions)> throws <exceptions; separator=", "><endif> <if(bodyIsSemi)>;`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<else>`
			`<body>`
			`<endif>`
			`<\n>`
emit constructors 2010-12-15 12:26:21 +01:00			`>>`

option to omit timestamps, static constructors, indexers 2010-12-21 12:03:24 +01:00			`static_constructor(modifiers, body, bodyIsSemi) ::= <<`
			`<modifiers(modifiers)><if(bodyIsSemi)>;`
			`<else>`
			`<body>`
			`<endif>`
			`<\n>`
			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`method(modifiers, typeparams, type, name, params, exceptions, body, bodyIsSemi) ::= <<`
			`<modifiers(modifiers)><typeparams> <type> <name>(<params; separator=", ">)<if(exceptions)> throws <exceptions; separator=", "><endif> <if(bodyIsSemi)>;`
			`<else>`
			`<body>`
			`<endif>`
			`<\n>`
method headers, elide virtual and override keywords 2010-12-06 10:18:23 +01:00			`>>`

			`field(modifiers, type, field, comments, init) ::= "<comments><modifiers(modifiers)><type> <field>;"`

fix broken CollectComments, split verbatim strings on carriage returns 2010-12-04 13:00:16 +01:00			`variable_declarators(varinits) ::= "<varinits; separator=\", \">"`
more templates 2010-11-24 07:27:05 +01:00			`variable_declarator(typename,init) ::= "<typename><if(init)> = <init><endif>"`

			`primary_expression_start_parts(start,follows) ::= "<start><follows>"`
collect comments as we go, and emit collected comments periodically, emit (some of) field declarations 2010-11-20 15:29:39 +01:00
add type parameter constraints 2010-11-19 16:49:43 +01:00			`type_param_constraint(param, constraints) ::= "<param> extends <constraints; separator=\" & \">"`

method headers 2010-12-06 17:24:18 +01:00			`fixed_parameter(mod,type,name,def) ::= <<`
			`<mod> <type> <name><if(def)> = <def><endif>`
			`>>`

varargs support 2010-12-20 10:00:43 +01:00			`varargs(type,name) ::= <<`
			`<type>... <name>`
			`>>`

method headers, elide virtual and override keywords 2010-12-06 10:18:23 +01:00			`identifier(id, id2) ::= "<id><if(id2)>::<id2><endif>"`

emit braces for method bodies when appropriate 2010-12-06 19:56:10 +01:00			`statement_list(statements) ::= <<`
			`<statements; separator="\n">`
			`>>`

more output 2010-12-07 15:30:04 +01:00			`statement(statement) ::= <<`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`<statement>`
more output 2010-12-07 15:30:04 +01:00			`>>`

If a class inherits from System.Attribute then convert to annotation 2011-02-04 11:58:50 +01:00			`annotation(modifiers, comments, attributes, name, body) ::= <<`
			`<comments; separator="\n">`
			`<modifiers(modifiers)>@interface <name>`
			`{`
			`<body>`
			`}`
			`>>`
more output 2010-12-07 15:30:04 +01:00
			`//***** local var declarations:`

added common statement types 2010-12-10 18:16:01 +01:00			`local_variable_declaration(type,decs) ::= "<type> <decs>"`
more output 2010-12-07 15:30:04 +01:00			`local_variable_declarator(name, init) ::= "<name><if(init)> = <init><endif>"`

progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`return(exp) ::= "return <exp>;"`
			`throw(exp) ::= "throw <exp>;"`
more output 2010-12-07 15:30:04 +01:00
Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`// ***** ENUMS *********`
support for straightforward enums 2010-11-16 13:51:43 +01:00
Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`enum(modifiers,comments, attributes, name, body) ::= <<`
support for straightforward enums 2010-11-16 13:51:43 +01:00			`<comments; separator="\n">`
Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`<modifiers(modifiers)>enum <name>`
support for straightforward enums 2010-11-16 13:51:43 +01:00			`{`
			`<body>`
			`}`
			`>>`

			`enum_body(values) ::= "<values; separator=\",\n\">"`

			`enum_member(comments, value) ::= <<`
			`<comments; separator="\n">`
			`<value>`
			`>>`

collect comments as we go, and emit collected comments periodically, emit (some of) field declarations 2010-11-20 15:29:39 +01:00			`type(name, rs, stars, opt) ::= "<name><rs><stars><opt>"`
Emit interfaces and structs (as class) Don't emit all comments again when multiple classes in a file 2010-11-18 14:23:17 +01:00			`namespace_or_type(type1, type2, types) ::= "<type1><if(type2)>::<type2><endif><if(types)>.<types; separator=\".\"><endif>"`

more templates 2010-11-24 07:27:05 +01:00			`modifiers(mods) ::= "<if(mods)><mods; separator=\" \"> <endif>"`
Emit interfaces and structs (as class) Don't emit all comments again when multiple classes in a file 2010-11-18 14:23:17 +01:00
method headers 2010-12-06 17:24:18 +01:00			`type_parameter_list(items) ::= <<`
			`\<<items; separator=", ">\>`
			`>>`

prettier: add spaces between base classes 2010-12-20 22:08:38 +01:00			`extends(types) ::= "<if(types)>extends <types; separator=\", \"><endif>"`
			`imps(types) ::= "<if(types)>implements <types; separator=\", \"><endif>"`
support for straightforward enums 2010-11-16 13:51:43 +01:00
add precedence table 2010-12-08 13:47:04 +01:00			`// ***** STATEMENTS *****`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`if_template(comments, cond, then, thenindent, else, elseindent, elseisif) ::= <<`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`<comments; separator="\n">`
add precedence table 2010-12-08 13:47:04 +01:00			`if (<cond>)`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = then, indent = thenindent)>`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`<if(else)>`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`else<if(elseisif)> <block(statements = else)><else>`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = else, indent = elseindent)>`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`<endif>`
			`<endif>`
			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`while(comments,cond,block) ::= <<`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`<comments; separator="\n">`
added common statement types 2010-12-10 18:16:01 +01:00			`while (<cond>)`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block)>`
added common statement types 2010-12-10 18:16:01 +01:00			`>>`

support for do ..while 2011-03-02 19:25:41 +01:00			`do(comments,cond,block) ::= <<`
			`<comments; separator="\n">`
			`do`
			`<block(statements = block)>`
			`while (<cond>);`
			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`for(comments,init,cond,iter,block,blockindent) ::= <<`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`<comments; separator="\n">`
added common statement types 2010-12-10 18:16:01 +01:00			`for (<init>;<cond>;<iter>)`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block, indent=blockindent)>`
added common statement types 2010-12-10 18:16:01 +01:00			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`foreach(comments,type,loopid,fromexp,block,blockindent) ::= <<`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`<comments; separator="\n">`
added common statement types 2010-12-10 18:16:01 +01:00			`for (<type> <loopid> : <fromexp>)`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block,indent=blockindent)>`
added common statement types 2010-12-10 18:16:01 +01:00			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`try(comments,block, blockindent, catches, fin) ::= <<`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`<comments; separator="\n">`
added common statement types 2010-12-10 18:16:01 +01:00			`try`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block, indent=blockindent)>`
added common statement types 2010-12-10 18:16:01 +01:00			`<catches>`
			`<fin>`
			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`catch_template(type, id, block, blockindent) ::= <<`
added common statement types 2010-12-10 18:16:01 +01:00			`catch (<type> <id>)`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block, indent = blockindent)>`
added common statement types 2010-12-10 18:16:01 +01:00			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`fin(block, blockindent) ::= <<`
added common statement types 2010-12-10 18:16:01 +01:00			`finally`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block, indent = blockindent)>`
added common statement types 2010-12-10 18:16:01 +01:00			`>>`


Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`switch(comments,scrutinee, sections) ::= <<`
			`<comments; separator="\n">`
added common statement types 2010-12-10 18:16:01 +01:00			`switch(<scrutinee>)`
more outputting 2010-12-10 20:36:47 +01:00			`{`
added common statement types 2010-12-10 18:16:01 +01:00			`<sections>`
more outputting 2010-12-10 20:36:47 +01:00			`}`
added common statement types 2010-12-10 18:16:01 +01:00			`>>`

			`switch_section(labels,statements) ::= <<`
fix parens on ops and prettified multiple case labels 2010-12-11 12:59:42 +01:00			`<labels; separator="\n">`
added common statement types 2010-12-10 18:16:01 +01:00			`<statements; separator="\n">`

			`>>`

			`case(what) ::= <<`
			`case <what>:`
			`>>`

			`default_template() ::= <<`
			`default:`
			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`lock(comments,exp,block, indent) ::= <<`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`<comments; separator="\n">`
added common statement types 2010-12-10 18:16:01 +01:00			`lock(<exp>)`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block, indent = indent)>`
added common statement types 2010-12-10 18:16:01 +01:00			`>>`

pass yield statements through as [unsupported] comments 2011-03-16 14:48:56 +01:00			`yield(comments,exp) ::= <<`
			`<comments; separator="\n">`
			`yield <if(exp)>return <exp><else>break<endif>;`
			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`keyword_block(comments,keyword,block, indent) ::= <<`
unsupported: checed/unchecked/default 2010-12-20 10:58:48 +01:00			`<comments; separator="\n">`
			`<keyword>`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<block(statements = block, indent = indent)>`
unsupported: checed/unchecked/default 2010-12-20 10:58:48 +01:00			`>>`

implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`block(statements, indent) ::= <<`
			`<if(indent)>`
			`<statements>`
add precedence table 2010-12-08 13:47:04 +01:00			`<else>`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`<statements>`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`<endif>`
implement using statements and fix indentation 2010-12-20 22:05:25 +01:00			`>>`

			`braceblock(statements) ::= <<`
			`{`
			`<statements; separator="\n">`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`}`
add precedence table 2010-12-08 13:47:04 +01:00			`>>`

no need for SEP now that types are wrapped 2010-11-24 11:29:30 +01:00			`// ***** EXPRESSIONS *****`

			`cast_expr(type, exp) ::= "(<type>)<exp>"`
more output 2010-12-07 15:30:04 +01:00			`construct(type, args, inits) ::= "new <type>(<args>)<if(inits)> /* [UNIMPLEMENTED] <inits> */<endif>"`
translate new T[] {e,e,e} don't emit 'new' modifier, comment 'extern' 2010-12-17 13:48:09 +01:00			`array_construct(type, args, inits) ::= "new <type><if(args)>[<args>]<endif><if(inits)><inits><endif>"`
			`array_initializer(init) ::= "{ <init> }"`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`application(func, funcparens, args) ::= "<optparens(parens=funcparens,e=func)>(<args>)"`
added common statement types 2010-12-10 18:16:01 +01:00			`index(func, funcparens, args) ::= "<optparens(parens=funcparens,e=func)>[<args>]"`
more output 2010-12-07 15:30:04 +01:00			`stackalloc(type, exp) ::= "stackalloc <type>[<exp>]"`
added common statement types 2010-12-10 18:16:01 +01:00			`typeof(type) ::= "<type>.class"`
no need for SEP now that types are wrapped 2010-11-24 11:29:30 +01:00
more outputting 2010-12-10 20:36:47 +01:00			`cond(condexp,condparens,thenexp,thenparens,elseexp,elseparens) ::= <<`
			`<if(condparens)>(<endif><condexp><if(condparens)>)<endif> ? <if(thenparens)>(<endif><thenexp><if(thenparens)>)<endif> : <if(elseparens)>(<endif><elseexp><if(elseparens)>)<endif>`
			`>>`

progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`// ***** TYPES *********`
			`void() ::= "void"`

method headers 2010-12-06 17:24:18 +01:00			`// ***** MISC *********`

progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`optparens(parens, e) ::= "<if(parens)>(<endif><e><if(parens)>)<endif>"`
method headers 2010-12-06 17:24:18 +01:00			`parens(e) ::= "(<e>)"`
			`rank_specifiers(rs) ::= "<rs>"`
fix parens on ops and prettified multiple case labels 2010-12-11 12:59:42 +01:00			`op(comments,pre,op,post,preparen,postparen,space) ::= <<`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`<comments; separator="\n">`
fix parens on ops and prettified multiple case labels 2010-12-11 12:59:42 +01:00			`<if(pre)><if(preparen)>(<endif><pre><if(preparen)>)<endif><space><endif><op><if(post)><space><if(postparen)>(<endif><post><if(postparen)>)<endif><endif>`
Shovel out comments in more places 2010-12-10 18:57:37 +01:00			`>>`
fix generic method calls and add unsupported to explicit interface implementations 2010-12-19 16:13:15 +01:00			`member_access(comments,pre,op,access,access_tyargs,preparen) ::= <<`
			`<comments; separator="\n">`
			`<if(preparen)>(<endif><pre><if(preparen)>)<endif><op><access_tyargs><access>`
			`>>`
progress on outputting expressions and if then else 2010-12-09 17:30:11 +01:00			`assign(lhs,lhsparen,assign,rhs,rhsparen) ::= "<if(lhsparen)>(<endif><lhs><if(lhsparen)>)<endif> <assign> <if(rhsparen)>(<endif><rhs><if(rhsparen)>)<endif>"`
method headers 2010-12-06 17:24:18 +01:00			`generic_args(args) ::= "\<<args>\>"`
			`parameter(annotation,param) ::= "/* <annotation> */ <param>"`
			`inline_comment(payload, explanation) ::= "/* <explanation> <payload> */"`
			`commalist(items) ::= "<items; separator=\", \">"`
			`dotlist(items) ::= "<items; separator=\".\">"`
fix for multiple catch clauses, weird: is list() special in ST? 2010-12-11 11:19:53 +01:00			`//list(items,sep) ::= "<items;separator=sep>"`
			`list(items,sep) ::= <<`
			`<items;separator=sep>`
			`>>`
			`seplist(items,sep) ::= <<`
			`<items;separator=sep>`
			`>>`
more output 2010-12-07 15:30:04 +01:00
			`unsupported(reason, text) ::= "/* [UNSUPPORTED] <reason> \"<text>\" */"`

method headers 2010-12-06 17:24:18 +01:00
Start of support for classes - Simplified pretty printer code by passing modifier template into definitions. 2010-11-16 17:29:08 +01:00			`// ***** UTILITY *********`
fix broken CollectComments, split verbatim strings on carriage returns 2010-12-04 13:00:16 +01:00			`string(payload) ::= "<payload>"`

			`verbatim_string(payload) ::= <<`
			`"<payload; separator="\" + \n\"">"`
method headers, elide virtual and override keywords 2010-12-06 10:18:23 +01:00			`>>`