source: to-imperative/trunk/compiler/rfp_asail_java.rf @ 2043

// $Id: rfp_asail_java.rf 2043 2006-08-01 17:25:13Z orlov $

$use Access Apply Arithm Box Class Compare Convert JavaMangle List StdIO Table;
$use "rfpc";
$use "rfp_helper";

$box Int;

$box Exports;

$table Inputs;

$box Module-Name;

$box Entry;

$box Entry-Name;

$box Current-Namespace;

$box Func-Name;

$box Ress;
$table Result;
$box Res-Assigns;

$table Iter-Vars;

$func ASAIL-To-Java e.body = e.java-code;

$func Expr-To-Java (e.ASAIL-Expr-init ) e.ASAIL-Expr-rest = e.aux-arrays (e.java-expr);

$func Expr-Ref-To-Java e.ASAIL-Expr-Ref = e.aux-arrays (e.JAVA-Expr-Ref);

$func Expr-Int-To-Java s.acc e.ASAIL-Expr-Int = e.JAVA-Expr-Int;

$func Step-To-Java e.step-operators = e.java-step-operators;

$func Const-Expr-To-Java e.ASAIL-const-expr = e.aux-arrays (e.JAVA-const-expr);

$func Expr-Args-To-Java e.args = e.aux-arrays (e.java-args);

$func Int-Args-To-Java s.acc e.args = e.java-args;

$func Var-Args-To-Java e.args = e.java-args;

$func Symbol-To-Java s.RFP-Symbol = e.JAVA-String;

$func Name-To-Java t.name = e.JAVA-Name;

$func Var-To-Java t.var = e.java-var;

$func Cond-To-Java s.acc e.cond = e.JAVA-Cond;

$func Infix-To-Java s.acc s.func-for-converting-args-to-java s.op e.args = e.java-expr;

$func Op-Arg-To-Java s.op = s.func-for-converting-args-to-java;

$func Access-Mode t.name = e.java-access-mode;

$box Free-Idx;

$func Free-Index = e.free-index;

$func Declare-Results (e.ress) e.acc-java-ress = e.decls (e.java-ress);

RFP-ASAIL-To-Java (e.ModuleName) (e.exports) e.asail =
  <Store &Free-Idx>,
  <RFP-Clear-Table &Iter-Vars>,
  <RFP-Clear-Table &Inputs>,
  {
    <Store &Int <Lookup &RFP-Options INT>>;
    <Store &Int BigInteger>;
  },
  <Store &Exports e.exports>,
  <Store &Current-Namespace e.ModuleName>,
  <Store &Entry (e.ModuleName Main)>,
  <Store &Entry-Name /*empty*/>,
  <Store &Module-Name <Intersperse ('.') e.ModuleName>>,
  <Rfp2Java e.ModuleName> :: e.java-module-name,
  {
    <ASAIL-To-Java e.asail> : v.java,
      { 
        <? &Entry-Name> : v.name =
          ()
          ('public static void main (java.lang.String[] args) {'
            (('RefalRuntime.setArgs ("'e.java-module-name'", args);')
             ('try {' (v.name' (new Result ());') '}')
             ('catch (RefalException e) {' ('System.out.println ("$error: " + e);') '}')
            )
          '}');;
      } :: e.entry,
      (e.java-module-name)
      (<Domain &Inputs>)
      ('public class 'e.java-module-name'\n{'
        (v.java e.entry)
       '}');
    (e.java-module-name) ();
  };

ASAIL-To-Java e.asail, {
  e.asail : t.item e.rest, t.item : {
    (s.tag t.name (e.args) (e.ress) e.body),
      s.tag : \{
        FUNC  = ('void') /*empty*/;
        FUNC? = ('boolean') ('return true;');
      } :: (e.return-type) e.return =
      <Store &Ress e.ress>,
      <RFP-Clear-Table &Result>,
      { <? &Entry> : t.name = <Store &Entry-Name <Rfp2Java t.name>>;; },
//      <RFP-Extract-Qualifiers t.name> :: (e.qualifiers) e.n,
      <Store &Func-Name <Name-To-Java t.name>>,
      ()
      ('static '<Access-Mode t.name>' 'e.return-type' '
        <? &Func-Name>' ('<Var-Args-To-Java Expr e.args Result e.ress>') throws RefalException')
        ('{' (<ASAIL-To-Java e.body> e.return) '}');
    (TRACE t.name) =
      <Bind &RFP-Trace (t.name) ()>;
    (IF (e.cond) e.body) =
      <Box> :: s.acc,
      <Cond-To-Java s.acc e.cond> :: e.j-cond,
      {
        e.cond : (NOT (CALL e)) =
          () (<? &Res-Assigns> <Store &Res-Assigns /*empty*/>);
        (<? &Res-Assigns> <Store &Res-Assigns /*empty*/>) ();
      } :: (e.if-yes-assigns) (e.if-not-assigns),
      <? s.acc>
      ('if ('e.j-cond')')
      ('{' (
        e.if-yes-assigns
        <ASAIL-To-Java e.body>
      )'}' )
      e.if-not-assigns;
    (FOR (e.cont-label) (e.break-label) (e.cond) (e.step) e.body) =
      {
        e.cont-label : t = <Rfp2Java (LABEL e.cont-label)> ': ';;
      } :: e.cont,
      {
        e.break-label : t = <Rfp2Java (LABEL e.break-label)> ': ';;
      } :: e.break,
      <Box> :: s.acc,
      <Cond-To-Java s.acc e.cond> :: e.cond,
      {
        e.step : (s.d e.var), s.d : \{ INC-ITER; DEC-ITER; } =
          <Lookup &Iter-Vars e.var> : e.new-var t.var1 t.var2,
          ('Expr '<Rfp2Java t.var1>' = 'e.new-var'.getLeft();')
          ('Expr '<Rfp2Java t.var2>' = 'e.new-var'.getRight();');;
      } :: e.split-vars,
      <? s.acc>
      (e.break e.cont 'for ( ; 'e.cond'; '<Step-To-Java e.step>')')
      ('{' (
        e.split-vars <? &Res-Assigns> <Store &Res-Assigns /*empty*/>
        <ASAIL-To-Java e.body>
      ) '}'); 
    (LABEL (e.label) e.body) =
      (<Rfp2Java (LABEL e.label)>': {' (<ASAIL-To-Java e.body>) '}');
    (TRY e.body) =
      ('try') ('{' (
        ('if (false)'
          ('throw new RefalException ("'<? &Module-Name>'", "'<? &Func-Name>'", '
            '"This is for avoiding \'Unreachable code\' errors");'
        )   )
        <ASAIL-To-Java e.body>
      ) '}');
    (CATCH-ERROR e.body) =
      ('catch (RefalException error) {' (
        ('Expr err = error.getExpr ();')
        (<ASAIL-To-Java e.body>)
      ) '}');
    RETFAIL = ('return false;');
    FATAL =
      ('throw new RefalException ("'<? &Module-Name>'", "'<? &Func-Name>'", "Unexpected fail");');
    (LSPLIT t.name (e.min) t.var1 t.var2) =
      <Expr-Ref-To-Java t.name> :: e.a (e.n),
      '_va_' <Free-Index> :: e.new-var,
      <Bind &Iter-Vars (t.name) (e.new-var t.var1 t.var2)>,
      <Box> :: s.acc,
      <Expr-Int-To-Java s.acc e.min> :: e.min,
      e.a <? s.acc>
      ('Expr.SplitIterator 'e.new-var' = 'e.n'.leftSplit('e.min');');
    (RSPLIT t.name (e.min) t.var1 t.var2) =
      <Expr-Ref-To-Java t.name> :: e.a (e.n),
      '_va_' <Free-Index> :: e.new-var,
      <Bind &Iter-Vars (t.name) (e.new-var t.var1 t.var2)>,
      <Box> :: s.acc,
      <Expr-Int-To-Java s.acc e.min> :: e.min,
      e.a <? s.acc>
      ('Expr.SplitIterator 'e.new-var' = 'e.n'.rightSplit('e.min');');
    (ASSIGN t.var e.expr) =
      <Expr-To-Java () e.expr> :: e.a (e.j-expr),
      {
        <? &Ress> : e t.var e =
          e.a (<Rfp2Java t.var>'.assign ('e.j-expr');');
        e.a (<Lookup &Result t.var>'.assign ('e.j-expr');');
        e.a (<Rfp2Java t.var>' = 'e.j-expr';');
      };
    (DECL s.type t.var) =
      <Rfp2Java t.var> :: e.j-var,
      {
        s.type : Result =
          <Bind &Result (t.var) (e.j-var)>,
          ('Result 'e.j-var' = new Result ();');
        <Unbind &Result t.var>,
          ('Expr 'e.j-var' = Expr.empty;');
      };
    (INT t.var e.expr) =
      <Box> :: s.acc,
      <Expr-Int-To-Java s.acc e.expr> :: e.expr,
      <? s.acc> ('int '<Rfp2Java t.var>' = 'e.expr';');
    (EXPR t.var e.expr) =
      <Unbind &Result t.var>,
      <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
      e.a ('Expr '<Rfp2Java t.var>' = 'e.j-expr';');
    (DEREF t.var e.expr (e.pos)) =
      <Unbind &Result t.var>,
      <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
      <Box> :: s.acc,
      <Expr-Int-To-Java s.acc e.pos> :: e.pos,
      e.a <? s.acc> ('Expr '<Rfp2Java t.var>' = (Expr) 'e.j-expr'.at ('e.pos');');
    (SUBEXPR t.var e.expr (e.pos) (e.len)) =
      <Unbind &Result t.var>,
      <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
      <Box> :: s.acc,
      <Expr-Int-To-Java s.acc e.pos> :: e.pos,
      <Expr-Int-To-Java s.acc e.len> :: e.len,
      e.a <? s.acc> ('Expr '<Rfp2Java t.var>' = new Expr ('e.j-expr', 'e.pos', 'e.len');');
    (DROP t.var) =
      (<Var-To-Java t.var>'.drop ();');
    (CONTINUE t.label) =
      ('continue '<Rfp2Java (LABEL t.label)>';');
    (BREAK t.label) =
      ('break '<Rfp2Java (LABEL t.label)>';');
    (ERROR e.expr) =
      <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
      e.a ('throw new RefalException ('e.j-expr');');
    (CONSTEXPR s.linkage t.name (e.comment) e.expr) =
      {
        t.name : (STATIC e) = <Rfp2Java t.name>;
        //<RFP-Extract-Qualifiers t.name> :: (e.qualifiers) e.name = e.name;
        <Name-To-Java t.name>;
      } :: e.n,
      <Const-Expr-To-Java e.expr> :: e.a (e.j-expr),
      e.a ('static '<Access-Mode t.name>' final Expr 'e.n' = 'e.j-expr';');
    (OBJ s.linkage s.tag t.name) =
      <To-Chars s.tag> : s1 e2,
      'Named' s1 <To-Lower e2> :: e.class-name,
      <Bind &Inputs ('org.refal.plus.library.'e.class-name) ()>,
      <RFP-Extract-Qualifiers t.name> :: (e.qualifiers) e.n,
      ('static '<Access-Mode t.name>' final Expr '<Name-To-Java t.name>
        ' = new Expr (new 'e.class-name' ("'e.n'"));');
    (DECL-OBJ t.name) = ;
    (DECL-FUNC t.name) = ;
    /*
     * s.call can be CALL or TAILCALL or TAILCALL?
     */
    (s.call t.name (e.args) (e.ress)) =
      <Declare-Results (e.ress)> :: e.decls (e.ress),
      <Expr-Args-To-Java e.args Result e.ress> :: e.arrays (e.args),
      <Name-To-Java t.name>' ('e.args')' :: e.c,
      {
        s.call : TAILCALL? =
          e.arrays e.decls ('if (!'e.c') {' ('return false;') '}');
        e.arrays e.decls (e.c';') <? &Res-Assigns>
          <Store &Res-Assigns /*empty*/>;
      };
  } :: e.java-item,
    {
      e.java-item : ('break ' e) = e.java-item;
      e.java-item <ASAIL-To-Java e.rest>;
    };
  /*empty*/;
};

Declare-Results {
  (t.var e.r) e.ress, {
    <In-Table? &Result t.var> = <Declare-Results (e.r) e.ress (<Rfp2Java t.var>)>;
    <? &Ress> : e t.var e     = <Declare-Results (e.r) e.ress (<Rfp2Java t.var>)>;
    '_va_' <Free-Index> :: e.new-var,
      <Put &Res-Assigns (<Rfp2Java t.var>' = 'e.new-var'.getExpr ();')> =
      ('Result 'e.new-var' = new Result ();') <Declare-Results (e.r) e.ress (e.new-var)>;
  };
  () e.ress = (e.ress);
};

/*
 * Determine type of e.expr - int or Refal.
 */
Expr-To-Java (e.init) e.expr-all, e.expr-all : {
  /*empty*/ = <Expr-Ref-To-Java e.init>;
  (PAREN e.expr) e.rest = <Expr-Ref-To-Java e.init e.expr-all>;
  (EXPR e.expr) e.rest = <Expr-Ref-To-Java e.init e.expr-all>;
  (DEREF e.expr) e.rest = <Expr-Ref-To-Java e.init e.expr-all>;
  (SUBEXPR e.expr) e.rest = <Expr-Ref-To-Java e.init e.expr-all>;
  (LENGTH e.expr) e.rest = (<Expr-Int-To-Java XXX e.init e.expr-all>);
  (MAX e.args) e.rest = (<Expr-Int-To-Java XXX e.init e.expr-all>);
  (MIN e.args) e.rest = (<Expr-Int-To-Java XXX e.init e.expr-all>);
  (INFIX s.op e.args) e.rest = (<Expr-Int-To-Java XXX e.init e.expr-all>);
  (s.var-tag (e.QualifiedName)) e.rest =
    <Expr-To-Java (e.init (s.var-tag (e.QualifiedName))) e.rest>;
};

$func Term-Ref-To-Java s.acc term = e.term;

Expr-Ref-To-Java {
  /*empty*/ = ('Expr.empty');
  term =
    <Box> :: s.acc,
    <Term-Ref-To-Java s.acc term> :: e.term,
    <? s.acc> (e.term);
  t1 t2 =
    <Box> :: s.acc,
    <Term-Ref-To-Java s.acc t1> :: e.t1,
    <Term-Ref-To-Java s.acc t2> :: e.t2,
    <? s.acc> ('new Expr ('e.t1', 'e.t2')');
  expr =
    '_va_'<Free-Index> :: e.new-var,
    <Box> :: s.acc,
    <Infix-To-Java s.acc &Term-Ref-To-Java "," <Paren expr>> :: e.arr-init,
    <? s.acc>
    ('Expr[] 'e.new-var' = { 'e.arr-init' };')
    ('Expr.concat ('e.new-var')');
};

Term-Ref-To-Java s.acc term = term : {
  (PAREN e.expr) =
    <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
    <Put s.acc e.a>,
    'new Expr('e.j-expr')';
  (DEREF e.expr (e.pos)) =
    <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
    <Put s.acc e.a>,
    <Expr-Int-To-Java s.acc e.pos> :: e.pos,
    '(Expr) 'e.j-expr'.at ('e.pos')';
  (SUBEXPR e.expr (e.pos) (e.len)) =
    <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
    <Put s.acc e.a>,
    <Expr-Int-To-Java s.acc e.pos> :: e.pos,
    <Expr-Int-To-Java s.acc e.len> :: e.len,
    'new Expr ('e.j-expr', 'e.pos', 'e.len')';
  (REF t.name) = <Name-To-Java t.name>;
  ERROR-EXPR = 'err';
  (s.var-tag e.ns t.name) = <Var-To-Java term>;
};

Expr-Int-To-Java s.acc expr = expr : {
//  /*empty*/ = /*empty*/;
  s.ObjectSymbol = 
    {
      <Int? s.ObjectSymbol> = s.ObjectSymbol;
      $error ("Illegal int-symbol: " s.ObjectSymbol);
        //FIXME: надо проверять, что число не
        //       выходит за допустимые границы.
        //       Задавать эти границы опциями.
    };
  (LENGTH e.expr) =
    <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
    <Put s.acc e.a>,
    e.j-expr'.getLen ()';
  (MAX e.args) =
    'java.lang.Math.max ('<Int-Args-To-Java s.acc e.args>')';
  (MIN e.args) =
    'java.lang.Math.min ('<Int-Args-To-Java s.acc e.args>')';
  (INFIX s.op e.args) =
    '(' <Infix-To-Java s.acc &Expr-Int-To-Java s.op e.args> ')';
//  (REF t.name) = <Name-To-Java t.name>;
  (s.var-tag t.name) = <Rfp2Java (s.var-tag t.name)>;
  expr = '(' <Infix-To-Java s.acc &Expr-Int-To-Java "+" <Paren expr>> ')';
};

Cond-To-Java s.acc expr = expr : {
  /*empty*/ = /*empty*/;
  (CALL t.name (e.args) (e.ress)) =
    <Declare-Results (e.ress)> :: e.decls (e.ress),
    <Expr-Args-To-Java e.args Result e.ress> :: e.arrays (e.args),
    <Put s.acc e.arrays e.decls>,
    <Name-To-Java t.name>' ('e.args')';
  (SYMBOL? e.expr (e.pos)) =
    <Expr-Ref-To-Java e.expr> :: e.a (e.j-expr),
    <Put s.acc e.a>,
    e.j-expr'.symbolAt ('<Expr-Int-To-Java s.acc e.pos>')';
  (CHECK-ITER e.expr) =
    <Middle 0 2 <Lookup &Iter-Vars e.expr>>'.isValid ()';
  (EQ e.expr1 (e.expr2) (e.pos)) =
    <Expr-Ref-To-Java e.expr1> :: e.a1 (e.j-expr1),
    <Expr-Ref-To-Java e.expr2> :: e.a2 (e.j-expr2),
    <Put s.acc e.a1 e.a2>,
    e.j-expr1'.eq ('e.j-expr2', '<Expr-Int-To-Java s.acc e.pos>')'; 
  (TERM-EQ e.expr1 (e.expr2) (e.pos)) =
    <Expr-Ref-To-Java e.expr1> :: e.a1 (e.j-expr1),
    <Expr-Ref-To-Java e.expr2> :: e.a2 (e.j-expr2),
    <Put s.acc e.a1 e.a2>,
    e.j-expr1'.eq ('e.j-expr2', '<Expr-Int-To-Java s.acc e.pos> ')'; 
  (NOT e.cond) =
    '!' <Cond-To-Java s.acc e.cond>;
  (INFIX s.op e.args) =
    {
      s.op : \{ "+"; "-"; "%"; "*"; "/"; } =
        <Infix-To-Java s.acc &Expr-Int-To-Java s.op e.args>' != 0';
      '(' <Infix-To-Java s.acc <Op-Arg-To-Java s.op> s.op e.args> ')';
    };
  expr = '(' <Infix-To-Java s.acc &Cond-To-Java "&&" <Paren expr>> ')';
}; 

Infix-To-Java s.acc s.arg2java s.op e.args, {
  e.args : (e.arg) e.rest =
    <Apply s.arg2java s.acc e.arg> :: e.arg,
    <Infix-To-Java s.acc s.arg2java s.op e.rest> :: e.rest,
    { 
      e.arg : v, e.rest : v = e.arg ' ' s.op ' ' e.rest;
      e.arg e.rest;
    };;
};

Op-Arg-To-Java s.op, {
  s.op : \{ "&&"; "||"; } =
    &Cond-To-Java;
  s.op : \{ "<"; ">"; "<="; ">="; "=="; "!="; "+"; "-"; "%"; "*"; "/"; } =
    &Expr-Int-To-Java;
};
 
Step-To-Java {
  /*empty*/ = /*empty*/;
  (INC-ITER e.expr) = <Middle 0 2 <Lookup &Iter-Vars e.expr>>'.next ()';
  (DEC-ITER e.expr) = <Middle 0 2 <Lookup &Iter-Vars e.expr>>'.prev ()';
};

$func Const-Expr-Aux (e.accum) e.expr = (e.arrays) e.java-expr;

Const-Expr-To-Java {
  /*empty*/ = ('Expr.empty');
  (SUBEXPR t.name s.pos s.len) = ('new Expr ('<Rfp2Java t.name>', 's.pos', 's.len')');
                  //FIXME: надо проверять, что s.pos и s.len
                  //       не превышают допустимых величин.
                  //       Задавать эти величины опциями.
  e.expr =
    <Const-Expr-Aux () e.expr> : {
      (e.arrays) (e1)      = e.arrays (e1);
      (e.arrays) (e1) (e2) = e.arrays ('new Expr ('e1', 'e2')');
      (e.arrays) e.concat  =
        '_va_'<Free-Index> :: e.new-var,
        e.arrays 
        ('static private final Expr[] 'e.new-var' = { '<Concat <Intersperse (', ') e.concat>>' };')
        ('Expr.concat ('e.new-var')');
    };
};

Const-Expr-Aux (e.accum) e.expr, {
  e.expr : s.sym e.rest, <Char? s.sym> =
    <Const-Expr-Aux (e.accum <Symbol-To-Java s.sym>) e.rest>;
  e.accum : v =
    <Const-Expr-Aux () e.expr> :: (e.arrays) e.j-expr,
    (e.arrays) ('Expr.fromSequence ("'e.accum'")') e.j-expr;
  e.expr : t.item e.rest, t.item : {
    (PAREN e.paren-expr) =
      <Const-Expr-To-Java e.paren-expr> :: e.arrays (e.j-expr),
      (e.arrays) ('new Expr ('e.j-expr')');
    (REF t.name) =
      () (<Name-To-Java t.name>);
    (STATIC e) =
      () (<Rfp2Java t.item>);
    (FUNC? t.name) = () ('new Expr (new Func () {'
      ('public boolean eval (Expr arg, Result res) throws RefalException {'
        ('return '<Name-To-Java t.name>' (arg, res);')
      '}') '})');
    (FUNC t.name) = () ('new Expr (new Func () {'
      ('public boolean eval (Expr arg, Result res) throws RefalException {'
        ((<Name-To-Java t.name>' (arg, res);')
         ('return true;'))
      '}') '})');
    s.sym, {
      <Int? s.sym> = 
        {
          <? &Int> : BigInteger =
            <Bind &Inputs ('java.math.BigInteger') ()>;;
        },
        () ('new Expr (new '<? &Int>' ("'s.sym'"))');
      <Word? s.sym> =
        () ('new Expr (new Word ("'<Symbol-To-Java s.sym>'"))');
    };
  } :: (e.arrays) e.java-item =
    <Const-Expr-Aux () e.rest> :: (e.new-arrays) e.java-rest,
    (e.arrays e.new-arrays) e.java-item e.java-rest;
  = () /*empty*/;
};

Symbol-To-Java s.ObjectSymbol, {
  <To-Chars s.ObjectSymbol> () $iter {
    e.symbol : s.char e.rest, s.char : {
      '\\' = '\\\\';
      '\n' = '\\n';
      '\t' = '\\t';
//        '\v' = '\\v';
//        '\b' = '\\b';
      '\r' = '\\r';
//        '\f' = '\\f';
      '\"' = '\\"';
//      '\'' = '\\\'';
      s = s.char;
    } :: e.java-char,
    e.rest (e.java-symbol e.java-char);
  } :: e.symbol (e.java-symbol),
    e.symbol : /*empty*/ =
    e.java-symbol;
};

Int-Args-To-Java s.acc e.args =
  e.args (/*e.java-args*/) $iter {
    e.args : (e.arg) e.rest =
      {
        e.rest : v = ', ';
        /*empty*/;
      } :: e.comma,
      e.rest (e.java-args <Expr-Int-To-Java s.acc e.arg> e.comma);
    } :: e.args (e.java-args),
  e.args : /*empty*/ =
  e.java-args;

Var-Args-To-Java e.args =
  e.args (/*e.type*/) (/*e.java-args*/) $iter {
    e.args : s.t e.rest =
      e.rest (s.t) (e.java-args);
    e.args : t.arg e.rest =
      {
        e.rest : e (e) e = ', ';
        /*empty*/;
      } :: e.comma,
      e.rest (e.type) (e.java-args e.type' '<Rfp2Java t.arg> e.comma);
    } :: e.args (e.type) (e.java-args),
  e.args : /*empty*/ =
  e.java-args;

Expr-Args-To-Java e.args =
  e.args (/*e.type*/) (/*e.java-args*/) (/*e.arrays*/) $iter {
    e.args : s.t e.rest =
      e.rest (s.t) (e.java-args) (e.arrays);
    e.args : (e.arg) e.rest =
      {
        e.rest : e (e) e = ', ';
        /*empty*/;
      } :: e.comma,
      {
        e.type : /*empty*/ =
          <Expr-Ref-To-Java e.arg> :: e.a (e.j-arg),
          e.rest (e.type) (e.java-args e.j-arg e.comma) (e.arrays e.a);
        e.rest (e.type) (e.java-args e.arg e.comma) (e.arrays);
      };
  } :: e.args (e.type) (e.java-args) (e.arrays),
  e.args : /*empty*/ =
  e.arrays (e.java-args);

Name-To-Java t.obj-name =
  <RFP-Extract-Qualifiers t.obj-name> :: (e.qualifiers) e.name,
  <? &Current-Namespace> :: e.namespace,
  {
    e.qualifiers : e.namespace e.cont = <Rfp2Java e.cont e.name>;
    <Bind &Inputs (e.qualifiers) ()>,
      <Rfp2Java (e.qualifiers e.name)>;
  };

Var-To-Java t.var = {
  <Lookup &Result t.var>'.getExpr ()';
  <Rfp2Java t.var>;
};

Access-Mode t.name, {
  <? &Exports> : e t.name e = 'public';
  'private';
};

Free-Index =
  <? &Free-Idx> : {
    /*empty*/ = 1;
    s.idx     = <"+" s.idx 1>;
  } :: s.idx,
  <Store &Free-Idx s.idx>,
  s.idx;