--* From postmaster%watson.vnet.ibm.com@yktvmv.watson.ibm.com  Tue Aug 10 13:52:09 1993
--* Received: from yktvmv2.watson.ibm.com by radical.watson.ibm.com (AIX 3.2/UCB 5.64/900524)
--*           id AA13198; Tue, 10 Aug 1993 13:52:09 -0400
--* X-External-Networks: yes
--* Received: from watson.vnet.ibm.com by yktvmv.watson.ibm.com (IBM VM SMTP V2R3)
--*    with BSMTP id 2063; Tue, 10 Aug 93 13:53:30 EDT
--* Received: from YKTVMV by watson.vnet.ibm.com with "VAGENT.V1.0"
--*           id <A.EDWARDS.NOTE.YKTVMV.7547.Aug.10.13:53:28.-0400>
--*           for asbugs@watson; Tue, 10 Aug 93 13:53:29 -0400
--* Received: from ibm8.scri.fsu.edu by watson.ibm.com (IBM VM SMTP V2R3) with TCP;
--*    Tue, 10 Aug 93 13:53:28 EDT
--* Received: by ibm8.scri.fsu.edu id AA13367
--*   (5.65c/IDA-1.4.4 for asbugs@watson.ibm.com); Tue, 10 Aug 1993 13:53:22 -0400
--* Date: Tue, 10 Aug 1993 13:53:22 -0400
--* From: Robert Edwards <edwards@ibm8.scri.fsu.edu>
--* Message-Id: <199308101753.AA13367@ibm8.scri.fsu.edu>
--* To: asbugs@watson.ibm.com
--* Subject: Bug: sstNext:  too many simultaneous traversals [bug10.as][A# version 29.5 for AIX RS/6000 (debug version)]

--@ Fixed  by: SMW Sat Oct 09 14:47:08 1993
--@ Tested by: reclist0.as
--@ Summary:   Rewrote sefo marking scheme.

--+ % asharp -rv bug10.as
--+ A# version 29.5 for AIX RS/6000 (debug version)
--+ Bug: sstNext:  too many simultaneous traversals
#include "aslib.as"

macro SI == SingleInteger

RegularExpression(Char: BasicType): Category == BasicType with

    coerce: Char -> %
    seq: Tuple % -> %
    alt: Tuple % -> %
    rpt: % -> %
--  next: (%, Char) -> %
    nextaa: (%, Char) -> %

RegExp: RegularExpression(String) == add

    macro State == SI
    macro Link == Record(char: String, next: State)
    macro Node == List Link
    macro Rep == Record(start: State, stop: State)

    import
      String
      Link
      Node
      Rep

    print("Creating domain RegExp")()

    macro maxNodes == 100
    macro void == "~"

    local table: Array Node == new(maxNodes, nil)
    local freeState: SI := 1

    addNode(n: Node): State ==
      free freeState := freeState + 1
      freeState > maxNodes => error("Too many nodes!")
      table.freeState := n
      freeState

    coerce(nextChar: String): % ==
      local end: State == addNode(nil)
      per [addNode(list [nextChar, end]), end]

    seq(t: Tuple %): % ==
      local begin: State := addNode(nil)
      local prev: State := begin
      for r: % in t repeat
        table.prev := list [void, (rep r).start]
        prev := (rep r).stop
      per [begin, prev]

    alt(t: Tuple %): % ==
      local begin: State := addNode(nil)
      local end: State := addNode(nil)
      for r: % in t repeat
        table.begin := cons( [void, (rep r).start], table.begin )
        table((rep r).stop) := list [void, end]
      per [begin, end]

    rpt(r: %): % ==
      local begin: State := (rep r).start
      local end: State := addNode(nil)
      table((rep r).stop) := list( [void, end], [void, begin] )
      per [begin, end]

    apply(p: Outport, r: %): Outport ==
      p("RegExp[")((rep r))("]")

print("Constructing RegExp...")()

r : RegExp == seq(coerce("a")@RegExp, coerce("b")@RegExp)

print("Printing RegExp...")()

print(r)()

print("Successfully finished!")()