Jacques Klein's Tcl Page

Core mods:
(For those looking at the source, the keyword to grep/search for is CNT_ENABLED).
The Interp struct has been extended with a few pointers to Cnt structs.
These structures are used to track the evolution of the C calling stack and to manage a tree of stack frames which will be most of the "Continuation Objects".
Continuation Objects are explicitely created, used and destroyed (Tcl vars).
"Continuation resuming" is done by recalling the C functions to recreate call stack and local variables.
To achieve this, the full bunch of functions having to do with code evaluation has been modified sligtly.

Extension:
I took the source code of the "dict 8.4 back-implementation" as starting point, I am not confident enough with the "Tcl Extension" package structure to do it from scratch.
Remark: I didn't yet try to understand the "stub" stuf, and didn't really take care of the "obj internalRep" stuf...

For now, the API is:
made of a namespace called ::cnt with following procs:

      init                  initialize (enable) the cnt context.
      reset                 reset the cnt context (forget all cnt objects).
      dbglevel              set tracing level for debug purpose.
      disabled              eval script with cnt disabled (for speedup).
      loaderstorer          set the loaderstore for persistence.

      new                   create a cnt object (variable).
      update                update a cnt object (store current execution state in it).
      resume                resume execution at a cnt ('s last update state).

      current               create a cnt object and update it (wrapper around new/update).
      goto                  goto a cnt (wrappper around resume).

there are also some sub-namespaces implementing "higher-level" concepts, like:
::cnt::cons (consumer)

      new                   create a consumer object.
      put                   put something into the cons (called by producer).
      get                   get something from cons (called by the consumer).

::cnt::gene (generator)

      new:                  create a generator object.
      get:                  get next value from gene.
      yield:                return value to get caller (resuming at next command when called again).

and a sub-namespace ::cnt:dls (default loaderstorer) implementing "persistency":

      save_frames_and_cnts  save frames and cnt objects.
      save_namespace        save namespace.
      run_file              reload and run a (previously saved) script.

Tcl api:
No "doc" yet, just some examples of usage.
setting the cnt context

  package require Cnt

  ::cnt::init

using the lowest-level procs script.

  # do something like: set k 3; while 1 {puts "k=$k"; if !$k break; incr k -1}

  # create the cnt object
  set cnt [::cnt::new]

  # update it with the current context/continuation (the cc), return value 3
  set k [cnt::update $cnt 3]

  puts "k=$k"

  # maybe resume it, with a new value
  if $k {cnt::resume $cnt [expr $k-1]}

  puts done

the goto example (syntaxic sugar) script.

  # do something like: set k -2; while 1 {puts "k=$k"; incr k; if !$k break}

  set k -2

  # create and update a cnt object
  set label [::cnt::current]

  puts "k=$k"
  incr k

  # maybe goto
  if $k [::cnt::goto $label]

  puts done

the producer/consumer example script.

  # define the consumer proc (a standard function, no state machine)
  proc consume {a b c} {
    while 1 {
      set v [::cnt::cons::get]
      # work with $v
      puts "consuming v=$v"
      # ...
    }
  }

  # create the consumer object
  set cntc [::cnt::cons::new consume "a" "b" "c"]

  # produce ... call consumer
  for {set i 0} {$i < 30} {incr i} {
    # work
    # ...
    # call consume
    ::cnt::cons::put $cntc $i
  }

  # delete the consumer object
  unset cntc

  puts "consumer done"

the generator example script.

  # define the generator proc (standard proc, no state machine)
  proc generate {b s} {
    set i $b
    while 1 {
      ::cnt::gene::yield $i
      incr i $s
    }
  }

  # create the generator object
  set cntg [::cnt::gene::new generate 1 2]

  # use it.
  while 1 {
    set v [::cnt::gene::get $cntg]
    if {$v > 20} break
    puts "got v=$v"
  }

  # delete it
  unset cntg

saving/restoring the interp context script.

  #define the loader-storer package
  ::cnt::loaderstorer ::cnt::dls

  # define the saving proc
  proc save {filename cnt rval} {
    ::cnt::disabled {
      ::cnt::dls::save_frames_and_cnts $cnt -rval $rval frames cnts restart
      puts stderr "save: dumping to $filename"
      set f [open $filename w]
      puts $f "# -*- mode: tcl -*-\n"
      puts $f "package require Cnt\n\n[::cnt::dls::save_namespace {}]"
      puts $f "\# frames\n\n::cnt::init disabled\n::cnt::loaderstorer ::cnt::dls\n\n$frames"
      puts $f "\# cnts\n\n$cnts\n\# restart\n\n$restart\n\# end"
      close $f
    }
  }

  # create a cnt object
  set cnt [::cnt::new]

  # update it
  set what [::cnt::update $cnt "save"]

  puts "$what"

  set filename /tmp/x.cnt
  if {$what == "save"} {
    # save, setting the restart cnt and value
    if [catch {save $filename $cnt "restarted"} err] {
      puts stderr "save: $err"
      exit 1
    }
  }

  set n 4
  puts "reloading/restarting in $n secs"
  exec sleep $n

  ::cnt::dls::run_file $filename

Missing/Todo:
Debug...., optimize....
Define an API for co-routines and implement it.
Same for cooperative "userland threads" and scheduler.
..............

Jacques Klein's Tcl Page

Project: Tcl Continuations

My objectives, ordered by importance:

Prototype impl.

Downloads.

How-To-Make the 8.4.14 version (well, how I made it).