Fossil Wrapper

    puts "Currently defined expansions:"
    dict for {alias expansion} $config::aliases {
        puts [format "%10s -> %s" $alias $expansion]
    }
}

interceptor df {
   # ----------------------------------------------------------------------
   # a first stab at getting relative revision numbers working with `diff'.
   # should be called as `fsl df -r n' or `fsl df -r n:m' where `n, m' are
   # counting from 0 (initial checkin). This call which is 
   # be mapped to 
   #
   # fsl di -r sha1_n --to sha1_m
   #
   # where `sha1_n, sha1_m' are the sha1 hashes of the respective checkins.
   # further arguments to `diff' are passed through unmodified (hopefully).
   # ----------------------------------------------------------------------
   set hash2num [computeRevnums {}]
   set dim [dict size $hash2num]

   # exchange keys and values in the above dictonary sha1. at the same time,
   # strip the square brackets around the hash value:
   dict for {key val} $hash2num {
      regexp {[[:alnum:]]+} $key sha1
      dict set num2hash [expr {$dim - $val}] $sha1
   }

   # modification of the `params' list is performed in place and step by
   # step. we use `di' instead of `diff' since only the former triggers the
   # `diff' filter:
   set params [lreplace $params  0 0 di]

   # extract the revison number information from `params'. the case where the
   # blank between `-r' and `n:m' is ommitted is handled, too:
   set cnt 0
   set rgxrevnum {[[:digit:]]+(:[[:digit:]]+)?}
   foreach word $params {
      set rgx {^\-r} 
      if {[regexp $rgx $word]} {
         set flagpos $cnt
         set rgx $rgx$rgxrevnum
         if {[regexp $rgx $word]} {
            set noblank 1 
         } else {set noblank 0}
         break
      }

      incr cnt
   }
   if {$noblank} {
      set dum [lindex $params $flagpos]
      set numbers [string trimleft $dum -r]
   } else {
      set idx [expr $flagpos + 1]
      set numbers [lindex $params $idx] 
      # remove the `numbers' field from `params':
      set params [lreplace $params $idx $idx]
   }
   set revs [split $numbers :]

   # translate rev. numbers to sha1 hashes and construct the 
   # required `diff' arguments:
   set to {}
   set cnt 0
   set fromto [list from to]

   foreach rev $revs {
      set which [lindex $fromto $cnt] 
      # this evals in turn to define variables `from' and `to', respectively,
      # which contain the respective `diff' arguments.
      set $which " --$which [dict get $num2hash $rev]"
      incr cnt
   } 

   # insert the canonical `diff' arguments/options into the `params' list
   # after `-r' (whose position is given by `flagpos') and finally remove the
   # `-r'.

   set cnt 1
   foreach word $from$to {
      set idx [expr $flagpos + $cnt]
      set params [linsert $params $idx $word]
      incr cnt
   }


   set params [lreplace $params $flagpos $flagpos]

   puts "executing `fossil $params'"
   return $params
}

proc unwrapTimeline records {
#-----------------------------------------------------------------------
# unwrap `fossil timeline' output, putting each checkin on a single
# line. expected input: currently, a list of \n terminated lines.