$use Apply Arithm Box Class Compare Convert CppMangle List StdIO Table;
$use "rfpc";
$use "rfp_helper";
$use "rfp_compile";

$box Int;

$box Module-Name;

$box Current-Namespace;

$box Current-Func;

$box Entry;

$box Entry-Name;

$box Const-Exprs;

$box Const-Local;
 
$box Param;

$func ASAIL-To-TPP e.body = e.cpp-code;

// $func Namespace-Control e.qualifiers = e.namespace-control;

$func Expr-To-TPP (e.ASAIL-Expr-init) e.ASAIL-Expr-rest = e.ASAIL-Expr;

$func Expr-Ref-To-TPP e.ASAIL-Expr-Ref = e.CPP-Expr-Ref;

$func Expr-Int-To-TPP e.ASAIL-Expr-Int = e.CPP-Expr-Int;

$func Step-To-TPP e.step-operators = e.cpp-step-operators;

$func Const-Expr-To-TPP e.ASAIL-const-expr = e.CPP-const-expr;

$func Args-To-TPP (e.prefix) s.Arg-Res-Tag e.ASAIL-Args = e.CPP-Args;

$func Symbol-To-TPP s.RFP-Symbol = e.CPP-String;

$func Name-To-TPP t.name = e.CPP-Name;

$func Cond-To-TPP e.cond = e.CPP-Cond;

$func Infix-To-TPP s.func-for-converting-args-to-cpp s.op e.args = e.cpp-expr;

$func Op-Arg-To-TPP s.op = s.func-for-converting-args-to-cpp;

$func TPP-Param e.cpp-param = e.tpp-param;

$func Func-Const (e.const) (e.local-const) = e.local;

$func Add s.box e.const = ;

$func Term-Ref-To-TPP e = e;

$func Punct e.param = e.text;

$func Func-Prototype (e.type) e.param = e.res;


RFP-ASAIL-To-TPP (e.ModuleName) e.asail =
  {
    <Store &Int <Lookup &RFP-Options INT>>;
    <Store &Int Integer>;
  },
  <Store &Module-Name e.ModuleName>,
//  <Store &Current-Namespace /*empty*/>,
  <Store &Entry (e.ModuleName Main)>,
  <Store &Entry-Name /*empty*/>,
  <Store &Const-Exprs /*empty*/>,
  {
    <ASAIL-To-TPP e.asail> : v.cpp,
  //    {
  //      <? &Current-Namespace> : v = ('}');;  // close last namespace
  //    } :: e.close-namespace,
  //    <Store &Current-Namespace /*empty*/>,
//      {
//        <? &Entry-Name> : v.name = ('rfrt::Entry rf_entry (' v.name ');');;
//      } :: e.entry,
//      {
//        <? &Const-Exprs> : v.c-exprs =
//          (/*e.init-consts*/) <? &Const-Exprs> $iter {
//            e.c-exprs : (e.cpp-name (e.value)) e.rest =
//              (e.init-consts (e.cpp-name ' = ' e.value ';')) e.rest;
//          } :: (e.init-consts) e.c-exprs
    //    ,
    //      e.c-exprs : /*empty*/ =
    //      <Namespace-Control <? &Module-Name>>
    //      ('static void init_ ()\n{' (e.init-consts) '}')
    //      ('static AtStart init_registrator_ (&init_);')
    //      ('}')
//           ;;
//   } :: e.init,
    //  ('namespace refal\n{')
    //  ('using namespace rfrt;')
        v.cpp 
    //  e.close-namespace 
//      e.init 
//      e.entry
    //  ('}')
       ;;
  };

ASAIL-To-TPP e.asail,  
{
  e.asail : t.item e.end =  t.item : {
    (s.tag t.name (e.args) (e.ress) e.body),
      s.tag : \{
        FUNC  = ('tfun int') /*empty*/;
        FUNC? = ('boolean') ('return true;');
        TFUNC = ('tfun int') /*empty*/;
      } :: (e.return-type) e.return, 
      <Store &Current-Func t.name>,
      { 
        <? &Entry> : t.name = <Store &Entry-Name <Rfp2Cpp t.name>>;; 
      },
      <RFP-Extract-Qualifiers t.name> :: (e.qualifiers) e.name,
      <TPP-Param <Args-To-TPP ('RF_ARG')  Vars e.args>> :: e.tval, 
      <TPP-Param <Args-To-TPP ('RF_Res')  Vars e.ress> > :: e.tout,
      { 
        e.tval : /*empty*/ = e.tout;
        e.tout : /*empty*/ = e.tval;
        e.tval ',' e.tout;
      } :: e.tparam,
      <Store &Const-Local /*empty*/>, 
      <ASAIL-To-TPP e.body> :: e.body, 
      <Func-Const (<? &Const-Exprs>) (<? &Const-Local>)> :: e.const,
      {
        () e.const $iter {
          e.result : (e.cpp-name (e.value)) e.rest =
            (e.init-consts ('tval Expr ' e.cpp-name ' = ' e.value ';')) e.rest;
        } :: (e.init-consts) e.result,
        e.result : /*empty*/ = e.init-consts;
      } :: e.const,
       ('tfun int ' <Rfp2Cpp e.name> '( 'e.tparam ')' ('{' 
         ('tval Expr empty;')  (e.const)  (e.body) '}'));
    (IF (e.cond) e.body) =
      ('if (' <Cond-To-TPP e.cond> ')')
      ('{' (<ASAIL-To-TPP e.body>) '}');
    (FOR (e.cont-label) (e.break-label) (e.cond) (e.step) e.body) =
      {
        e.cont-label : t =
          ('{'
            ('{' (<ASAIL-To-TPP e.body>) '}')
            (LABEL <Rfp2Cpp (LABEL e.cont-label)> ': {}')
          '}');
        ('{' (<ASAIL-To-TPP e.body>) '}');
      } :: e.body,
      {
        e.break-label : t = (LABEL <Rfp2Cpp (LABEL e.break-label)> ': {}');;
      } :: e.break,
      ('for ( ; ' <Cond-To-TPP e.cond> '; ' <Step-To-TPP e.step> ')') e.body e.break;
    (LABEL (e.label) e.body) =
//      {
//        e.label : /*empty*/ =
//          ('{' (<ASAIL-To-TPP e.body>) '}' );
        ('{' (<ASAIL-To-TPP e.body>) '}')
        (LABEL <Rfp2Cpp (LABEL e.label)> ': {}');
//      };
    (TRY e.body) =
      ('RF_TRAP') ('{' (<ASAIL-To-TPP e.body>) '}');
    (CATCH-ERROR e.body) =
      ('RF_WITH') ('{' (('RF_CLEANUP;') <ASAIL-To-TPP e.body>) '}');
    RETURN = ('return true;');
    RETFAIL = ('RF_RETFAIL;');
    FATAL =
//      <? &Current-Func> : (e.name),
      ('RF_FUNC_ERROR (unexpected_fail);');
    (LSPLIT e.expr (e.min) t.var1 t.var2) =
      ('lsplit (' <Expr-Ref-To-TPP e.expr> ',' <Expr-Int-To-TPP e.min>
       ', (Expr&) ' <Rfp2Cpp t.var1> ',(Expr&) ' <Rfp2Cpp t.var2> ');');
    (RSPLIT e.expr (e.min) t.var1 t.var2) =
      ('rsplit (' <Expr-Ref-To-TPP e.expr> ',' <Expr-Int-To-TPP e.min> 
      ', (Expr&) ' <Rfp2Cpp t.var1> ',(Expr&)' <Rfp2Cpp t.var2 > ');');
    (ASSIGN t.var e.expr) =
      (<Rfp2Cpp t.var> ' = ' <Expr-To-TPP () e.expr> ';');
    (DECL s.type t.var) =
      ('tval Expr ' <Rfp2Cpp t.var> ';');
    (INT  t.var e.expr) =
      ('tval Expr ' <Rfp2Cpp t.var> ' = ' <Expr-Int-To-TPP e.expr> ';');
    (EXPR t.var e.expr) =
      ('tval Expr ' <Rfp2Cpp t.var> ' (' <Expr-Ref-To-TPP e.expr> ');');
    (DEREF t.var e.expr (e.pos)) =
      ('tval Expr ' <Rfp2Cpp t.var> ' (' <Expr-Ref-To-TPP e.expr> ', '
      <Expr-Int-To-TPP e.pos> ');');
    (SUBEXPR t.var e.expr (e.pos) (e.len)) =
      ('tval Expr ' <Rfp2Cpp t.var> ' ('
      <Expr-Ref-To-TPP e.expr> ', ' <Expr-Int-To-TPP e.pos> ', ' 
      <Expr-Int-To-TPP e.len> ');');
    (DROP t.var) =
      ('((Expr&)'<Rfp2Cpp t.var> ').drop ();');
    (CONTINUE t.label) =
      ('goto ' <Rfp2Cpp (LABEL t.label)> ';');
    (BREAK t.label) =
      ('goto ' <Rfp2Cpp (LABEL t.label)> ';');
    (ERROR e.expr) =
      ('RF_ERROR (' <Expr-Ref-To-TPP e.expr> ');');
    (CONSTEXPR s.linkage t.name (e.comment) e.expr) =
//      { s.linkage : LOCAL = 'static ';; } :: e.linkage,
      {
        t.name : (STATIC e) = (<? &Module-Name>) t.name;
        <RFP-Extract-Qualifiers t.name>;
      } :: (e.qualifiers) e.name,
      <Rfp2Cpp e.name> :: e.cpp-name,
      <Put &Const-Exprs (e.cpp-name (<Const-Expr-To-TPP e.expr>))>;
//      <Namespace-Control e.qualifiers>
//      (e.linkage 'tval Expr ' e.cpp-name ';');
    (OBJ s.linkage s.tag t.name) =
      { s.linkage : LOCAL = 'static ';; } :: e.linkage,
      <To-Chars s.tag> : s1 e2,
      <RFP-Extract-Qualifiers t.name> :: (e.qualifiers) e.name,
      <Rfp2Cpp e.name> :: e.cpp-name,
      {
        s.tag : BOX =
          <Put &Const-Exprs (e.cpp-name
            ('Expr::create_sym< NamedObject<BoxContents> >(L"'e.name'")'))>;
        <Put &Const-Exprs (e.cpp-name
          ('new rftype::StaticObject<rftype::' s1 <To-Lower e2> '>(L"'e.name'")'))>;
      },
//      <Namespace-Control e.qualifiers>
      (e.linkage 'Expr ' e.cpp-name ';');
    (DECL-OBJ t.name) =
      <RFP-Extract-Qualifiers t.name> :: (e.qualifiers) e.name,
//      <Namespace-Control e.qualifiers>
      ('extern Expr ' <Rfp2Cpp e.name> ';');
    (DECL-FUNC t.fname) =
      <RFP-Extract-Qualifiers t.fname> :: (e.qualifiers) e.name,
      <Store &Param 0>,
      <Lookup-Func t.fname> : e.expr (e.Fin)(e.Fout),
      <Func-Prototype ('tval ') e.Fin>::e.fin,
      <Func-Prototype ('tout ') e.Fout>::e.fout,
      <Punct e.fin e.fout> :: e.param,
//      <Namespace-Control e.qualifiers>
      ('tfun int ' <Rfp2Cpp e.name> ' (' e.param ');');
    /*
     * s.call can be CALL or TAILCALL
     */
    (s.call t.name (e.exprs) (e.ress)) = 
      <Args-To-TPP  () Exprs e.exprs> :: e.tval, 
      <Args-To-TPP  () Vars e.ress> :: e.tout,
      { 
        e.tval : /*empty*/ = e.tout;
        e.tout : /*empty*/ = e.tval;
        e.tval ',' e.tout;
      } :: e.tparam, 
      ( <Name-To-TPP t.name> '(' e.tparam ');');
  } :: e.cpp-item,
    e.cpp-item <ASAIL-To-TPP e.end>;
  /*empty*/;
};


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

Expr-Ref-To-TPP {
  /*empty*/ = /*empty*/;
  term = <Term-Ref-To-TPP term>;
  expr = ' concat(' <Infix-To-TPP &Term-Ref-To-TPP "+" <Paren expr>> ')';
};

Term-Ref-To-TPP {
  (PAREN e.expr) =
    'tval Expr ' <Expr-Ref-To-TPP e.expr> ' ()';
  (EXPR e.expr) =
    ' tval Expr(' <Expr-Ref-To-TPP e.expr> ')';
  (DEREF e.expr (e.pos)) =
    'tval Expr(' <Expr-Ref-To-TPP e.expr> ', ' <Expr-Int-To-TPP e.pos> ')';
  (SUBEXPR e.expr (e.pos) (e.len)) =
    'tval Expr(' <Expr-Ref-To-TPP e.expr> ', '
        <Expr-Int-To-TPP e.pos>   ', ' <Expr-Int-To-TPP e.len> ')';
  (REF t.name) = <Name-To-TPP t.name>;
  ERROR-EXPR = 'err';
  (s.var-tag t.name) =  {  
    s.var-tag : STATIC = <Rfp2Cpp (s.var-tag t.name)> :: e.var, 
      <Add &Const-Local  (e.var) <? &Const-Local>>, e.var;
    <Rfp2Cpp (s.var-tag t.name)>;
    };
};

Expr-Int-To-TPP {
  /*empty*/ = /*empty*/;
  s.ObjectSymbol = 
    {
      <Int? s.ObjectSymbol> = s.ObjectSymbol;
      $error ("Illegal type int-symbol: " s.ObjectSymbol);
    };
  (LENGTH e.expr) =
    '((Expr&)' <Expr-Ref-To-TPP e.expr> ').get_len ()';
  (MAX e.args) =
    'pxx_max (' <Args-To-TPP () Ints e.args> ')';
  (MIN e.args) =
    'pxx_min (' <Args-To-TPP () Ints e.args> ')';
  (INFIX s.op e.args) =
    '(' <Infix-To-TPP &Expr-Int-To-TPP s.op e.args> ')';
  (REF t.name) = <Name-To-TPP t.name>;
  (s.var-tag t.name) =  {  
    s.var-tag : STATIC = <Rfp2Cpp (s.var-tag t.name)> :: e.var, 
      <Add &Const-Local  (e.var) <? &Const-Local>>, e.var;
    <Rfp2Cpp (s.var-tag t.name)>;
    };
//  (s.var-tag t.name) = <Rfp2Cpp (s.var-tag t.name)>;
  expr = '(' <Infix-To-TPP &Expr-Int-To-TPP "+" <Paren expr>> ')';
};

Cond-To-TPP {
  /*empty*/ = /*empty*/;
  (CALL t.name (e.exprs) (e.ress)) =
//    e.exprs () $iter {
//      e.tmp : (exp) e.r,
//        e.r
//        (e.pr-args 'printf ("    "); ('
//              <Expr-Ref-To-TPP exp> ').writeln(stdout); ');
//    } :: e.tmp (e.pr-args),
//    e.tmp : /*empty*/ =
//    e.ress () $iter {
//      e.tmp : t.var e.r, {
//        <To-Chars t.var> : '(VAR(res' e =
//          e.r
//          (e.pr-ress 'printf ("    res-var\\n");');
//        e.r
//        (e.pr-ress 'printf ("    "); '
//              <Rfp2Cpp t.var> '.writeln(stdout); ');
//      };
//    } :: e.tmp (e.pr-ress),
//    e.tmp : /*empty*/ =
//    '({ printf ("<<<<< ' <Name-To-TPP t.name> '\\n"); ' e.pr-args
//    'bool res = '
   
      <Args-To-TPP  () Exprs e.exprs> :: e.tval, 
      <Args-To-TPP  () Vars e.ress> :: e.tout,
      { 
        e.tval : /*empty*/ = e.tout;
        e.tout : /*empty*/ = e.tval;
        e.tval ',' e.tout;
      } :: e.tparam, 
      <Name-To-TPP t.name> '(' e.tparam ')' ;
//    '; printf (">>>>> ' <Name-To-TPP t.name> '\\n"); '
//    'if (res) { 'e.pr-ress' } else printf ("    failed\\n"); res; })'
//    ;
  (SYMBOL? e.expr (e.pos)) =
    '((Expr&)'<Expr-Ref-To-TPP e.expr> ').symbol_at (' <Expr-Int-To-TPP e.pos> ')';
  (FLAT-SUBEXPR? e.expr (e.pos) (e.len)) =
    '((Expr&)' <Expr-Ref-To-TPP e.expr> ').flat_at ('
      <Expr-Int-To-TPP e.pos> ', ' <Expr-Int-To-TPP e.len> ')';
  (CHECK-ITER e.expr) =
    'iter(' <Expr-Ref-To-TPP e.expr> ')';
  (EQ e.expr1 (e.expr2) (e.pos)) =
    '((Expr&)' <Expr-Ref-To-TPP e.expr1> ').eq ('
      <Expr-Ref-To-TPP e.expr2> ', ' <Expr-Int-To-TPP e.pos> ')'; 
  (TERM-EQ e.expr1 (e.expr2) (e.pos)) =
    '((Expr&)' <Expr-Ref-To-TPP e.expr1> ').term_eq ('
      <Expr-Ref-To-TPP e.expr2> ', ' <Expr-Int-To-TPP e.pos> ')'; 
  (NOT e.cond) =
    '!' <Cond-To-TPP e.cond>;
  (INFIX s.op e.args) =
    '(' <Infix-To-TPP <Op-Arg-To-TPP s.op> s.op e.args> ')';
  expr = '(' <Infix-To-TPP &Cond-To-TPP "&&" <Paren expr>> ')';
}; 

Infix-To-TPP s.arg2cpp s.op e.args, {
  e.args : (e.arg) e.rest =
    <Apply s.arg2cpp e.arg> :: e.arg,
    <Infix-To-TPP s.arg2cpp s.op e.rest> :: e.rest,
    {
      e.arg : v, e.rest : v = {
           s.op : "+" = ' concat('e.arg ','e.rest')';
           e.arg ' ' s.op ' ' e.rest;
           }; 
      e.arg e.rest;
    };;
};

Op-Arg-To-TPP s.op, {
  s.op : \{ "&&"; "||"; } =
    &Cond-To-TPP;
  s.op : \{ "<"; ">"; "<="; ">="; "=="; "!="; "+"; "-"; "%"; "*"; "/"; } =
    &Expr-Int-To-TPP;
};
 
Step-To-TPP {
  /*empty*/ = /*empty*/;
  (INC-ITER e.expr) = 'iter(' <Expr-Ref-To-TPP e.expr> ')++';
  (DEC-ITER e.expr) = 'iter(' <Expr-Ref-To-TPP e.expr> ')--';
};



$func Const-Expr-Aux e.expr = e.cpp-expr;

Const-Expr-To-TPP {
  /*empty*/ = 'empty';
  (SUBEXPR t.name s.pos s.len) = 'tval Expr (' <Rfp2Cpp t.name> ', ' s.pos ', ' s.len ')';
                  //FIXME: надо проверять, что s.pos и s.len
                  //       не превышают допустимых величин.
                  //       Задавать эти величины опциями.
  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, <Char? s.sym> =
    <Const-Expr-Aux (e.accum <Symbol-To-TPP s.sym>) e.rest>;
  e.accum : v =
    ' + Char::create_expr ("' e.accum '")' <Const-Expr-Aux () e.expr>;
  e.expr : t.item e.rest, t.item : {
    (PAREN e.paren-expr) =
      ' + (' <Const-Expr-To-TPP e.paren-expr> ') ()';
    (REF t.name) =
      ' + ' <Name-To-TPP t.name>;
//      ' + Expr::create<ObjectRef>(' <Name-To-TPP t.name> ')';
    (STATIC e) = <Rfp2Cpp t.item> :: e.const,
      <Add &Const-Local (e.const) <? &Const-Local>>, 
      ' + ' e.const;
    (FUNC t.name) =
      ' + Expr::create_sym<Func> (' <Name-To-TPP t.name> ')';
    s.sym, {
      <Int? s.sym> = 
        ' + Expr_create_' <? &Int> '("' s.sym '")';
      <Word? s.sym> =
        ' + Expr_create_Word("' <Symbol-To-TPP s.sym> '")';
    };
  } :: e.cpp-item =
    e.cpp-item <Const-Expr-Aux () e.rest>;
  = /*empty*/;
};

Symbol-To-TPP 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.cpp-char,
    e.rest (e.cpp-symbol e.cpp-char);
  } :: e.symbol (e.cpp-symbol),
    e.symbol : /*empty*/ =
    e.cpp-symbol;
};



Args-To-TPP {
  (v.prefix) Vars /*empty*/  = 'RF_VOID' ;
  (        ) Vars /*empty*/  =  /*empty*/ ;
  (        ) Vars (e.arg)    = <Rfp2Cpp (e.arg)>;
  (e.prefix) Exprs /*empty*/ = /*empty*/ ;
  (e.prefix) Exprs (e.arg)   = <Expr-Ref-To-TPP 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-TPP e.arg> e.comma);
          Ints = e.rest (e.cpp-args <Expr-Int-To-TPP 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-TPP t.obj-name =
  <RFP-Extract-Qualifiers t.obj-name> :: (e.qualifiers) e.name,
  <? &Current-Namespace> :: e.namespace,
  {
    e.qualifiers : e.namespace e.cont = <Rfp2Cpp e.cont e.name>;
    <Rfp2Cpp (e.qualifiers e.name)>;
  };

/* Namespace-Control e.qualifiers, {
  <? &Current-Namespace> : e.qualifiers;
  {
    <? &Current-Namespace> : v = ('}');;
  } :: e.close-namespace,
    <Store &Current-Namespace e.qualifiers>,
    e.close-namespace ('namespace ' <Rfp2Cpp e.qualifiers> '\n{');
};
*/


TPP-Param {
 'RF_VOID' = /*empty*/;
 '(RF_ARG' ex ',' ey  = 'tval Expr ' ex <TPP-Param '(RF_ARG' ey>;
 '(RF_ARG' ex ';;)' = 'tval Expr ' ex;
 '(RF_Res' ex ',' ey = 'tout Expr ' ex <TPP-Param '(RF_Res' ey>;
 '(RF_Res' ex ';;)' = 'tout Expr ' ex; 
};

Add s.box (e.const) e.expr  = { 
      e.expr : e1 (e.const) e2 = /*empty*/;
      <Store s.box (e.const) e.expr>;
};

Func-Const (e.all-const) (e.local-const) = 
  ( ) (e.all-const) (e.local-const) $iter {
    e.local : (e.name) e.rest, 
    e.all : e1 (e.name(e.value)) e2 = 
    (e.res (e.name(e.value))) (e1 e2) (e.rest);
  }  :: (e.res) (e.all) (e.local),
  e.local : /*empty*/  = e.res;

Punct {
  /*empty*/ = /*empty*/; 
  (e1) = e1;
  (e1) e2 = e1 ',' <Punct e2>;
};


Func-Prototype (e.type) e.param =  
  () e.param $iter {
    e.list : (e1) e2 = <? &Param> : s.numb,
    <Store &Param <"+" s.numb 1>>,
    (e.init (e.type' Expr var_'<? &Param>)) e2;
  } :: (e.init) e.list,
  e.list : /*empty*/ = e.init;