$use Access Apply Arithm Box Class Compare Convert CppMangle List StdIO Table;

$use "org.refal.plus.compiler.rfpc";
$use "org.refal.plus.compiler.rfp_helper";
$use "org.refal.plus.compiler.rfp_vars";

$box Int;

$box Module_Name;

$box Current_Namespace;

$box Current_Func;

$box Current_Trace;

$box Entry;

$box Entry_Name;

$box Const_Exprs;

$table Externs;

$table Unavailable_Imports;
$table Used_Unavailable_Imports;

$table Decls;
$table Locals;

$table Used_Consts;

$func ASAIL_To_CPP e.body = e.cpp_code;

$func Open_Namespace e.name = e;
$func Close_Namespace e.name = e;

$func Namespace_Control e.qualifiers = e.namespace_control;

$func Expr_Ref_To_CPP s.tvars_box e.ASAIL_Expr_Ref = e.CPP_Expr_Ref;

$func Term_Ref_To_CPP s.tvars e = e;

$func Expr_Int_To_CPP e.ASAIL_Expr_Int = e.CPP_Expr_Int;

$func Step_To_CPP e.step_operators = e.cpp_step_operators;

$func Const_Expr_To_CPP e.ASAIL_const_expr = e.CPP_const_expr;

$func Args_To_CPP (e.prefix) s.Arg_Res_Tag e.ASAIL_Args = e.CPP_Args;

$func Symbol_To_CPP s.RFP_Symbol = e.CPP_String;

$func QName_To_Cpp e.name = e.cpp_name;

$func Name_To_CPP s.decl_type t.name e.args = e.CPP_Name;

$func Cond_To_CPP t.cond = e.CPP_Cond;

$func Infix_To_CPP (e.box) s.func_for_converting_args_to_cpp s.op e.args = e.cpp_expr;

$func Trace_Enter e.name (e.args) = e.trace;
$func Trace_Exit  e.name (e.ress) = e.trace;
$func Trace_Fail  e.name          = e.trace;

$func Extract_Qualifiers t.name = (e.qualifiers) e.name;


RFP_ASAIL_To_TPP (MODULE (e.ModuleName) e.asail) =
  {
    <Store &Int <Lookup &RFP_Options INT>>;
    <Store &Int "rftype::Integer">;
  },
  <Store &Module_Name e.ModuleName>,
  <Store &Current_Namespace /*empty*/>,
  {
    <Store &Entry <Lookup &RFP_Options ENTRIES>>;
    <Store &Entry (e.ModuleName Main)>;
  },
  <Store &Entry_Name /*empty*/>,
  <Store &Const_Exprs /*empty*/>,
  <ClearTable &Externs>,
  <ClearTable &Unavailable_Imports>,
  <ClearTable &Used_Unavailable_Imports>,
  <ClearTable &Decls>,
  <ClearTable &Locals>,
  <ClearTable &Used_Consts>,
  {
    <ASAIL_To_CPP e.asail> : v.cpp,
      v.cpp <Map &Close_Namespace (<Get &Current_Namespace>)> :: v.cpp,
      <Store &Current_Namespace /*empty*/>,
      <ASAIL_To_CPP <Domain &Used_Unavailable_Imports>> :: e.imp,
      e.imp <Map &Close_Namespace (<Get &Current_Namespace>)> v.cpp :: v.cpp,
      <Store &Current_Namespace /*empty*/>,
      {
        <Get &Entry_Name> : v.name = ('rfrt::Entry rf_entry (' v.name ');');;
      } :: e.entry,
      {
        <Get &Const_Exprs> : v.c_exprs =
          <Namespace_Control <Get &Module_Name>> :: e.nc,
          (/*e.init_consts*/) (/*e.decl_consts*/) v.c_exprs $iter {
            e.c_exprs : (t.name (e.value) e.decl) e.rest =
              {
                <IsInTable &Used_Consts t.name> =
                  {
                    t.name : (STATIC e) = <Rfp2Cpp t.name>;
                    <Name_To_CPP "DECL-OBJ" t.name>;
                  } :: e.name,
                  (e.init_consts (e.name ' = new TExpr;') (e.value ';')) (e.decl_consts e.decl) e.rest;
                (e.init_consts) (e.decl_consts) e.rest;
              };
          } :: (e.init_consts) (e.decl_consts) e.c_exprs,
          e.c_exprs : /*empty*/ =
          e.nc
          ('static void init_ () {' (e.init_consts) '}')
          ('static AtStart init_registrator_ (&init_);')
          <Map &Close_Namespace (<Get &Current_Namespace>)>
          (<Store &Current_Namespace /*empty*/>
            <Namespace_Control <Get &Module_Name>>
            e.decl_consts
            <Map &Close_Namespace (<Get &Current_Namespace>)>
          );
        ();
      } :: e.init (e.decl_consts),
      <Store &Current_Namespace /*empty*/>,
      ('#include <rf_core.hh>')
      ('using namespace rfrt;')
      <ASAIL_To_CPP <List.Sub (<Domain &Decls>) <Domain &Locals>>>
      <Map &Close_Namespace (<Get &Current_Namespace>)>
      e.decl_consts
      v.cpp e.init e.entry;;
  };

ASAIL_To_CPP e.asail, {
  e.asail : t.item e.rest, t.item : {
    (s.tag UNDEF e) = ;
    (LINENUMBER sN) = ;
    (NATIVE s.linkage s.tag (e.name) (e.in) (e.out) e.native) =
    	<Del_Pragmas <Gener_Var_Indices 1 (<Vars e.in>) 'arg'>> : e.rfArg s,
    	<Del_Pragmas <Gener_Var_Indices 1 (<Vars e.out>) 'res'>> : e.rfRes s,
    	<ASAIL_To_CPP (s.tag LOCAL (e.name) (e.rfArg) (e.rfRes) (ERROR e.name "Not available"))>;
    (s.tag IMPORT (e.name) t.args t.ress e.body),
      s.tag : \{ FUNC; "FUNC?"; },
      e.name : "org" "refal" "plus" "wrappers" e.n =
      <Bind &Unavailable_Imports (e.name)
        (s.tag LOCAL (<ToWord <Intersperse ('_') e.n>>) t.args t.ress
          (ERROR e.n "Not available"))>;
    (TFUNC s.linkage t.name (e.args) (e.ress) e.body),
      <Store &Current_Func t.name>,
      { <Get &Entry> : e t.name e = <Store &Entry_Name <QName_To_Cpp <Concat t.name>>>;; },
      {
        \{
          <IsInTable &RFP_Options TRACEALL>;
          <IsInTable &RFP_Trace t.name>;
        } =
          <Intersperse ('.') <Concat t.name>> :: e.name,
          <Store &Current_Trace e.name (e.ress)>,
          (<Trace_Enter e.name (e.args)>) (<Trace_Exit e.name (e.ress)>);
        <Store &Current_Trace /*empty*/>,
          () ();
      } :: (e.trace_enter) (e.trace_exit),
      <MapIn &Rfp2Cpp (<Paren e.args>)> :: e.args,
      <MapIn &Id 'TExpr ' (e.args)> :: e.args,
      <Replicate <Length e.args> ('TExpr')> :: e.proto_args,
      <MapIn &Rfp2Cpp (<Paren e.ress>)> :: e.ress,
      <MapIn &Id 'tout Expr ' (e.ress)> :: e.ress,
      <Replicate <Length e.ress> ('tout Expr')> :: e.proto_ress,
      <Concat <Intersperse (', ') e.args e.ress>> :: e.args,
      <Concat <Intersperse (', ') e.proto_args e.proto_ress>> :: e.proto_args,
      <Extract_Qualifiers t.name> :: (e.qualifiers) e,
      <Namespace_Control e.qualifiers>
      ('tfun int '<Name_To_CPP "DECL-FUNC" t.name TFUNC e.proto_args>' ('e.args') {'
        (e.trace_enter <ASAIL_To_CPP e.body> e.trace_exit ('return 0;'))
      '}');
    (s.tag s.linkage t.name (e.args) (e.ress) e.body),
      s.tag : \{ FUNC; "FUNC?"; } =
      <Store &Current_Func t.name>,
      { <Get &Entry> : e t.name e = <Store &Entry_Name <QName_To_Cpp <Concat t.name>>>;; },
      {
        \{
          <IsInTable &RFP_Options TRACEALL>;
          <IsInTable &RFP_Trace t.name>;
        } =
          <Intersperse ('.') <Concat t.name>> :: e.name,
          <Store &Current_Trace e.name (e.ress)>,
          (<Trace_Enter e.name (e.args)>) (<Trace_Exit e.name (e.ress)>);
        <Store &Current_Trace /*empty*/>,
          () ();
      } :: (e.trace_enter) (e.trace_exit),
      <MapIn &Rfp2Cpp (<Paren e.args> <Paren e.ress>)> :: e.args,
      <Concat <Intersperse (', ') <Replicate <Length e.args> ('Expr&')> :: e.proto_args,
      <Concat <Intersperse (', ') <MapIn &Id 'TExpr& ' (e.args)>>> :: e.args,
      <Extract_Qualifiers t.name> :: (e.qualifiers) e,
      <Namespace_Control e.qualifiers>
//T/      ('RF_FUNC (' <Name_To_CPP "DECL-FUNC" t.name> ', '
//T/            <Args_To_CPP ('RF_ARG ') Vars e.args> ', '
//T/            <Args_To_CPP ('RF_RES ') Vars e.ress> ')'
//T/        (e.trace_enter <ASAIL_To_CPP e.body> e.trace_exit)
//T/       'RF_END');
      ('int '<Name_To_CPP "DECL-FUNC" t.name FUNC e.proto_args>' ('e.args') {'
        (e.trace_enter <ASAIL_To_CPP e.body> e.trace_exit ('return 0;'))
      '}');
    (TRACE t.name) =
      <Bind &RFP_Trace (t.name) ()>;
    ("IF-INT-CMP" s.op (e.arg1) (e.arg2) e.body) =
      ('if (' <Expr_Int_To_CPP e.arg1> ' 's.op' ' <Expr_Int_To_CPP e.arg2> ')')
      ('{' (<ASAIL_To_CPP e.body>) '}');
    (IF t.cond e.body) =
      ('if (' <Cond_To_CPP t.cond> ')')
      ('{' (<ASAIL_To_CPP e.body>) '}');
    (FOR (e.cont_label) (e.break_label) (e.cond) (e.step) e.body) =
      {
        e.cont_label : t =
          ('{'
            ('{' (<ASAIL_To_CPP e.body>) '}')
            (LABEL <Rfp2Cpp (LABEL e.cont_label)> ': {}')
          '}');
        ('{' (<ASAIL_To_CPP e.body>) '}');
      } :: e.body,
      {
        e.break_label : t = (LABEL <Rfp2Cpp (LABEL e.break_label)> ': {}');;
      } :: e.break,
      ('for ( ; ; ' <Step_To_CPP e.step> ')') e.body e.break;
    (LABEL (e.label) e.body) =
      ('{' (<ASAIL_To_CPP e.body>) '}')
      (LABEL <Rfp2Cpp (LABEL e.label)> ': {}');
    (TRY e.body) =
      ('RF_TRAP') ('{' (<ASAIL_To_CPP e.body>) '}');
    ("CATCH-ERROR" e.body) =
      ('RF_WITH') ('{' (('RF_CLEANUP;') <ASAIL_To_CPP e.body>) '}');
    RETFAIL =
      {
        <Get &Current_Trace> : e.name (e.ress) =
          <Trace_Fail e.name>;
        /*empty*/;
      } :: e.trace_exit,
      e.trace_exit ('return 1;');
    FATAL =
//      <? &Current-Func> : (e.name),
      ('{' (('TExpr ex;') ('((Expr&)ex).init_str("Unexpected fail", 15);') ('throw ex;')) '}');
//T/      ('RF_FUNC_ERROR (unexpected_fail);');
    (LSPLIT e.expr (e.min) t.var1 t.var2) =
      <Box> :: s.tvars,
      <Expr_Ref_To_CPP s.tvars e.expr> :: e.expr,
      <Get s.tvars> ('RF_lsplit ('e.expr', ' <Expr_Int_To_CPP e.min>', '
        <Rfp2Cpp t.var1>', '<Rfp2Cpp t.var2>');');
    (RSPLIT e.expr (e.min) t.var1 t.var2) =
      <Box> :: s.tvars,
      <Expr_Ref_To_CPP s.tvars e.expr> :: e.expr,
      <Get s.tvars> ('RF_rsplit ('e.expr', '<Expr_Int_To_CPP e.min>', '
        <Rfp2Cpp t.var1>', '<Rfp2Cpp t.var2 >');');
    (ASSIGN t.var e.expr), t.var : (INT e)  =
      (<Rfp2Cpp t.var> ' = ' <Expr_Int_To_CPP e.expr> ';');
    (ASSIGN t.var e.expr) =
      <Box> :: s.tvars,
      <Expr_Ref_To_CPP s.tvars e.expr> :: e.expr,
      <Get s.tvars> (<Rfp2Cpp t.var> ' = 'e.expr';');
    (DECL t.var e.expr), t.var : (INT e)  =
      ('int ' <Rfp2Cpp t.var> ' = '<Expr_Int_To_CPP e.expr>';');
    (DECL s.type t.var) =
      ('TExpr ' <Rfp2Cpp t.var> ';');
    (DECL s.type t.var (SUBEXPR e.expr (e.pos) (e.len))) =
      <Box> :: s.tvars,
      <Term_Ref_To_CPP s.tvars (SUBEXPR e.expr (e.pos) (e.len))> : 'TExpr ' e.constr,
      ('TExpr '<Rfp2Cpp t.var> e.constr';');
    (DECL s.type t.var (DEREF e.expr (e.pos))) =
      <Box> :: s.tvars,
      ('TExpr '<Rfp2Cpp t.var>' = '
        '((Expr&)'<Expr_Ref_To_CPP s.tvars e.expr>')'
        '['<Expr_Int_To_CPP e.pos>'].e;');
    (DECL s.type t.var e.expr) =
      <Box> :: s.tvars,
      <Expr_Ref_To_CPP s.tvars e.expr> :: e.expr,
      <Get s.tvars> ('TExpr ' <Rfp2Cpp t.var> ' ('e.expr');');
    (DROP t.var) =
      (<Rfp2Cpp t.var> '.drop ();');
    (CONTINUE t.label) =
      ('goto ' <Rfp2Cpp (LABEL t.label)> ';');
    (BREAK t.label) =
      ('goto ' <Rfp2Cpp (LABEL t.label)> ';');
    (ERROR e.expr) =
      <Box> :: s.tvars,
      <Expr_Ref_To_CPP s.tvars e.expr> :: e.expr,
      <Get s.tvars> ('RF_ERROR ('e.expr');');
    (CONSTEXPR IMPORT (e.name) (e.comment) e.expr) =
      e.name : "org" "refal" "plus" "wrappers" e.n,
      <Bind &Unavailable_Imports (e.name)
        (CONSTEXPR LOCAL (<ToWord <Intersperse ('_') e.n>>) () e.expr)>;
    (CONSTEXPR s.linkage t.name (e.comment) e.expr) =
      { s.linkage : LOCAL = 'static ';; } :: e.linkage,
      {
        t.name : (STATIC e) = (<Get &Module_Name>) (&Rfp2Cpp t.name);
        <Extract_Qualifiers t.name> (&Name_To_CPP "DECL-OBJ" t.name);
      } :: (e.qualifiers) e (s.name_producer e.name_arg),
      <Put &Const_Exprs (t.name
        (<Const_Expr_To_CPP /*e.expr*/ e.comment>)
        /*e.qualifiers*/ (e.linkage 'TExpr* ' <Apply s.name_producer e.name_arg> ';'))>;
    (OBJ s.linkage s.tag t.name) =
      <Bind &Locals ("DECL-OBJ" t.name) ()>,
      { s.linkage : LOCAL = 'static ';; } :: e.linkage,
      <ToChars s.tag> : s1 e2,
      <Extract_Qualifiers t.name> :: (e.qualifiers) e.n,
      {
        s.tag : BOX =
          <Put &Const_Exprs (t.name
            ('Expr::create_sym< rftype::NamedObject<rftype::BoxContents> >('
              'L"'e.n'")'))>;
//        s.tag : VECTOR =
//          <Put &Const-Exprs (t.name
//            ('Expr::create_sym< rftype::NamedObject<rftype::Vector> >('
//              'L"'e.n'")'))>;
        <Put &Const_Exprs (t.name
          ('new rftype::StaticObject<rftype::' s1 <ToLower e2> '>(L"'e.n'")'))>;
      },
      <Namespace_Control e.qualifiers>
      (e.linkage 'Expr ' <Name_To_CPP "DECL-OBJ" t.name> ';');
    ("DECL-OBJ" t.name) =
      <Extract_Qualifiers t.name> :: (e.qualifiers) e,
      <Namespace_Control e.qualifiers>
      ('extern Expr ' <Name_To_CPP "DECL-OBJ" t.name> ';');
    ("DECL-TFUNC" t.name e.args) =
      <Extract_Qualifiers t.name> :: (e.qualifiers) e,
      <Namespace_Control e.qualifiers>
      ('tfun int '<Name_To_CPP "DECL-TFUNC" t.name>' 'e.args';');
    ("DECL-FUNC" t.name e.args) =
      <Extract_Qualifiers t.name> :: (e.qualifiers) e,
      <Namespace_Control e.qualifiers>
      ('int '<Name_To_CPP "DECL-FUNC" t.name>' 'e.args';');
    (EXTERN t.name) =
      <Bind &Externs (t.name) ()>,
      <Extract_Qualifiers t.name> :: (e.qualifiers) e,
      <Namespace_Control e.qualifiers>
      ('RF_DECL (' <Name_To_CPP "DECL-FUNC" t.name> ');');
    /*
     * s.call can be CALL or TAILCALL or TAILCALL?
     */
    (s.call t.name (e.exprs) (e.ress)) =
      {
        # \{ s.call : CALL; }, <Get &Current_Trace> : e.full_name (e.ress) =
          ('if (RF_CALL (' <Name_To_CPP "DECL-FUNC" t.name> ', '
            <Args_To_CPP () Exprs e.exprs> ', ' <Args_To_CPP () Vars e.ress> '))')
          ('{' (<Trace_Exit e.full_name (e.ress)> ('return true;')) '}')
          ('else RF_RETFAIL;');
//T/        {
//T/          s.call : "TAILCALL?" = TAILCALL;
//T/          s.call;
//T/        } :: s.call,
//T/          ('RF_' s.call ' (' <Name_To_CPP "DECL-FUNC" t.name> ', '
//T/            <Args_To_CPP () Exprs e.exprs> ', ' <Args_To_CPP () Vars e.ress> ');');
        <Concat <Intersperse (', ') <Replicate <Add <Length e.exprs> <Length e.ress>> ('Expr&')> :: e.proto_args,
        (<Name_To_CPP "DECL-FUNC" t.name CALL e.proto_args>'('
          <Concat <Intersperse (', ') (<Args_To_CPP () Exprs e.exprs>) <MapIn &Rfp2Cpp (<Paren e.ress>)>>>
        ');');
      };
  } :: e.cpp_item,
    e.cpp_item <ASAIL_To_CPP e.rest>;
  /*empty*/;
};


Expr_Ref_To_CPP s.tvars e.expr = e.expr : {
  /*empty*/ = 'empty';
  term = <Term_Ref_To_CPP s.tvars term>;
  expr = '(' <Infix_To_CPP (s.tvars) &Term_Ref_To_CPP "+" <Paren expr>> ')';
};

Term_Ref_To_CPP s.tvars e.arg = e.arg : {
  (PAREN e.expr) =
    <Expr_Ref_To_CPP s.tvars e.expr> ' ()';
  (DEREF e.expr (e.pos)) =
    'TExpr (' <Expr_Ref_To_CPP s.tvars e.expr> ', ' <Expr_Int_To_CPP e.pos> ')';
  (SUBEXPR e.expr (e.pos) (e.len)) =
    'TExpr (' <Expr_Ref_To_CPP s.tvars e.expr> ', '
        <Expr_Int_To_CPP e.pos>   ', ' <Expr_Int_To_CPP e.len> ')';
  (REF t.name) = <Name_To_CPP "DECL-OBJ" t.name>;
  "ERROR-EXPR" = 'err';
  (STATIC t.name) =
    <Bind &Used_Consts ((STATIC t.name)) ()>,
    <Get &Current_Namespace> :: e.namespace,
    {
      <Get &Module_Name> : e.namespace = /*empty*/;
      <Get &Module_Name>'::';
    } :: e.prefix,
    '*' e.prefix <Rfp2Cpp (STATIC t.name)>;
  (s.var_tag e.ns t.name) = <Rfp2Cpp (s.var_tag e.ns t.name)>;
  s.sym, {
    <IsInt s.sym> = 
      'Expr::create<' <Get &Int> '>("' s.sym '")';
    <IsWord s.sym> =
      'Expr::create<rftype::Word>("' <Symbol_To_CPP s.sym> '")';
  };
};

Expr_Int_To_CPP {
  /*empty*/ = /*empty*/;
  s.ObjectSymbol = 
    {
      <IsInt s.ObjectSymbol> = s.ObjectSymbol;
      $error ("Illegal type int-symbol: " s.ObjectSymbol);
    };
  (LENGTH e.expr) =
    '((Expr&)'<Expr_Ref_To_CPP <Box> e.expr> ').get_len()';
  (MAX e.args) =
    'pxx_max (' <Args_To_CPP () Ints e.args> ')';
  (MIN e.args) =
    'pxx_min (' <Args_To_CPP () Ints e.args> ')';
  (INFIX s.op e.args) =
    '(' <Infix_To_CPP () &Expr_Int_To_CPP s.op e.args> ')';
  (REF t.name) = <Name_To_CPP "DECL-OBJ" t.name>;
  (s.var_tag t.name) = <Rfp2Cpp (s.var_tag t.name)>;
  expr = '(' <Infix_To_CPP () &Expr_Int_To_CPP "+" <Paren expr>> ')';
};

Cond_To_CPP {
  ("CALL-FAILS" (CALL t.name (e.exprs) (e.ress))) =
    <Concat <Intersperse (', ') <Replicate <Add <Length e.args> <Length e.ress>> ('Expr&')> :: e.proto_args,
    '!RF_CALL (' <Name_To_CPP "DECL-FUNC" t.name CALL e.proto_args> ', '
          <Args_To_CPP () Exprs e.exprs> ', '
          <Args_To_CPP () Vars e.ress>   ')';
  ("SYMBOL?" e.expr (e.pos)) =
    '((Expr&)'<Expr_Ref_To_CPP <Box> e.expr> ').symbol_at(' <Expr_Int_To_CPP e.pos> ')';
  ("FLAT-SUBEXPR?" e.expr (e.pos) (e.len)) =
    <Expr_Ref_To_CPP <Box> e.expr> '.flat_at ('
      <Expr_Int_To_CPP e.pos> ', ' <Expr_Int_To_CPP e.len> ')';
  ("ITER-FAILS" e.expr) =
    '!RF_iter(' <Expr_Ref_To_CPP <Box> e.expr> ')';
  (EQ e.expr1 (e.expr2) (e.pos)) =
    <Expr_Ref_To_CPP <Box> e.expr1> '.eq ('
      <Expr_Ref_To_CPP <Box> e.expr2> ', ' <Expr_Int_To_CPP e.pos> ')'; 
  ("TERM-EQ" e.expr1 (e.expr2) (e.pos)) =
    '((Expr&)'<Term_Ref_To_CPP <Box> e.expr1>')[0] == '
    '((Expr&)'<Term_Ref_To_CPP <Box> e.expr2>')['<Expr_Int_To_CPP e.pos>']';
    //T/ <Expr_Ref_To_CPP <Box> e.expr1> '.term_eq ('
    //T/   <Expr_Ref_To_CPP <Box> e.expr2> ', ' <Expr_Int_To_CPP e.pos> ')'; 
  (NOT t.cond) =
    '!' <Cond_To_CPP t.cond>;
}; 

Infix_To_CPP (e.box) s.arg2cpp s.op e.args, {
  e.args : (e.arg) e.rest =
    <Apply s.arg2cpp e.box e.arg> :: e.arg,
    <Infix_To_CPP (e.box) s.arg2cpp s.op e.rest> :: e.rest,
    {
      e.arg : v, e.rest : v = e.arg ' ' s.op ' ' e.rest;
      e.arg e.rest;
    };;
};

Step_To_CPP {
  /*empty*/ = /*empty*/;
  ("INC-ITER" e.expr) = 'RF_iter(' <Expr_Ref_To_CPP <Box> e.expr> ')++';
  ("DEC-ITER" e.expr) = 'RF_iter(' <Expr_Ref_To_CPP <Box> e.expr> ')--';
};



$func Const_Expr_Aux e.expr = e.cpp_expr;

Const_Expr_To_CPP {
  /*empty*/ = 'empty';
  (SUBEXPR t.name s.pos s.len) = 'Expr (' <Rfp2Cpp t.name> ', ' s.pos ', ' s.len ')';
                  //FIXME: It is needed to check that s.pos and s.len
                  //       are in allowable bounds.
                  //       Set this bounds by options.
  e.expr =
    <Const_Expr_Aux () e.expr> : {
      ' + ' e.cpp_expr = e.cpp_expr;
      e.cpp_expr = e.cpp_expr;
    };
};

Const_Expr_Aux (e.accum) e.expr, {
  e.expr : s.sym e.rest, <IsChar s.sym> =
    <Const_Expr_Aux (e.accum <Symbol_To_CPP s.sym>) e.rest>;
  e.accum : v =
    '"'e.accum'"' <Const_Expr_Aux () e.expr>;
//T/    {
//T/      <CharsToBytes e.accum> : e s.c e,
//T/        <Gt (s.c) (127)> =
//T/        ' + rftype::Char::create_expr ("' e.accum '")' <Const_Expr_Aux () e.expr>;
//T/      //' + Expr::create_seq<Char> (L"' e.accum '")' <Const-Expr-Aux () e.expr>;
//T/      ' + rftype::Char::create_expr (L"' e.accum '")' <Const_Expr_Aux () e.expr>;
//T/    };
  e.expr : t.item e.rest, t.item : {
    (PAREN e.paren_expr) =
      ' + (' <Const_Expr_To_CPP e.paren_expr> ') ()';
    (REF t.name) =
      ' + ' <Name_To_CPP "DECL-OBJ" t.name>;
//      ' + Expr::create<ObjectRef>(' <Name-To-CPP t.name> ')';
    (STATIC e) =
      <Bind &Used_Consts (t.item) ()>,
      ' + ' '*' <Rfp2Cpp t.item>;
    (s.FUNC t.name), s.FUNC : \{ FUNC; "FUNC?"; TFUNC; } =
      ' + Expr::create_sym<rftype::Func> (' <Name_To_CPP "DECL-FUNC" t.name> ')';
    s.sym, {
      <IsInt s.sym> = 
        ' + Expr::create<' <Get &Int> '>("' s.sym '")';
      <IsWord s.sym> =
        ' + Expr::create<rftype::Word>("' <Symbol_To_CPP s.sym> '")';
    };
  } :: e.cpp_item =
    e.cpp_item <Const_Expr_Aux () e.rest>;
  = /*empty*/;
};

Symbol_To_CPP s.ObjectSymbol, {
  <ToChars 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.cpp_char,
    e.rest (e.cpp_symbol e.cpp_char);
  } :: e.symbol (e.cpp_symbol),
    e.symbol : /*empty*/ =
    e.cpp_symbol;
};



Args_To_CPP {
  (v.prefix) Vars /*empty*/  = 'RF_VOID';
  (        ) Vars /*empty*/  = '/*void*/';
  (        ) Vars (e.arg)    = <Rfp2Cpp (e.arg)>;
  (e.prefix) Exprs /*empty*/ = '/*void*/';
  (e.prefix) Exprs (e.arg)   = <Expr_Ref_To_CPP <Box> e.arg>;
  (e.prefix) s.tag e.args =
    e.args () $iter {
      e.args : (e.arg) e.rest =
        {
          e.rest : v = ', ';
          /*empty*/;
        } :: e.comma,
        s.tag : {
          Vars = e.rest (e.cpp_args <Rfp2Cpp (e.arg)> e.comma);
          Exprs = e.rest (e.cpp_args <Expr_Ref_To_CPP <Box> e.arg> e.comma);
          Ints = e.rest (e.cpp_args <Expr_Int_To_CPP e.arg> e.comma);
        };
    } :: e.args (e.cpp_args),
    e.args : /*empty*/,
    (e.prefix) s.tag : {
      t   Exprs = '(' e.cpp_args ')';
      ( ) Vars  = '(' e.cpp_args ')';
      (v) Vars  = '(' e.prefix e.cpp_args ';;)';
      e         = e.prefix e.cpp_args;
    };
};

Name_To_CPP s.decl_type (e.name) e.args =
  {
    e.name : "org" "refal" "plus" "wrappers" e.cont =
      <Bind &Used_Unavailable_Imports (<Lookup &Unavailable_Imports e.name>) ()>,
      <QName_To_Cpp <Get &Module_Name> <ToWord <Intersperse ('_') e.cont>>>;
    e.name : "refal" "plus" e.cont =
      {
        <Lookup &Decls s.decl_type ("refal" e.cont)> : e;
        <Bind &Decls (s.decl_type ("refal" e.cont)) (e.args)>;
      },
      <QName_To_Cpp "" "refal" e.cont>;
    <Get &Current_Namespace> :: e.namespace,
      <Bind &Decls (s.decl_type (e.name)) (e.args)>,
      {
        e.name : e.namespace e.cont =
          <QName_To_Cpp e.cont>;
        <QName_To_Cpp e.name>;
      };
  };

QName_To_Cpp e.name = <Intersperse ('::') e.name>;

Open_Namespace e.name = ('namespace ' e.name ' {');
Close_Namespace e.name = ('}');

Namespace_Control e.qualifiers =
  {
    e.qualifiers : /*empty*/ = <Get &Module_Name>;
    e.qualifiers : () = /*empty*/;
    e.qualifiers;
  } :: e.qualifiers,
  {
    <Get &Current_Namespace> : e.qualifiers;
    <Map &Close_Namespace (<Get &Current_Namespace>)> :: e.close_namespace,
      <Store &Current_Namespace e.qualifiers>,
      e.close_namespace <Map &Open_Namespace (e.qualifiers)>;
  };

Trace_Enter e.name (e.args) =
  e.args 1 () $iter {
    e.args : t.arg e.rest =
      {
        \{ e.rest : v; <Gt (s.n) (1)>; } = 'printf("%2d: ", 's.n');';
        'printf("  : ");';
      } :: e.num,
      e.rest <Add s.n 1>
      (e.pr_args ('printf ("           argument "); 'e.num' ('<Rfp2Cpp t.arg>').writeln(stdout);'));
  } :: e.args s.n (e.pr_args),
  e.args : /*empty*/ =
  ('printf ("+ %5u: enter >>> 'e.name' <<<\\n", rfrt::stack->get_depth());') e.pr_args;

Trace_Exit e.name (e.args) =
  e.args 1 () $iter {
    e.args : t.arg e.rest =
      {
        \{ e.rest : v; <Gt (s.n) (1)>; } = 'printf("%2d: ", 's.n');';
        'printf("  : ");';
      } :: e.num,
      e.rest <Add s.n 1>
      (e.pr_args
       ('printf ("           result   "); 'e.num' ('<Rfp2Cpp t.arg>').to_Expr().writeln(stdout);'));
  } :: e.args s.n (e.pr_args),
  e.args : /*empty*/ =
  ('printf ("- %5u: exit  >>> 'e.name' <<<\\n", rfrt::stack->get_depth());') e.pr_args;

Trace_Fail e.name =
  ('printf ("- %5u: fail  >>> 'e.name' <<<\\n", rfrt::stack->get_depth());');

Extract_Qualifiers t.name, {
  <IsInTable &Externs t.name> =
    t.name : (e.n),
    (()) e.n;
  <RFP_Extract_Qualifiers t.name>;
};