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.
   #


   set hash2num [computeRevnums {}]
   set dim [dict size $hash2num]

   #revert the above dictonary in order to get the mapping from numbers to 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
   }

   set parstring [concat $params]




   # first introduce a blank between `-r' and revnum in case it was forgotten...



   set rgxrevnum {[[:digit:]]+(:[[:digit:]]+)?}
   regsub "\\-r($rgxrevnum)" $parstring {-r \1} parstring










   #extract the full match of the `df' command as well as the revnums
   set rgx {df[ ]+\-r[ ]+([[:digit:]]+(:[[:digit:]]+)?)}
   regexp $rgx $parstring fullmatch numbers











   set revs [split $numbers :]
   set fromto [list from to]



   set to {}
   set cnt 0
   
   #translate to sha1 hashes and prepend with correct `diff' options

   foreach rev $revs {
      set which [lindex $fromto $cnt] 


      set $which " --$which [dict get $num2hash $rev]"
      incr cnt
   } 
   #we use `di' instead of `diff' since only the former triggers the `diff' filter

   set replace "di $from$to"
   regsub $fullmatch $parstring $replace parstring


   #create the modified `params' list
   regsub -all {[[:blank:]]+} $parstring " " parstring
   set params [split $parstring]






   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.

    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.