// -*- C++ -*-
 
 

#define N 10

generic main()
{
  stream long A1;
  stream long A2;

  stream long[N] B1;
  stream long[N] B2;

  stream long C1;
  stream long C2;

  stream bool D1;
  stream bool D2;
  
  genera1   (                    output_stream A1);
  genera2   (                    output_stream A2);
  p1        (input_stream A1     output_stream B1);
  p2        (input_stream A2     output_stream B2);
  cross     (input_stream B1,B2  output_stream C1,C2);
  p3        (input_stream C1     output_stream D1);
  p4        (input_stream C2     output_stream D2);
  fine      (input_stream D1,D2);
} 
 

genera1(output_stream long A1) {
  fgen1(output_stream A1);
}


proc fgen1(output_stream long A1)
 
inc<"iostream">
$c++{
  long a;
  
  // start message for regression test
  std::cerr << "STARTING genera1" << std::endl;

  for (int i=0;i<N;i++) {
    a = i;
    assist_out(A1, a);
  };
}c++$


genera2(output_stream long A2) {
  fgen2(output_stream A2);
}


proc fgen2(output_stream long A2)
 
inc<"iostream">
$c++{
  long a;

  // start message for regression test
  std::cerr << "STARTING genera2" << std::endl;

  for (int i=0;i<N;i++) {
    a = 1 + i;
    assist_out(A2,a);
  }
}c++$


parmod p1 (input_stream long A1 output_stream long B1[N]) {
  topology none Pv;
  
  do input_section {  
    guard1: on , , A1 {
      distribution A1 on_demand to Pv;
    }
  } while (true)
    
  virtual_processors {
    elab (in guard1 out B1) {
      VP {
	f_p1 (in A1 output_stream B1);
      }
    }
  }
   
  output_section {
    collects B1 from ANY Pv;
  } 
}


parmod p2 (input_stream long A2 output_stream long B2[N]) 
{
  topology none Pv;
  
  do input_section {
    guard1: on , , A2 {
      distribution A2 on_demand to Pv;
    }
  } while (true==true)
  
  virtual_processors {
    elab (in guard1 out B2) {
      VP {
	f_p2 (in A2 output_stream B2);
      }
    }
  }
 
  output_section {
    collects B2 from ANY Pv;
  } 
}


cross(input_stream long B1[N], long B2[N] output_stream long C1, long C2) {
  fcross (in B1,B2 output_stream C1,C2);
}


proc fcross(in long B1[N], long B2[N] output_stream long C1, long C2) 
 
inc<"iostream">
$c++{
  long c1 = 0;
  long c2 = 0;

  for (int i=0;i<N;i++) {
    c1 = c1 + B1[i];
    c2 = c2 + B2[i];
  }
  assist_out(C1,c1);
  assist_out(C2,c2);
}c++$


parmod p3 (input_stream long C1 output_stream bool D1) 
{
  topology none Pv;
  
  do input_section {
    guard1: on , , C1 {
      distribution C1 on_demand to Pv;
    }
  } while (true)
  
  virtual_processors {
    elab (in guard1 out D1) {
      VP {
	f_p3 (in C1 output_stream D1);
      }
    }
  }
 
  output_section {
    collects D1 from ANY Pv;
  } 
}


parmod p4 (input_stream long C2 output_stream bool D2) 
{
  topology none Pv;
  
  do input_section {
    guard1: on , , C2 {
      distribution C2 on_demand to Pv;
    }
  } while (true)
  
  virtual_processors {
    elab (in guard1 out D2) {
      VP {
	f_p4 (in C2 output_stream D2);
      }
    }
  }
 
  output_section {
    collects D2 from ANY Pv;
  } 
}


fine(input_stream bool D1,bool D2)
 
inc<"iostream">
$c++{
  static int count;
  static int ok = 0;

  if ((D1 != true) || (D2 !=false)) ok = -1;
  count++;

  if (count >= N) {
    // termination message for regression test
    if (ok==0) 
      std::cerr << "ENDING with SUCCESS grafo.ast" << std::endl;
    else 
      std::cerr << "ENDING with FAILURE grafo.ast" << std::endl;
  }
}c++$


proc f_p1(in long A1 output_stream long B1[N])
 
inc<"iostream">
$c++{
  long b[N];

  b[0] = A1;
  for (int i=1;i<N;i++)
    b[i] = b[i-1] + A1;

  assist_out(B1, b);
}c++$


proc f_p2(in long A2 output_stream long B2[N])
 
inc<"iostream">
$c++{
  long b[N];

  b[0] = A2;
  for (int i=1;i<N;i++)
    b[i] = b[i-1] + A2;

  assist_out(B2, b);
}c++$


proc f_p3(in long C1 output_stream bool D1)
 
inc<"iostream">
$c++{
  bool d1 = true;
  assist_out(D1,d1);
}c++$


proc f_p4(in long C2 output_stream bool D2)
 
inc<"iostream">
$c++{
  bool d2 = false;
  assist_out(D2,d2);
}c++$