-- version control marker $Id: cgtest02.occ,v 1.4 1995/10/10 12:59:36 djb1 Exp $
-- SEQ, PAR  with no replications

PROC cgtest2 (CHAN OF BYTE keyb, scr, err)

  #INCLUDE "cgmain.occ"

  --{{{  SEQ
  --{{{  S1
  PROC S1 ()
    INT X:
    BYTE Y:
    BOOL Z:
    SEQ
      X := 67
      SEQ
        Y := 'y'
        SEQ
          Z := TRUE
          SEQ
            SEQ
              SEQ
                Z := FALSE
                --{{{
                SEQ
                  SEQ
                    SEQ
                      SEQ
                        X := 42
                        check(X, 42, "S1")
                        check(INT Y, INT 'y', "S2")
                        check(INT Z, INT FALSE, "S3")
                --}}}
  :
  --}}}
  --{{{  S2
  PROC S2 ()
    INT X:
    BYTE Y:
    BOOL Z:
    SEQ
      X := 0
      Y := 'Y'
      Z := TRUE
      SEQ
        SEQ
          --{{{
          INT Z:
          BYTE X:
          BOOL Y:
          SEQ
            X := '1'
            Y := FALSE
            Z := 42
            check( Z, 42, "S4")
            check( INT Y, INT FALSE, "S5")
            check( INT X, INT '1', "S6")
          --}}}
          check( X, 0, "S7")
          check(INT Y, INT 'Y', "S8")
          check(INT Z, INT TRUE, "S9")
  :
  --}}}
  --}}}
  --{{{  PAR
  INT N1, N2:
  
  --{{{  P1
  PROC P1 ()
    INT X :
    BYTE Y:
    SEQ
      PAR
        X := 0
        Y := '1'
      check( X, 0, "P1")
      check( INT Y, INT '1', "P2")
  :
  --}}}
  --{{{  P2
  PROC P2 ()
    INT X, Y, Z:
    SEQ
      PAR
        X := 0
        PAR
          Y := 1
          Z := 2
      check( X, 0, "P3")
      check( Y, 1, "P4")
      check( Z, 2, "P5")
  :
  --}}}
  --{{{  P3
  PROC P3 ()
    INT X:
    BOOL Y:
    BYTE Z:
    SEQ
      PAR
        PAR
          X := 0
        PAR
          PAR
            Y := TRUE
          SEQ
            Z := '2'
      check( X, 0, "P6")
      check(INT Y,INT TRUE, "P7")
      check(INT Z,INT '2', "P8")
  :
  --}}}
  --{{{  P4
  PROC P4 ()
    INT X:
    BYTE Y:
    BOOL Z:
    SEQ
      PAR
        X := 0
        Y := '1'
        Z := FALSE
        --{{{
        INT X, Y:
        SEQ
          PAR
            X := 3
            Y := 4
          PAR
            SEQ
              check( X, 3, "P9")
              check( Y, 4, "P10")
            SEQ
        --}}}
      check( X, 0, "P11")
      check(INT Y, INT '1', "P12")
      check(INT Z, INT FALSE, "P13")
  :
  --}}}
  --{{{  P5
  PROC P5 ()
    INT X, Y, Z:
    SEQ
      N1 := 0
      N2 := 1
      X := 2
      Y := 3
      Z := 4
      --{{{
      INT X:
      BYTE Y, Z:
      SEQ
        PAR
          SEQ
            check( N1, 0, "P14")
            check( N2, 1, "P15")
          SEQ
            X := 5
            Y := '6'
            Z := '7'
        check( X, 5, "P16")
        check(INT Y,INT '6', "P17")
        check(INT Z,INT '7', "P18")
      --}}}
      PAR
        SEQ
        SEQ
          check( X, 2, "P19")
          check( Y, 3, "P20")
          check( Z, 4, "P21")
  :
  --}}}
  --{{{  P6
  PROC P6 ()
    INT X:
    BYTE Y:
    SEQ
      PAR
        SEQ
          N1 := 0
          N2 := 65
          PROC P7 (VAL INT X, Y)
            SEQ
              check( X, N1, "P22")
              check(INT Y, N2, "P23")
          :
          P7 (N1, N2)
        PAR
          X := 0
          Y := BYTE 65
      check( X, 0, "P24")
      check(INT Y, 65, "P25")
  :
  --}}}
  --{{{  P7
  PROC P7 ()
    INT X:
    BYTE Y:
    SEQ
      PAR
        --{{{
        SEQ
          N1 := 0
          N2 := 1
          PROC P7 (INT X, Y)
            SEQ
              check( X, N1, "P26" )
              check( Y, N2, "P27")
              check( X, 0, "P28")
              check( Y, 1, "P29")
              X := 2
              Y := 3
              check( X, 2, "P30")
              check( Y, 3, "P31")
          :
          --P7( N1, N2)
          INT NN1, NN2 :
          SEQ
            NN1, NN2 := N1, N2
            P7(NN1, NN2)
            check (NN1, 2, "P32")
            check (NN2, 3, "P33")
        --}}}
        PAR
          X := 0
          Y := 'q'
      check( X, 0, "P34")
      check(INT Y,INT 'q', "P35")
  :
  --}}}
  --{{{  P8    (tests P36 to P38)
  PROC P8 ()
    INT a:      -- test that m.link is working ok
    BYTE b:
    BOOL c:
    [3] BOOL result:
    --{{{  PROC P8.check ( VAL INT is, VAL INT should.be, BOOL result)
    PROC P8.check (VAL INT is, VAL INT should.be, BOOL result)
      result := is = should.be
    :
    --}}}
    --{{{  PROC A1
    PROC A1 ()
      a := 42
    :
    --}}}
    --{{{  PROC A2
    PROC A2 ()
      b := 'b'
    :
    --}}}
    --{{{  PROC A3
    PROC A3 ()
      c := TRUE
    :
    --}}}
    SEQ
      PAR
        A1 ()
        A2 ()
        A3 ()
      PAR
        P8.check (a, 42, result[0])
        P8.check (INT b, INT 'b', result[1])
        P8.check (INT c, INT TRUE, result[2])
      SEQ
        check (INT result[0], INT TRUE, "P36")
        check (INT result[1], INT TRUE, "P37")
        check (INT result[2], INT TRUE, "P38")
  :
  --}}}
  --{{{  P9
  PROC P9 ()  -- test reading shared variables
    INT x, y, z, x2, y2, z2 :
    BOOL b, c :
    SEQ
      x := 15
      y := 13
      z := 42
      b := TRUE
      c := FALSE
      --{{{  P39 to P41
      PAR
        x2 := x
        y2 := y
        z2 := z
      check (x2, 15, "P39")
      check (y2, 13, "P40")
      check (z2, 42, "P41")
      --}}}
      --{{{  P42 to P44
      PAR
        IF
          b
            x2 := y
          TRUE
            SKIP
        IF
          c
            y2 := x
          TRUE
            z2 := x
      check (x2, 13, "P42")
      check (y2, 13, "P43")
      check (z2, 15, "P44")
      --}}}
  :
  --}}}
  #IF NOT DEFINED (COMPILER.TOCK)
  --{{{  P10   (tests P45 to P49)  chan ? len ; [b FROM 0 FOR len]
  PROC P10 ()
    INT x :
    SEQ
      CHAN OF ANY c :
      PAR
        c ! 9 ; "123456789"
  
        [10]BYTE b :
        INT len :
        SEQ
          len := 99
          c ? len ; [b FROM 0 FOR len]
          x := len
  
      check (x, 9, "P45")
  :
  --}}}
  --{{{  COMMENT P10a  (tests P45 to P49)  chan ? len ; [b FROM 0 FOR len]
  --PROC P10a ()
    --INT x :
    --SEQ
      --PROTOCOL any IS ANY :
      --CHAN OF any c :
      --PAR
        --SEQ
          --c ! 9
          --c ! "123456789"
  --
        --[10]BYTE b :
        --INT len :
        --SEQ
          --len := 99
          --c ? len
          --c ? [b FROM 0 FOR len]
          --x := len
  --
      --check (x, 9, "P45a")
  --:
  --}}}
  #ENDIF
  --}}}
  INT key :
  SEQ
    init ("CG test 2", "Testing SEQ and PAR")

    --{{{  SEQ
    title("Testing SEQ")
    --{{{  S1 to S2
    S1 ()
    S2 ()
    --}}}
    --}}}
    --{{{  PAR
    title("Testing PAR")
    P1 ()
    P2 ()
    P3 ()
    P4 ()
    P5 ()
    P6 ()
    P7 ()
    P8 ()
    P9 ()
    #IF NOT DEFINED (COMPILER.TOCK)
    P10 ()
    -- P10a ()
    #ENDIF
    --}}}
    finish ()
:
