Fossil Wrapper

# further `diff' arguments.
# This call is mapped to
#
# fsl (g)di ... -r sha1_n (--to sha1_m) ...
#
# where `sha1_n, sha1_m' are the sha1 hashes of the respective checkins.
# ------------------------------------------------------------------------
   # map this interceptor command to `fossil (g)diff'. actually, we use `di'
   # instead of `diff' since only the former will trigger the `diff' filter:
   regsub {^(g?d)f} $params {\1i} params

   # extract the revison number information from `params'. contrary to
   # `fossil' it is acceptable to omit blanks between `-r' and `n:m':
   set rgx { \-r[[:blank:]]*}
   set rgxrevnum {[[:digit:]]+(:[[:digit:]]+)?}
   set rgx $rgx$rgxrevnum

   # without `-r' argument we can return already:
   if {![regexp $rgx $params revarg]} {return $params}

   set hash2num [computeRevnums {}]

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

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

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


   #replace `-r n:m' by the constructed `diff' arguments: 
   regsub $revarg $params $from$to params
   return $params
}

proc intercept {params} {
    set command [first $params]
    if {[interceptor? $command]} {

# further `diff' arguments.
# This call is mapped to
#
# fsl (g)di ... -r sha1_n (--to sha1_m) ...
#
# where `sha1_n, sha1_m' are the sha1 hashes of the respective checkins.
# ------------------------------------------------------------------------
   # map this interceptor command to `fossil (g)di'. we use `di' instead of
   # `diff' since only the former will trigger the `diff' filter:
   regsub {^(g?d)f} $params {\1i} params

   # extract the revison number information from `params'. contrary to
   # `fossil' it is acceptable to omit blanks between `-r' and `n:m':
   set rgxopt    { \-r[[:blank:]]*}
   set rgxrevnum {[[:digit:]]+(:[[:digit:]]+)?}
   append rgxopt $rgxrevnum

   # without `-r' argument we can return already:
   if {![regexp $rgxopt $params revarg]} {return $params}

   set hash2num [computeRevnums {}]

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

   # translate rev. numbers to sha1 hashes and construct the 
   # required `diff' arguments:
   regexp $rgxrevnum $revarg numbers
   set revs   [split $numbers :]

   set cnt    0
   set fromto [list --from --to]
   set ftopt  { }
   foreach rev $revs {
      append ftopt [lindex $fromto $cnt] 


      append ftopt " [dict get $num2hash $rev] "
      incr cnt
   } 
   set ftopt [string trimright $ftopt]

   #replace `-r n:m' by the constructed `diff' arguments: 
   regsub $revarg $params $ftopt params
   return $params
}

proc intercept {params} {
    set command [first $params]
    if {[interceptor? $command]} {