interface IDataparam
{
  extern xint $int$;
  enum Status {Yes, No};

  in void e0 ();
  in Status e0r ();
  in void e (in xint i);
  in Status er (in xint i);
  in Status eer (in xint i, in xint j);

  in void eo(out xint i);
  in void eoo(out xint i, out xint j);
  in void eio(in xint i, out xint j);
  in void eio2(inout xint i);

  in Status eor(out xint i);
  in Status eoor(out xint i, out xint j);
  in Status eior(in xint i, out xint j);
  in Status eio2r(inout xint i);

  out void a0 ();
  out void a (xint i);
  out void aa (in xint i, in xint j);
  out void a6 (in xint a0,in xint a1,in xint a2,in xint a3,in xint a4,in xint a5);

  behaviour
  {
    on e0: a6;
    on e0r: {a0;reply(Status.Yes);}
    on e:
    {
      a;
      aa;
    }
    on er:
    {
      a;
      aa;
      reply(Status.Yes);
    }
    on eer:
    {
      a;
      aa;
      reply(Status.No);
    }
    on eo:{}
    on eoo:{}
    on eio:{}
    on eio2:{}

    on eor: { reply(Status.Yes); }
    on eoor: { reply(Status.Yes); }
    on eior: { reply(Status.Yes); }
    on eio2r: { reply(Status.Yes); }
  }
}

component Dataparam_
{
  provides IDataparam port;

  behaviour
  {
    IDataparam.xint mi = $0$;
    IDataparam.Status s = IDataparam.Status.Yes;

    IDataparam.Status fun ()
    {
      return IDataparam.Status.Yes;
    }

    IDataparam.Status funx (IDataparam.xint xi)
    {
      // xi = xi; Java: final parameter may not be assigned
      return IDataparam.Status.Yes;
    }

    // void fun(inout IDataparam.xint i) // TODO inout function
    // {
    //   i = $789$;
    // }

    // IDataparam.xint xfunx (IDataparam.xint xi, IDataparam.xint xj)
    // {
    //   return $(xi + xj) / 2$;
    // }

    on port.e0(): { port.a6($0$,$1$,$2$,$3$,$4$,$5$); }

    on port.e0r(): {port.a0();reply(IDataparam.Status.Yes);}

    on port.e (pi):
    {
      IDataparam.Status s = funx (pi);
      s = s;
      mi = pi;
      // mi = xfunx (pi, $pi + mi$);  // member in $: Ok for C++ but C: self->mi, Python: self.mi
      //mi = xfunx (pi, $pi + pi$); // javascript: foobar NaN
      //mi = xfunx (pi, pi);
      port.a (mi);
      port.aa (mi, pi);
      pi = $0$; // assign in-parameter should not have any effect
    }
    on port.er (pi):
    {
      IDataparam.Status s = IDataparam.Status.No;
      mi = pi;
      port.a (mi);
      port.aa (mi, pi);

      if(true) {
        reply(IDataparam.Status.Yes);
      } else {
        reply(s);
      }
    }
    on port.eer (i,j):
    {
      IDataparam.Status s = IDataparam.Status.No;
      port.a (j);
      port.aa (j, i);
      reply(s);
    }
    on port.eo(i): { i = $234$; }
    on port.eoo(i,j): { i = $123$; j = $456$; }
    on port.eio(i,j): { j = i; }
    // on port.eio2(i): { i = $i + 123$; } // parameter in $: Ok for C++ but C: *i
    // on port.eio2(i): { IDataparam.xint t = i; i = $t + 123$; } // Ok for C, C++; not portable to javascript
    //on port.eio2(i): { IDataparam.xint t = i; i = $123 + 123$; } // Ok for C, C++, Python, Javascript, not portable to Scheme
    on port.eio2(i): { IDataparam.xint t = i; i = $246$; }

    on port.eor(i): { i = $234$; reply(IDataparam.Status.Yes); }
    on port.eoor(i,j): { i = $123$; j = $456$; reply(IDataparam.Status.Yes); }
    on port.eior(i,j): { j = i; reply(IDataparam.Status.Yes); }
    // on port.eio2r(i): { i = $i + 123$; reply(IDataparam.Status.Yes); } // parameter in $: Ok for C++ but C: *i
    // on port.eio2r(i): { IDataparam.xint t = i; i = $t + 123$; reply(IDataparam.Status.Yes); }
    //on port.eio2r(i): { IDataparam.xint t = i; i = $123 + 123$; reply(IDataparam.Status.Yes); }
    on port.eio2r(i): { IDataparam.xint t = i; i = $246$; reply(IDataparam.Status.Yes); }
  }
}

component proxy
{
  provides IDataparam top;
  requires IDataparam bottom;

  behaviour
  {
    void outfunc (out IDataparam.xint i)
    {
      IDataparam.xint j = i;
      bottom.eo(j);
      i = j;
    }
    void deferfunc (IDataparam.xint i)
    {
      top.a(i);
    }
    on top.e0(): bottom.e0();
    on top.e0r(): {IDataparam.Status r = bottom.e0r(); reply(r);}
    on top.e(pi): bottom.e(pi);
    on top.er(pi): {IDataparam.Status r = bottom.er(pi); reply(r);}
    on top.eer(i,j): {IDataparam.Status r = bottom.eer(i,j); reply(r);}

    on top.eo(i): { outfunc(i); }
    on top.eoo(i,j): { bottom.eoo(i,j); }
    on top.eio(i,j): { bottom.eio(i,j); }
    on top.eio2(i): { bottom.eio2(i); }

    on top.eor(i): { IDataparam.Status s = bottom.eor(i); reply(s); }
    on top.eoor(i,j): { IDataparam.Status s = bottom.eoor(i,j); reply(s); }
    on top.eior(i,j): { IDataparam.Status s = bottom.eior(i,j); reply(s); }
    on top.eio2r(i): { IDataparam.Status s = bottom.eio2r(i); reply(s); }

    on bottom.a0(): top.a0();
    on bottom.a6(A0,A1,A2,A3,A4,A5): top.a6(A0,A1,A2,A3,A4,A5);
    on bottom.a(i): deferfunc(i);
    on bottom.aa(i,j): top.aa(i,j);
  }
}

component Dataparam
{
  provides IDataparam port;
  system
  {
    proxy p;
    Dataparam_ c;

    p.top <=> port;
    c.port <=> p.bottom;
  }
}