// $Id$
// vim: set et ts=2 sw=2 :

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

$import "java.lang.Integer";
$import "org.objectweb.asm.ClassWriter";
$import "org.objectweb.asm.FieldVisitor";
$import "org.objectweb.asm.Label";
$import "org.objectweb.asm.MethodVisitor";
$import "org.objectweb.asm.Opcodes";

$box Module_Name;
$box Refal_Module_Name;
$box Class_Name;

$box Entry;
$box Entry_Name;

$box Func_Name;

$func Module_To_JBC s.cw e.module = ;

$func ASAIL_To_JBC e.body = ;

$func Expr_Ref_To_JBC e.ASAIL_Expr_Ref = ;

$func Expr_Int_To_JBC e.ASAIL_Expr_Int = ;

$func Step_To_JBC e.step_operators = ;

$func Const_Expr_To_JBC e.ASAIL_const_expr = ;

$func Var_To_JBC t.var = ;

$func Cond_To_JBC t.cond = s.if;

$func Infix_To_JBC s.func_for_converting_args_to_java s.op e.args = ;

$func Access_Mode s.linkage = s.jbc_access_mode;

$box Objects;
$box Constants;
$box Func_Refs;

$func GetJavaName e.name = e.javaName;

GetJavaName e.name = <Concat <MapIn &ToWord (<MapIn &Rfp2Java (<Paren e.name>)>)>>;

$func GetJBCName t.name = s.jbcName;

GetJBCName t.name = <ToWord <GetJavaName t.name>>;

$func GetJBCQName e.moduleName t.name = s.jbcModuleName s.jbcName;

GetJBCQName e.moduleName t.name = {
    e.moduleName : "refal" "plus" s.module = "org" "refal" "plus" "library" s.module;
    e.moduleName;
  } :: e.moduleName,
  <GetJavaName e.moduleName t.name> : e.javaModuleName s.javaName,
  <ToWord <Intersperse ('/') e.javaModuleName>> s.javaName;

$box MVbox;

$func MV = s;

MV, <Get &MVbox> : s.mv = s.mv;

RFP_ASAIL_To_JBC (MODULE (e.moduleName) e.module) =
  <Store &Objects>,
  <Store &Constants>,
  <Store &Func_Refs>,
  {
    <Store &Entry <Lookup &RFP_Options ENTRIES>>;
    <Store &Entry (e.moduleName Main)>;
  },
  <Store &Entry_Name /*empty*/>,
  <Store &Module_Name e.moduleName>,
  <ToWord <Intersperse ('.') e.moduleName>> :: s.refal_mod_name,
  <Store &Refal_Module_Name s.refal_mod_name>,
  <GetJavaName e.moduleName> :: e.java_module_name,
  <ToWord <Intersperse ('/') e.java_module_name>> :: s.class_name,
  <Store &Class_Name s.class_name>,
  <ClassWriter &COMPUTE_MAXS> :: s.cw,
  <CWvisit s.cw &V1_4 &ACC_PUBLIC s.class_name <Null> "java/lang/Object" ()>,
  <Module_To_JBC s.cw e.module>,
  { 
    <Get &Entry_Name> : s.name =
      /*<ASAIL-To-JBC-Temp s.cw e.module> : e,
      ()
          ('public static void main (java.lang.String[] args) {' (
            ('RefalRuntime.setArgs ("'e.java-module-name'", args);')
      ('try {' (v.name' (new Result ());') '}')
            ('catch (RefalException e) {' (
              ('java.lang.System.out.println ("$error: " + e);')
              ('java.lang.System.exit (100);')
            )'}')
          )'}');;
      } :: e.entry,*/
      <Store &MVbox <CWvisitMethod s.cw <Add &ACC_PUBLIC &ACC_STATIC> "main" "([Ljava/lang/String;)V" <Null> ()>>,
      <MVvisitLdcInsn <MV> <WordToString s.refal_mod_name>>,
      <MVvisitVarInsn <MV> &ALOAD 0>,
      <MVvisitMethodInsn <MV> &INVOKESTATIC "org/refal/plus/RefalRuntime" "setArgs" "(Ljava/lang/String;[Ljava/lang/String;)V">,
      <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Result">,
      <MVvisitInsn <MV> &DUP>,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Result" "<init>" "()V">,
      <MVvisitMethodInsn <MV> &INVOKESTATIC s.class_name s.name "(Lorg/refal/plus/Result;)V">,
      <MVvisitInsn <MV> &RETURN>,
      <MVvisitMaxs <MV> 0 0>,
      <MVvisitEnd <MV>>;;
  },
  <Store &MVbox <CWvisitMethod s.cw &ACC_STATIC "<clinit>" "()V" <Null> ()>>,
  {
    <Get &Objects> : e (s.j_name s.rf_name e.cl_name) e,
      <ToWord "org/refal/plus/library/" e.cl_name> :: s.cl_name,
      <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
      <MVvisitInsn <MV> &DUP>,
      <MVvisitTypeInsn <MV> &NEW s.cl_name>,
      <MVvisitInsn <MV> &DUP>,
      <MVvisitLdcInsn <MV> <WordToString s.rf_name>>,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL s.cl_name "<init>" "(Ljava/lang/String;)V">,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Ljava/lang/Object;)V">,
      <MVvisitFieldInsn <MV> &PUTSTATIC s.class_name s.j_name "Lorg/refal/plus/Expr;">,
      $fail;;
  },
  {
    <Get &Constants> : e (s.const_name e.expr) e,
      <Const_Expr_To_JBC e.expr>,
      <MVvisitFieldInsn <MV> &PUTSTATIC s.class_name s.const_name "Lorg/refal/plus/Expr;">,
      $fail;;
  },
  <MVvisitInsn <MV> &RETURN>,
  <MVvisitMaxs <MV> 0 0>,
  <MVvisitEnd <MV>>,
  //{
  //  <? &Func-Refs> : e (s.cl-name s.mod-name s.func-name) e,
  //    <CWvisitInnerClass s.cw s.cl-name <Null> <Null> &"ACC_STATIC">,
  //    $fail;;
  //},
  <CWvisitEnd s.cw>,
  <Box (<CWtoByteArray s.cw> e.java_module_name)> :: s.res,
  {
    <Get &Func_Refs> : e (s.cl_name s.mod_name s.func_name s.type) e,
      <ClassWriter &COMPUTE_MAXS> :: s.cw,
      <CWvisit s.cw &V1_4 &ACC_FINAL <ToWord s.class_name '$' s.cl_name> <Null> "java/lang/Object" ("org/refal/plus/Func")>,
      <CWvisitMethod s.cw 0 "<init>" "()V" <Null> ()> :: s.mv,
      <MVvisitVarInsn s.mv &ALOAD 0>,
      <MVvisitMethodInsn s.mv &INVOKESPECIAL "java/lang/Object" "<init>" "()V">,
      <MVvisitInsn s.mv &RETURN>,
      <MVvisitMaxs s.mv 0 0>,
      <MVvisitEnd s.mv>,
      <CWvisitMethod s.cw &ACC_PUBLIC "eval" "(Lorg/refal/plus/Expr;Lorg/refal/plus/Result;)Z" <Null> ("org/refal/plus/RefalException")> :: s.mv,
      <MVvisitVarInsn s.mv &ALOAD 1>,
      <MVvisitVarInsn s.mv &ALOAD 2>,
      s.type : {
        "FUNC?" =
          <MVvisitMethodInsn s.mv &INVOKESTATIC s.mod_name s.func_name "(Lorg/refal/plus/Expr;Lorg/refal/plus/Result;)Z">,
          <MVvisitInsn s.mv &IRETURN>;
        FUNC  =
          <MVvisitMethodInsn s.mv &INVOKESTATIC s.mod_name s.func_name "(Lorg/refal/plus/Expr;Lorg/refal/plus/Result;)V">,
          <MVvisitInsn s.mv &ICONST_1> <MVvisitInsn s.mv &IRETURN>;
      },
      <MVvisitMaxs s.mv 0 0>,
      <MVvisitEnd s.mv>,
      <CWvisitEnd s.cw>,
      <Put s.res (<CWtoByteArray s.cw>
        <Middle 0 1 e.java_module_name> <ToWord <R 0 e.java_module_name> '$' s.cl_name>)>,
      $fail;;
  },
  <Get s.res>;

$box Block_Tables;

$func Init_Block_Table = ;
$func Push_Block_Table = ;
$func Pop_Block_Table = ;
$func Get_Block_Table = s.block_table;

Init_Block_Table =
  <Table> :: s.block_table,
  <Bind s.block_table ("VAR-INDEX") (0)>,
  <Store &Block_Tables s.block_table>;

Push_Block_Table =
  <Get &Block_Tables> : e.block_tables,
  e.block_tables : e s.block_table,
  <Store &Block_Tables e.block_tables <TableCopy s.block_table>>;

Pop_Block_Table = 
  <Get &Block_Tables> : e.block_tables s.block_table1 s.block_table2,
  <Lookup s.block_table2 "VAR-INDEX"> : s.i,
  <Bind s.block_table1 ("VAR-INDEX") (s.i)>,
  <Store &Block_Tables e.block_tables s.block_table1>;

Get_Block_Table =
  <Get &Block_Tables> : e s.block_table,
  s.block_table;

$func Bind_Vars s.type e.vars = ;
$func Bind_Var s.type t.var = s.i;
$func Lookup_Var t.var = s.type s.i;
$func Bind_Iter_Var e.expr t.var1 t.var2 = s.i;
$func Lookup_Iter_Var e.expr = s.i s.i1 s.i2;
$func Bind_TMP_Var t.var = s.i;
$func Lookup_TMP_Var t.var = s.i;

Bind_Vars s.type e.vars =
  {
    e.vars : e t.var e,
      <Bind_Var s.type t.var> : e,
      $fail;;
  };

Bind_Var s.type t.var =
  <Lookup <Get_Block_Table> "VAR-INDEX"> : s.i,
  <Bind <Get_Block_Table> ("VAR-INDEX") (<Add s.i 1>)>,
  <Bind <Get_Block_Table> (VAR t.var) (s.type s.i)>,
  s.i;

Lookup_Var t.var = <Lookup <Get_Block_Table> VAR t.var> : s.type s.i = s.type s.i;

Bind_Iter_Var e.expr t.var1 t.var2 = 
  <Lookup <Get_Block_Table> "VAR-INDEX"> : s.i,
  <Bind <Get_Block_Table> ("VAR-INDEX") (<Add s.i 1>)>,
  <Bind_Var Expr t.var1> :: s.i1,
  <Bind_Var Expr t.var2> :: s.i2,
  <Bind <Get_Block_Table> (ITER e.expr) (s.i s.i1 s.i2)>,
  s.i;

Lookup_Iter_Var e.expr = <Lookup <Get_Block_Table> ITER e.expr> : s.i s.i1 s.i2 = s.i s.i1 s.i2;

Bind_TMP_Var t.var = 
  <Lookup <Get_Block_Table> "VAR-INDEX"> : s.i,
  <Bind <Get_Block_Table> ("VAR-INDEX") (<Add s.i 1>)>,
  <Bind <Get_Block_Table> (TMP t.var) (s.i)>,
  s.i;

Lookup_TMP_Var t.var = <Lookup <Get_Block_Table> TMP t.var> : s.i = s.i;

$func Bind_Label t.label = s.l;
$func Lookup_Label t.label = s.l;

Bind_Label t.label =
  <Label> :: s.l,
  <Bind <Get_Block_Table> (LABEL t.label) (s.l)>,
  s.l;

Lookup_Label t.label = <Lookup <Get_Block_Table> LABEL t.label> : s.l = s.l;


$box Traps;

$func Push_Trap s.end s.handler = ;
$func Get_Trap = s.handler;
$func Pop_Trap = s.end;

Push_Trap s.end s.handler =
  <Put &Traps s.end s.handler>;

Get_Trap = <R 0 <Get &Traps>> : s.handler = s.handler;

Pop_Trap =
  <Get &Traps> : e.traps s.end s,
  <Store &Traps e.traps>,
  s.end;



$func Function_Description (e.args) (e.ress) s.retType = s.desc;

Function_Description (e.args) (e.ress) s.retType = 
  <ToWord '(' <Replicate <Length e.args> "Lorg/refal/plus/Expr;">
    <Replicate <Length e.ress> "Lorg/refal/plus/Result;">')' s.retType>;

Module_To_JBC s.cw e.module, {
  e.module : e t.item e, t.item : {
    (s.tag IMPORT e) = /*empty*/;
    (s.tag s.linkage t.name (e.args) (e.ress) e.body),
      s.tag : \{
        FUNC  = 'V';
        "FUNC?" = 'Z';
      } : s.retType =
      <Init_Block_Table>,
      <Bind_Vars Expr e.args>,
      <Bind_Vars Result e.ress>,
      <Add &ACC_STATIC <Access_Mode s.linkage>> :: s.accessMode,
      t.name : (e s.funcName),
      <Store &Func_Name s.funcName>,
      <GetJBCName s.funcName> :: s.funcName,
      { <Get &Entry> : e t.name e = <Store &Entry_Name s.funcName>;; },
      <Function_Description (e.args) (e.ress) s.retType> :: s.desc,
      <Store &MVbox <CWvisitMethod s.cw s.accessMode s.funcName s.desc <Null> ("org/refal/plus/RefalException")>>,
      <ASAIL_To_JBC e.body>,
      s.tag : {
        FUNC  = <MVvisitInsn <MV> &RETURN>;
        "FUNC?" = <MVvisitInsn <MV> &ICONST_1> <MVvisitInsn <MV> &IRETURN>;
      },
      <MVvisitMaxs <MV> 0 0>,
      <MVvisitEnd <MV>>;
    (CONSTEXPR s.linkage t.name (e.comment) e.expr) = 
      t.name : {
        (STATIC (e)) = t.name;
        (e s.const_name) = s.const_name;
      } :: t.name,
      <GetJBCName t.name> :: s.name,
      <Add &ACC_STATIC <Add &ACC_FINAL <Access_Mode s.linkage>>> :: s.accessMode,
      <CWvisitField s.cw s.accessMode s.name "Lorg/refal/plus/Expr;" <Null> <Null>> :: s.fv,
      <FVvisitEnd s.fv>,
      <Put &Constants (s.name e.expr)>;
    (OBJ s.linkage s.tag t.name) =
      t.name : (e s.obj_name),
      <ToChars s.tag> : s1 e2,
      'Named' s1 <ToLower e2> :: e.class_name,
      <GetJBCName s.obj_name> :: s.n,
      <Add &ACC_STATIC <Add &ACC_FINAL <Access_Mode s.linkage>>> :: s.accessMode,
      <CWvisitField s.cw s.accessMode s.n "Lorg/refal/plus/Expr;" <Null> <Null>> :: s.fv,
      <FVvisitEnd s.fv>,
      <Put &Objects (s.n s.obj_name e.class_name)>;
    ("DECL-OBJ" t.name) = ;
    ("DECL-FUNC" t.name) = ;
    (TRACE t.name) =
      <Bind &RFP_Trace (t.name) ()>;
  },
    $fail;;
};

ASAIL_To_JBC {
  e t.item e, /*<WriteLN> <WriteLN t.item>*/ t.item : {
    (DECL (INT t.var)) =
      <Bind_Var Int t.var> :: s;
    (DECL s.type t.var) =
      <Bind_Var s.type t.var> :: s.i,
      s.type : {
        Result =
          <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Result">,
          <MVvisitInsn <MV> &DUP>,
          <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Result" "<init>" "()V">,
          <MVvisitVarInsn <MV> &ASTORE s.i>;
        Expr =
          <MVvisitFieldInsn <MV> &GETSTATIC "org/refal/plus/Expr" "empty" "Lorg/refal/plus/Expr;">,
          <MVvisitVarInsn <MV> &ASTORE s.i>;
      };
    (ASSIGN (INT t.var) e.expr) =
      <Lookup_Var t.var> :: s s.i,
      <Expr_Int_To_JBC e.expr>,
      <MVvisitVarInsn <MV> &ISTORE s.i>;
    (ASSIGN t.var e.expr) =
      <Lookup_Var t.var> :: s.type s.i,
      s.type : {
        Result =
          <MVvisitVarInsn <MV> &ALOAD s.i>,
          <Expr_Ref_To_JBC e.expr>,
          <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Result" "assign" "(Lorg/refal/plus/Expr;)V">;
        Expr = 
          <Expr_Ref_To_JBC e.expr>,
          <MVvisitVarInsn <MV> &ASTORE s.i>;
      };
    ("IF-INT-CMP" s.op (e.arg1) (e.arg2) e.body) =
      <Push_Block_Table>,
      <Label> :: s.label,
      <Expr_Int_To_JBC e.arg1>,
      <Expr_Int_To_JBC e.arg2>,
      s.op : {
        "!=" = &IF_ICMPEQ;
        "<" = &IF_ICMPGE;
        ">" = &IF_ICMPLE;
      } :: s.op,
      <MVvisitJumpInsn <MV> s.op s.label>,
      <ASAIL_To_JBC e.body>,
      <MVvisitLabel <MV> s.label>,
      <Pop_Block_Table>;
    (IF t.cond e.body) =
      <Push_Block_Table>,
      <Label> :: s.label,
      <Cond_To_JBC t.cond> :: s.if,
      <MVvisitJumpInsn <MV> s.if s.label>,
      <ASAIL_To_JBC e.body>,
      <MVvisitLabel <MV> s.label>,
      <Pop_Block_Table>;
    (LSPLIT t.name (e.min) t.var1 t.var2) =
      <Push_Block_Table>,
      <Bind_Iter_Var t.name t.var1 t.var2> :: s.i,
      <Expr_Ref_To_JBC t.name>,
      <Expr_Int_To_JBC e.min>,
      <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr" "leftSplit" "(I)Lorg/refal/plus/Expr$SplitIterator;">,
      <MVvisitVarInsn <MV> &ASTORE s.i>;
    (RSPLIT t.name (e.min) t.var1 t.var2) =
      <Push_Block_Table>,
      <Bind_Iter_Var t.name t.var1 t.var2> :: s.i,
      <Expr_Ref_To_JBC t.name>,
      <Expr_Int_To_JBC e.min>,
      <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr" "rightSplit" "(I)Lorg/refal/plus/Expr$SplitIterator;">,
      <MVvisitVarInsn <MV> &ASTORE s.i>;
    (FOR (e.cont_label) (e.break_label) () (e.step) e.body) =
      { e.step : /*empty*/, <Push_Block_Table>;; },
      {
        e.cont_label : t.label = <Bind_Label t.label>;
        <Label>;
      } :: s.cont_label,
      {
        e.break_label : t.label = <Bind_Label t.label>;
        <Label>;
      } :: s.break_label,
      <Label> :: s.for_label,
      <MVvisitLabel <MV> s.for_label>,
      {
        e.step : (s.tag e.expr), s.tag : \{ "INC-ITER"; "DEC-ITER"; } =
          <Lookup_Iter_Var e.expr> : s.i s.i1 s.i2,
          <MVvisitVarInsn <MV> &ALOAD s.i>,
          <MVvisitInsn <MV> &DUP>,
          <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr$SplitIterator" "getLeft" "()Lorg/refal/plus/Expr;">,
          <MVvisitVarInsn <MV> &ASTORE s.i1>,
          <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr$SplitIterator" "getRight" "()Lorg/refal/plus/Expr;">,
          <MVvisitVarInsn <MV> &ASTORE s.i2>;;
      },
      <ASAIL_To_JBC e.body>,
      <MVvisitLabel <MV> s.cont_label>,
      <Step_To_JBC e.step>,
      <MVvisitJumpInsn <MV> &GOTO s.for_label>,
      <MVvisitLabel <MV> s.break_label>,
      <Pop_Block_Table>;
    (LABEL (t.label) e.body) =
      <Push_Block_Table>,
      <Bind_Label t.label> :: s.l,
      <ASAIL_To_JBC e.body>,
      <MVvisitLabel <MV> s.l>,
      <Pop_Block_Table>;
    (s.tag t.label), s.tag : \{ CONTINUE; BREAK; } =
      <MVvisitJumpInsn <MV> &GOTO <Lookup_Label t.label>>;
    RETFAIL =
      <MVvisitInsn <MV> &ICONST_0> <MVvisitInsn <MV> &IRETURN>;
    (TRY e.body) =
      <Push_Block_Table>,
      <Label> :: s.start,
      <Label> :: s.end,
      <Label> :: s.real_end,
      <Label> :: s.handler,
      <Push_Trap s.real_end s.handler>,
      <MVvisitTryCatchBlock <MV> s.start s.end s.handler "org/refal/plus/RefalException">,
      <MVvisitLabel <MV> s.start>,
      <ASAIL_To_JBC e.body>,
      <MVvisitLabel <MV> s.end>,
      <MVvisitJumpInsn <MV> &GOTO s.real_end>,
      <Pop_Block_Table>;
    ("CATCH-ERROR" e.body) =
      <Push_Block_Table>,
      <Get_Trap> :: s.label,
      <MVvisitLabel <MV> s.label>,
      <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/RefalException" "getExpr" "()Lorg/refal/plus/Expr;">,
      <MVvisitVarInsn <MV> &ASTORE <Bind_Var Expr s.label>>,
      <ASAIL_To_JBC e.body>,
      <MVvisitLabel <MV> <Pop_Trap>>,
      <Pop_Block_Table>;
    FATAL =
      <MVvisitTypeInsn <MV> &NEW "org/refal/plus/RefalException">,
      <MVvisitInsn <MV> &DUP>,
      <Get &Refal_Module_Name> : s.mod_name,
      <MVvisitLdcInsn <MV> <WordToString s.mod_name>>,
      <Get &Func_Name> : s.fname,
      <MVvisitLdcInsn <MV> <WordToString s.fname>>,
      <MVvisitLdcInsn <MV> <WordToString "Unexpected fail">>,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/RefalException" "<init>" "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V">,
      <MVvisitInsn <MV> &ATHROW>;
    (ERROR e.expr) =
      <MVvisitTypeInsn <MV> &NEW "org/refal/plus/RefalException">,
      <MVvisitInsn <MV> &DUP>,
      <Expr_Ref_To_JBC e.expr>,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/RefalException" "<init>" "(Lorg/refal/plus/Expr;)V">,
      <MVvisitInsn <MV> &ATHROW>;
    (s.call (e.module s.name) (e.args) (e.ress)),
      s.call : \{ CALL = V; TAILCALL = V; "TAILCALL?" = Z; } :: s.retType =
      <Function_Description (e.args) (e.ress) s.retType> :: s.desc,
      {
        e.args : e (e.arg) e, 
          <Expr_Ref_To_JBC e.arg>,
          $fail;;
      },
      {
        e.ress : e t.var e, <Lookup_Var t.var> : 
          {
            Expr s =
              <Bind_TMP_Var t.var> :: s.j,
              <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Result">,
              <MVvisitInsn <MV> &DUP>,
              <MVvisitInsn <MV> &DUP>,
              <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Result" "<init>" "()V">,
              <MVvisitVarInsn <MV> &ASTORE s.j>;
            Result s.i =
              <MVvisitVarInsn <MV> &ALOAD s.i>;
          }, $fail;;
      },
      <MVvisitMethodInsn <MV> &INVOKESTATIC <GetJBCQName e.module s.name> s.desc>,
      {
        s.call : "TAILCALL?" =
          <Label> :: s.label,
          <MVvisitJumpInsn <MV> &IFNE s.label>,
          <MVvisitInsn <MV> &ICONST_0>,
          <MVvisitInsn <MV> &IRETURN>,
          <MVvisitLabel <MV> s.label>;;
      },
      {
        e.ress : e t.var e, <Lookup_Var t.var> : Expr s.i,
          <Lookup_TMP_Var t.var> :: s.j,
          <MVvisitVarInsn <MV> &ALOAD s.j>
          <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Result" "getExpr" "()Lorg/refal/plus/Expr;">,
          <MVvisitVarInsn <MV> &ASTORE s.i>,
          $fail;;
      };
  }, $fail; e;
};


$func Term_Ref_To_JBC t.term = ;

Expr_Ref_To_JBC {
  /*empty*/ = <MVvisitFieldInsn <MV> &GETSTATIC "org/refal/plus/Expr" "empty" "Lorg/refal/plus/Expr;">;
  t.term = <Term_Ref_To_JBC t.term>;
  t.term1 t.term2 =
    <Term_Ref_To_JBC t.term1>,
    <Term_Ref_To_JBC t.term2>,
    <MVvisitMethodInsn <MV> &INVOKESTATIC "org/refal/plus/Expr" "concat" "(Lorg/refal/plus/Expr;Lorg/refal/plus/Expr;)Lorg/refal/plus/Expr;">;
  e.expr =
    <MVvisitLdcInsn <MV> <Integer <Length e.expr>>>,
    <MVvisitTypeInsn <MV> &ANEWARRAY "org/refal/plus/Expr">,
    0 e.expr $iter {
      e.expr : t.term e.rest,
        <MVvisitInsn <MV> &DUP>,
        <MVvisitLdcInsn <MV> <Integer s.i>>,
        <Term_Ref_To_JBC t.term>,
        <MVvisitInsn <MV> &AASTORE>,
        <Add s.i 1> e.rest;
    } :: s.i e.expr,
    e.expr : /*empty*/ =
    <MVvisitMethodInsn <MV> &INVOKESTATIC "org/refal/plus/Expr" "concat" "([Lorg/refal/plus/Expr;)Lorg/refal/plus/Expr;">;
};

Term_Ref_To_JBC {
  (PAREN e.expr) =
    <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
    <MVvisitInsn <MV> &DUP>,
    <Expr_Ref_To_JBC e.expr>,
    <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Ljava/lang/Object;)V">;
  (DEREF e.expr (e.pos)) =
    <Expr_Ref_To_JBC e.expr>,
    <Expr_Int_To_JBC e.pos>,
    <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr" "at" "(I)Ljava/lang/Object;">,
    <MVvisitTypeInsn <MV> &CHECKCAST "org/refal/plus/Expr">;
  (SUBEXPR e.expr (e.pos) (e.len)) =
    <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
    <MVvisitInsn <MV> &DUP>,
    <Expr_Ref_To_JBC e.expr>,
    <Expr_Int_To_JBC e.pos>,
    <Expr_Int_To_JBC e.len>,
    <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Lorg/refal/plus/Expr;II)V">;
  t.term, t.term : \{
    (REF (e.module s.name)) = e.module s.name;
    (STATIC (e)) = <Get &Module_Name> t.term;
  } :: e.module t.name =
    <MVvisitFieldInsn <MV> &GETSTATIC <GetJBCQName e.module t.name> "Lorg/refal/plus/Expr;">;
  "ERROR-EXPR" = <Var_To_JBC <Get_Trap>>;
  t.term, t.term : (s.var_tag e),
    s.var_tag : \{ VAR; SVAR; TVAR; EVAR; VVAR; } =
    <Var_To_JBC t.term>;
};

Expr_Int_To_JBC {
  s.ObjectSymbol = 
    {
      <IsInt s.ObjectSymbol> =
        <MVvisitLdcInsn <MV> <Integer s.ObjectSymbol>>;
      $error ("Illegal int-symbol: " s.ObjectSymbol);
        //FIXME: надо проверять, что число не
        //       выходит за допустимые границы.
        //       Задавать эти границы опциями.
    };
  (LENGTH e.x) =
    <Expr_Ref_To_JBC e.x>,
    <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr" "getLen" "()I">;
  (s.tag (e.x) (e.y)),
    s.tag : \{ MIN = "min"; MAX = "max"; } :: s.fn =
    <Expr_Int_To_JBC e.x>,
    <Expr_Int_To_JBC e.y>,
    <MVvisitMethodInsn <MV> &INVOKESTATIC "java/lang/Math" s.fn "(II)I">;
  (INFIX s.op e.args) =
    <Infix_To_JBC &Expr_Int_To_JBC s.op e.args>;
  (INT t.var) = <Var_To_JBC t.var>;
  e.expr = <Infix_To_JBC &Expr_Int_To_JBC "+" <Paren e.expr>>;
};

Infix_To_JBC s.arg2java s.op (e.arg) e.args =
  s.op : \{
    "+" = &IADD;
    "-" = &ISUB;
    "%" = &IREM;
    "*" = &IMUL;
    "/" = &IDIV;
  } :: s.jbcop,
  <Apply s.arg2java e.arg> : e,
  {
    e.args : e (e.arg2) e,
      <Apply s.arg2java e.arg2> : e,
      <MVvisitInsn <MV> s.jbcop>,
      $fail;;
  };

Cond_To_JBC {
  ("CALL-FAILS" (CALL (e.module s.name) (e.args) (e.ress))) = 
    <Function_Description (e.args) (e.ress) "Z"> :: s.desc,
    {
      e.args : e (e.arg) e, 
        <Expr_Ref_To_JBC e.arg>,
        $fail;;
    },
    {
      e.ress : e t.var e, <Lookup_Var t.var> : 
        {
          Expr s =
            <Bind_TMP_Var t.var> :: s.j,
            <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Result">,
            <MVvisitInsn <MV> &DUP>,
            <MVvisitInsn <MV> &DUP>,
            <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Result" "<init>" "()V">,
            <MVvisitVarInsn <MV> &ASTORE s.j>;
          Result s.i =
            <MVvisitVarInsn <MV> &ALOAD s.i>;
        }, $fail;;
    },
    <MVvisitMethodInsn <MV> &INVOKESTATIC <GetJBCQName e.module s.name> s.desc>,
    {
      e.ress : e t.var e, <Lookup_Var t.var> : Expr s.i,
        <Lookup_TMP_Var t.var> :: s.j,
        <MVvisitVarInsn <MV> &ALOAD s.j>
        <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Result" "getExpr" "()Lorg/refal/plus/Expr;">,
        <MVvisitVarInsn <MV> &ASTORE s.i>,
        $fail;;
    },
    &IFNE;
  ("ITER-FAILS" e.expr) =
    <Lookup_Iter_Var e.expr> :: s.i s s,
    <MVvisitVarInsn <MV> &ALOAD s.i>,
    <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr$SplitIterator" "isValid" "()Z">,
    &IFNE;
  ("SYMBOL?" e.expr (e.pos)) =
    <Expr_Ref_To_JBC e.expr>,
    <Expr_Int_To_JBC e.pos>,
    <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr" "symbolAt" "(I)Z">,
    &IFEQ;
  (EQ e.expr1 (e.expr2) (e.pos)) =
    <Expr_Ref_To_JBC e.expr1>,
    <Expr_Ref_To_JBC e.expr2>,
    <Expr_Int_To_JBC e.pos>,
    <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr" "eq" "(Lorg/refal/plus/Expr;I)Z">,
    &IFEQ;
  ("TERM-EQ" e.expr1 (e.expr2) (e.pos)) =
    <Expr_Ref_To_JBC e.expr1>,
    <Expr_Ref_To_JBC e.expr2>,
    <Expr_Int_To_JBC e.pos>,
    <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr" "termEq" "(Lorg/refal/plus/Expr;I)Z">,
    &IFEQ;
  (NOT t.cond) =
    <Cond_To_JBC t.cond> : {
      &IFEQ = &IFNE;
      &IFNE = &IFEQ;
    };
}; 


Step_To_JBC {
  /*empty*/ = /*empty*/;
  (s.tag e.expr),
    s.tag : {
      "INC-ITER" = "next";
      "DEC-ITER" = "prev";
    } :: s.m = 
    <Lookup_Iter_Var e.expr> :: s.i s s,
    <MVvisitVarInsn <MV> &ALOAD s.i>,
    <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Expr$SplitIterator" s.m "()Lorg/refal/plus/Expr$SplitIterator;">,
    <MVvisitInsn <MV> &POP>;
};

$func Const_Term_To_JBC t.term = ;
$func Get_String_From_Const_Expr e.expr = (e.chars) e.expr;
$func Convert_Const_Expr e.expr = e.expr;

Const_Expr_To_JBC {
  /*empty*/ = <MVvisitFieldInsn <MV> &GETSTATIC "org/refal/plus/Expr" "empty" "Lorg/refal/plus/Expr;">;
  (SUBEXPR t.name s.pos s.len) =
    t.name : \{
      (REF (e.module s.obj_name)) = e.module s.obj_name;
      (STATIC (e)) = <Get &Module_Name> t.name;
    } :: e.module t.name =
    <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
    <MVvisitInsn <MV> &DUP>,
    <MVvisitFieldInsn <MV> &GETSTATIC <GetJBCQName e.module t.name> "Lorg/refal/plus/Expr;">,
    <MVvisitLdcInsn <MV> <Integer s.pos>>,
    <MVvisitLdcInsn <MV> <Integer s.len>>,
    <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Lorg/refal/plus/Expr;II)V">;
                  //FIXME: надо проверять, что s.pos и s.len
                  //       не превышают допустимых величин.
                  //       Задавать эти величины опциями.

  e.expr = <Convert_Const_Expr e.expr> :: e.expr,
    <MVvisitLdcInsn <MV> <Integer <Length e.expr>>>,
    <MVvisitTypeInsn <MV> &ANEWARRAY "org/refal/plus/Expr">,
    0 e.expr $iter {
      e.expr : t.term e.rest,
        <MVvisitInsn <MV> &DUP>,
        <MVvisitLdcInsn <MV> <Integer s.i>>,
        <Const_Term_To_JBC t.term>,
        <MVvisitInsn <MV> &AASTORE>,
        <Add s.i 1> e.rest;
    } :: s.i e.expr,
    e.expr : /*empry*/ =
    <MVvisitMethodInsn <MV> &INVOKESTATIC "org/refal/plus/Expr" "concat" "([Lorg/refal/plus/Expr;)Lorg/refal/plus/Expr;">;




  /*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_' :: e.new-var,
        e.arrays 
        ('static private final Expr[] 'e.new-var' = { '<Concat <Intersperse (', ') e.concat>>' };')
        ('Expr.concat ('e.new-var')');
    };*/
};

Get_String_From_Const_Expr e.expr,
  () e.expr F $iter {
    e.expr : s.sym e.rest, <IsChar s.sym> = (e.chars s.sym) e.rest F;
    (e.chars) e.expr T;
  } :: (e.chars) e.expr s.flag, s.flag : T, 
  (e.chars) e.expr;

Convert_Const_Expr e.expr,
  () e.expr $iter {
    <Get_String_From_Const_Expr e.expr> :: (e.chars) e.expr,
      {
        e.chars : v = (e.res (CHARS e.chars)) e.expr;
        e.expr : t.term e.rest, (e.res t.term) e.rest;
      };
  } :: (e.res) e.expr, e.expr : /*empry*/,
  e.res;

Const_Term_To_JBC {
  (CHARS e.chars) = 
    <MVvisitLdcInsn <MV> <WordToString <ToWord e.chars>>>,
    <MVvisitMethodInsn <MV> &INVOKESTATIC "org/refal/plus/Expr" "fromSequence" "(Ljava/lang/CharSequence;)Lorg/refal/plus/Expr;">;
  (PAREN e.expr) =
    <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
    <MVvisitInsn <MV> &DUP>,
    <Const_Expr_To_JBC e.expr>,
    <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Ljava/lang/Object;)V">;
  t.term, t.term : \{
    (REF (e.module s.name)) = e.module s.name;
    (STATIC (e)) = <Get &Module_Name> t.term;
  } :: e.module t.name =
    <MVvisitFieldInsn <MV> &GETSTATIC <GetJBCQName e.module t.name> "Lorg/refal/plus/Expr;">;
  (s.func (e.module s.name)), s.func : \{ FUNC; "FUNC?"; } =
    <ToWord <Get &Class_Name> '$' <Length <Get &Func_Refs>>> :: s.cl_name,
    <Put &Func_Refs (<Length <Get &Func_Refs>> <GetJBCQName e.module s.name> s.func)>,
    <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
    <MVvisitInsn <MV> &DUP>,
    <MVvisitTypeInsn <MV> &NEW s.cl_name>,
    <MVvisitInsn <MV> &DUP>,
    <MVvisitMethodInsn <MV> &INVOKESPECIAL s.cl_name "<init>" "()V">,
    <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Ljava/lang/Object;)V">;
  s.sym, {
    <IsInt s.sym> = 
      <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
      <MVvisitInsn <MV> &DUP>,
      <MVvisitTypeInsn <MV> &NEW "java/math/BigInteger">,
      <MVvisitInsn <MV> &DUP>,
      <MVvisitLdcInsn <MV> <WordToString <ToWord s.sym>>>,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "java/math/BigInteger" "<init>" "(Ljava/lang/String;)V">,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Ljava/lang/Object;)V">;
    <IsWord s.sym> =
      <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Expr">,
      <MVvisitInsn <MV> &DUP>,
      <MVvisitTypeInsn <MV> &NEW "org/refal/plus/Word">,
      <MVvisitInsn <MV> &DUP>,
      <MVvisitLdcInsn <MV> <WordToString s.sym>>,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Word" "<init>" "(Ljava/lang/String;)V">,
      <MVvisitMethodInsn <MV> &INVOKESPECIAL "org/refal/plus/Expr" "<init>" "(Ljava/lang/Object;)V">;
  };
};

Var_To_JBC t.var =
  <Lookup_Var t.var> :: s.type s.i,
  s.type : {
    Result =
      <MVvisitVarInsn <MV> &ALOAD s.i>,
      <MVvisitMethodInsn <MV> &INVOKEVIRTUAL "org/refal/plus/Result" "getExpr" "()Lorg/refal/plus/Expr;">;
    Expr =
      <MVvisitVarInsn <MV> &ALOAD s.i>;
    Int =
      <MVvisitVarInsn <MV> &ILOAD s.i>;
  };

Access_Mode {
  EXPORT = &ACC_PUBLIC;
  s = 0;
};