Fossil SCM

Created convenience methods to create the human readable repesentation of a changeset and lists of such, and made liberal use of them.

aku 2007-11-24 05:31 trunk
Commit 87cf60902113c7564a2ae43de7ede9e83d23af1c
Parent 184c56327e6bd64…
5 files changed +9 -11 +11 -2 +2 -2 +10 -2 +1 -1
~ tools/cvs2fossil/lib/c2f_cyclebreaker.tcl ~ tools/cvs2fossil/lib/c2f_pbreakacycle.tcl ~ tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl ~ tools/cvs2fossil/lib/c2f_prev.tcl ~ tools/cvs2fossil/lib/c2f_prevlink.tcl
M tools/cvs2fossil/lib/c2f_cyclebreaker.tcl
+9 -11
--- tools/cvs2fossil/lib/c2f_cyclebreaker.tcl
+++ tools/cvs2fossil/lib/c2f_cyclebreaker.tcl
@@ -153,11 +153,11 @@
153153
 set dg [struct::graph dg]
154154
155155
 foreach cset $changesets {
156156
 $dg node insert $cset
157157
 $dg node set $cset timerange [$cset timerange]
158
- $dg node set $cset label [ID $cset]
158
+ $dg node set $cset label [$cset str]
159159
 $dg node set $cset __id__ [$cset id]
160160
 }
161161
162162
 # 2. Find for all relevant changeset their revisions and their
163163
 # dependencies. Map the latter back to changesets and
@@ -182,17 +182,17 @@
182182
 # breaking the relevant changesets apart. So having
183183
 # one indicates big trouble in pass 5. We report them
184184
 # and dump internal structures to make it easier to
185185
 # trace the links causing the problem.
186186
 if {$succ eq $cset} {
187
- trouble fatal "Self-referencing changeset <[$cset id]>"
188
- log write 2 cyclebreaker "LOOP changeset <[$cset id]> __________________"
187
+ trouble fatal "Self-referencing changeset [$cset str]"
188
+ log write 2 cyclebreaker "LOOP changeset [$cset str] __________________"
189189
 array set nmap [$cset nextmap]
190190
 foreach r [lsort -dict [array names nmap]] {
191191
 foreach succrev $nmap($r) {
192192
 log write 2 cyclebreaker \
193
- "LOOP * rev <$r> --> rev <$succrev> --> cs [join [struct::list map [project::rev ofrev $succrev] [myproc ID]] { }]"
193
+ "LOOP * rev <$r> --> rev <$succrev> --> cs [project::rev strlist [project::rev ofrev $succrev]]"
194194
 }
195195
 }
196196
 }
197197
 }
198198
 }
@@ -262,11 +262,11 @@
262262
 log write 10 cyclebreaker \
263263
 "Pending: [struct::list map $mybottom [myproc FormatPendingItem]]"
264264
 return
265265
 }
266266
267
- proc FormatPendingItem {item} { lreplace $item 0 0 <[[lindex $item 0] id]> }
267
+ proc FormatPendingItem {item} { lreplace $item 0 0 [[lindex $item 0] str] }
268268
269269
 proc FindCycle {dg} {
270270
 # This procedure is run if and only the graph is not empty and
271271
 # all nodes have predecessors. This means that each node is
272272
 # either part of a cycle or (indirectly) depending on a node
@@ -298,20 +298,18 @@
298298
 }
299299
300300
 return [struct::list reverse [lrange $path $seen($start) end]]
301301
 }
302302
303
- proc ID {cset} { return "<[$cset id]>" }
304
-
305303
 proc BreakCycle {dg cycle} {
306304
 # The cycle we have gotten is broken by breaking apart one or
307305
 # more of the changesets in the cycle. This causes us to
308306
 # create one or more changesets which are to be committed,
309307
 # added to the graph, etc. pp.
310308
311309
 # NOTE/TODO. Move this map operation to project::rev, as typemethod.
312
- set cprint [join [struct::list map $cycle [myproc ID]] { }]
310
+ set cprint [project::rev strlist $cycle]
313311
314312
 lappend cycle [lindex $cycle 0] [lindex $cycle 1]
315313
 set bestlink {}
316314
 set bestnode {}
317315
@@ -336,11 +334,11 @@
336334
 } else {
337335
 $link destroy
338336
 }
339337
 }
340338
341
- log write 5 cyclebreaker "Breaking cycle ($cprint) by splitting changeset <[$bestnode id]>"
339
+ log write 5 cyclebreaker "Breaking cycle ($cprint) by splitting changeset [$bestnode str]"
342340
 set ID [$bestnode id]
343341
 Mark $dg -${ID}-before
344342
345343
 set newcsets [$bestlink break]
346344
 $bestlink destroy
@@ -388,11 +386,11 @@
388386
 $dg node delete $n
389387
390388
 foreach cset $replacements {
391389
 $dg node insert $cset
392390
 $dg node set $cset timerange [$cset timerange]
393
- $dg node set $cset label [ID $cset]
391
+ $dg node set $cset label [$cset str]
394392
 $dg node set $cset __id__ [$cset id]
395393
 }
396394
397395
 foreach cset $replacements {
398396
 foreach succ [$cset successors] {
@@ -399,11 +397,11 @@
399397
 # The new changesets may have dependencies outside of
400398
 # the chosen set. These are ignored
401399
 if {![$dg node exists $succ]} continue
402400
 $dg arc insert $cset $succ
403401
 if {$succ eq $cset} {
404
- trouble internal "Self-referencing changeset <[$cset id]>"
402
+ trouble internal "Self-referencing changeset [$cset str]"
405403
 }
406404
 }
407405
 }
408406
 foreach cset $pre {
409407
 foreach succ [$cset successors] {
410408
--- tools/cvs2fossil/lib/c2f_cyclebreaker.tcl
+++ tools/cvs2fossil/lib/c2f_cyclebreaker.tcl
@@ -153,11 +153,11 @@
153 set dg [struct::graph dg]
154
155 foreach cset $changesets {
156 $dg node insert $cset
157 $dg node set $cset timerange [$cset timerange]
158 $dg node set $cset label [ID $cset]
159 $dg node set $cset __id__ [$cset id]
160 }
161
162 # 2. Find for all relevant changeset their revisions and their
163 # dependencies. Map the latter back to changesets and
@@ -182,17 +182,17 @@
182 # breaking the relevant changesets apart. So having
183 # one indicates big trouble in pass 5. We report them
184 # and dump internal structures to make it easier to
185 # trace the links causing the problem.
186 if {$succ eq $cset} {
187 trouble fatal "Self-referencing changeset <[$cset id]>"
188 log write 2 cyclebreaker "LOOP changeset <[$cset id]> __________________"
189 array set nmap [$cset nextmap]
190 foreach r [lsort -dict [array names nmap]] {
191 foreach succrev $nmap($r) {
192 log write 2 cyclebreaker \
193 "LOOP * rev <$r> --> rev <$succrev> --> cs [join [struct::list map [project::rev ofrev $succrev] [myproc ID]] { }]"
194 }
195 }
196 }
197 }
198 }
@@ -262,11 +262,11 @@
262 log write 10 cyclebreaker \
263 "Pending: [struct::list map $mybottom [myproc FormatPendingItem]]"
264 return
265 }
266
267 proc FormatPendingItem {item} { lreplace $item 0 0 <[[lindex $item 0] id]> }
268
269 proc FindCycle {dg} {
270 # This procedure is run if and only the graph is not empty and
271 # all nodes have predecessors. This means that each node is
272 # either part of a cycle or (indirectly) depending on a node
@@ -298,20 +298,18 @@
298 }
299
300 return [struct::list reverse [lrange $path $seen($start) end]]
301 }
302
303 proc ID {cset} { return "<[$cset id]>" }
304
305 proc BreakCycle {dg cycle} {
306 # The cycle we have gotten is broken by breaking apart one or
307 # more of the changesets in the cycle. This causes us to
308 # create one or more changesets which are to be committed,
309 # added to the graph, etc. pp.
310
311 # NOTE/TODO. Move this map operation to project::rev, as typemethod.
312 set cprint [join [struct::list map $cycle [myproc ID]] { }]
313
314 lappend cycle [lindex $cycle 0] [lindex $cycle 1]
315 set bestlink {}
316 set bestnode {}
317
@@ -336,11 +334,11 @@
336 } else {
337 $link destroy
338 }
339 }
340
341 log write 5 cyclebreaker "Breaking cycle ($cprint) by splitting changeset <[$bestnode id]>"
342 set ID [$bestnode id]
343 Mark $dg -${ID}-before
344
345 set newcsets [$bestlink break]
346 $bestlink destroy
@@ -388,11 +386,11 @@
388 $dg node delete $n
389
390 foreach cset $replacements {
391 $dg node insert $cset
392 $dg node set $cset timerange [$cset timerange]
393 $dg node set $cset label [ID $cset]
394 $dg node set $cset __id__ [$cset id]
395 }
396
397 foreach cset $replacements {
398 foreach succ [$cset successors] {
@@ -399,11 +397,11 @@
399 # The new changesets may have dependencies outside of
400 # the chosen set. These are ignored
401 if {![$dg node exists $succ]} continue
402 $dg arc insert $cset $succ
403 if {$succ eq $cset} {
404 trouble internal "Self-referencing changeset <[$cset id]>"
405 }
406 }
407 }
408 foreach cset $pre {
409 foreach succ [$cset successors] {
410
--- tools/cvs2fossil/lib/c2f_cyclebreaker.tcl
+++ tools/cvs2fossil/lib/c2f_cyclebreaker.tcl
@@ -153,11 +153,11 @@
153 set dg [struct::graph dg]
154
155 foreach cset $changesets {
156 $dg node insert $cset
157 $dg node set $cset timerange [$cset timerange]
158 $dg node set $cset label [$cset str]
159 $dg node set $cset __id__ [$cset id]
160 }
161
162 # 2. Find for all relevant changeset their revisions and their
163 # dependencies. Map the latter back to changesets and
@@ -182,17 +182,17 @@
182 # breaking the relevant changesets apart. So having
183 # one indicates big trouble in pass 5. We report them
184 # and dump internal structures to make it easier to
185 # trace the links causing the problem.
186 if {$succ eq $cset} {
187 trouble fatal "Self-referencing changeset [$cset str]"
188 log write 2 cyclebreaker "LOOP changeset [$cset str] __________________"
189 array set nmap [$cset nextmap]
190 foreach r [lsort -dict [array names nmap]] {
191 foreach succrev $nmap($r) {
192 log write 2 cyclebreaker \
193 "LOOP * rev <$r> --> rev <$succrev> --> cs [project::rev strlist [project::rev ofrev $succrev]]"
194 }
195 }
196 }
197 }
198 }
@@ -262,11 +262,11 @@
262 log write 10 cyclebreaker \
263 "Pending: [struct::list map $mybottom [myproc FormatPendingItem]]"
264 return
265 }
266
267 proc FormatPendingItem {item} { lreplace $item 0 0 [[lindex $item 0] str] }
268
269 proc FindCycle {dg} {
270 # This procedure is run if and only the graph is not empty and
271 # all nodes have predecessors. This means that each node is
272 # either part of a cycle or (indirectly) depending on a node
@@ -298,20 +298,18 @@
298 }
299
300 return [struct::list reverse [lrange $path $seen($start) end]]
301 }
302
 
 
303 proc BreakCycle {dg cycle} {
304 # The cycle we have gotten is broken by breaking apart one or
305 # more of the changesets in the cycle. This causes us to
306 # create one or more changesets which are to be committed,
307 # added to the graph, etc. pp.
308
309 # NOTE/TODO. Move this map operation to project::rev, as typemethod.
310 set cprint [project::rev strlist $cycle]
311
312 lappend cycle [lindex $cycle 0] [lindex $cycle 1]
313 set bestlink {}
314 set bestnode {}
315
@@ -336,11 +334,11 @@
334 } else {
335 $link destroy
336 }
337 }
338
339 log write 5 cyclebreaker "Breaking cycle ($cprint) by splitting changeset [$bestnode str]"
340 set ID [$bestnode id]
341 Mark $dg -${ID}-before
342
343 set newcsets [$bestlink break]
344 $bestlink destroy
@@ -388,11 +386,11 @@
386 $dg node delete $n
387
388 foreach cset $replacements {
389 $dg node insert $cset
390 $dg node set $cset timerange [$cset timerange]
391 $dg node set $cset label [$cset str]
392 $dg node set $cset __id__ [$cset id]
393 }
394
395 foreach cset $replacements {
396 foreach succ [$cset successors] {
@@ -399,11 +397,11 @@
397 # The new changesets may have dependencies outside of
398 # the chosen set. These are ignored
399 if {![$dg node exists $succ]} continue
400 $dg arc insert $cset $succ
401 if {$succ eq $cset} {
402 trouble internal "Self-referencing changeset [$cset str]"
403 }
404 }
405 }
406 foreach cset $pre {
407 foreach succ [$cset successors] {
408
M tools/cvs2fossil/lib/c2f_pbreakacycle.tcl
+11 -2
--- tools/cvs2fossil/lib/c2f_pbreakacycle.tcl
+++ tools/cvs2fossil/lib/c2f_pbreakacycle.tcl
@@ -133,11 +133,11 @@
133133
 return
134134
 }
135135
136136
 proc CheckAndBreakBackwardBranch {graph cset} {
137137
 while {[IsABackwardBranch $graph $cset]} {
138
- log write 5 breakacycle "Breaking backward branch changeset <[$cset id]>"
138
+ log write 5 breakacycle "Breaking backward branch changeset [$cset str]"
139139
140140
 # Knowing that the branch is backward we now look at the
141141
 # individual revisions in the changeset and determine
142142
 # which of them are responsible for the overlap. This
143143
 # allows us to split them into two sets, one of
@@ -302,11 +302,20 @@
302302
 }
303303
304304
305305
 # # ## ### ##### ######## #############
306306
307
- proc SaveOrder {graph cset pos} {
307
+ proc SaveOrder {graph at cset} {
308
+ set cid [$cset id]
309
+
310
+ log write 4 breakacycle "Comitting @ $at: [$cset str]"
311
+ state run {
312
+ INSERT INTO csorder (cid, pos)
313
+ VALUES ($cid, $at)
314
+ }
315
+ # MAYBE TODO: Write the project level changeset dependencies as well.
316
+ return
308317
 }
309318
310319
 # # ## ### ##### ######## #############
311320
312321
 proc BreakCycle {graph} {
313322
--- tools/cvs2fossil/lib/c2f_pbreakacycle.tcl
+++ tools/cvs2fossil/lib/c2f_pbreakacycle.tcl
@@ -133,11 +133,11 @@
133 return
134 }
135
136 proc CheckAndBreakBackwardBranch {graph cset} {
137 while {[IsABackwardBranch $graph $cset]} {
138 log write 5 breakacycle "Breaking backward branch changeset <[$cset id]>"
139
140 # Knowing that the branch is backward we now look at the
141 # individual revisions in the changeset and determine
142 # which of them are responsible for the overlap. This
143 # allows us to split them into two sets, one of
@@ -302,11 +302,20 @@
302 }
303
304
305 # # ## ### ##### ######## #############
306
307 proc SaveOrder {graph cset pos} {
 
 
 
 
 
 
 
 
 
308 }
309
310 # # ## ### ##### ######## #############
311
312 proc BreakCycle {graph} {
313
--- tools/cvs2fossil/lib/c2f_pbreakacycle.tcl
+++ tools/cvs2fossil/lib/c2f_pbreakacycle.tcl
@@ -133,11 +133,11 @@
133 return
134 }
135
136 proc CheckAndBreakBackwardBranch {graph cset} {
137 while {[IsABackwardBranch $graph $cset]} {
138 log write 5 breakacycle "Breaking backward branch changeset [$cset str]"
139
140 # Knowing that the branch is backward we now look at the
141 # individual revisions in the changeset and determine
142 # which of them are responsible for the overlap. This
143 # allows us to split them into two sets, one of
@@ -302,11 +302,20 @@
302 }
303
304
305 # # ## ### ##### ######## #############
306
307 proc SaveOrder {graph at cset} {
308 set cid [$cset id]
309
310 log write 4 breakacycle "Comitting @ $at: [$cset str]"
311 state run {
312 INSERT INTO csorder (cid, pos)
313 VALUES ($cid, $at)
314 }
315 # MAYBE TODO: Write the project level changeset dependencies as well.
316 return
317 }
318
319 # # ## ### ##### ######## #############
320
321 proc BreakCycle {graph} {
322
M tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl
+2 -2
--- tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl
+++ tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl
@@ -104,16 +104,16 @@
104104
 proc IsByRevision {cset} { $cset byrevision }
105105
106106
 proc SaveOrder {graph at cset} {
107107
 set cid [$cset id]
108108
109
- log write 4 breakrcycle "Comitting @ $at: <$cid>"
109
+ log write 4 breakrcycle "Comitting @ $at: [$cset str]"
110110
 state run {
111111
 INSERT INTO csorder (cid, pos)
112112
 VALUES ($cid, $at)
113113
 }
114
- # TODO: Write the project level changeset dependencies as well.
114
+ # MAYBE TODO: Write the project level changeset dependencies as well.
115115
 return
116116
 }
117117
118118
 # # ## ### ##### ######## #############
119119
 ## Configuration
120120
--- tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl
+++ tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl
@@ -104,16 +104,16 @@
104 proc IsByRevision {cset} { $cset byrevision }
105
106 proc SaveOrder {graph at cset} {
107 set cid [$cset id]
108
109 log write 4 breakrcycle "Comitting @ $at: <$cid>"
110 state run {
111 INSERT INTO csorder (cid, pos)
112 VALUES ($cid, $at)
113 }
114 # TODO: Write the project level changeset dependencies as well.
115 return
116 }
117
118 # # ## ### ##### ######## #############
119 ## Configuration
120
--- tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl
+++ tools/cvs2fossil/lib/c2f_pbreakrcycle.tcl
@@ -104,16 +104,16 @@
104 proc IsByRevision {cset} { $cset byrevision }
105
106 proc SaveOrder {graph at cset} {
107 set cid [$cset id]
108
109 log write 4 breakrcycle "Comitting @ $at: [$cset str]"
110 state run {
111 INSERT INTO csorder (cid, pos)
112 VALUES ($cid, $at)
113 }
114 # MAYBE TODO: Write the project level changeset dependencies as well.
115 return
116 }
117
118 # # ## ### ##### ######## #############
119 ## Configuration
120
M tools/cvs2fossil/lib/c2f_prev.tcl
+10 -2
--- tools/cvs2fossil/lib/c2f_prev.tcl
+++ tools/cvs2fossil/lib/c2f_prev.tcl
@@ -50,10 +50,12 @@
5050
 set myidmap($myid) $self
5151
 foreach r $revisions { lappend myrevmap($r) $self }
5252
 return
5353
 }
5454
55
+ method str {} { return "<${myid}>" }
56
+
5557
 method id {} { return $myid }
5658
 method revisions {} { return $myrevisions }
5759
 method data {} { return [list $myproject $mytype $mysrcid] }
5860
5961
 method bysymbol {} { return [expr {$mytype eq "sym"}] }
@@ -155,11 +157,11 @@
155157
156158
 array set dependencies {}
157159
 PullInternalSuccessorRevisions dependencies $myrevisions
158160
 if {![array size dependencies]} {return 0} ; # Nothing to break.
159161
160
- log write 6 csets ...<$myid>.......................................................
162
+ log write 6 csets ...[$self str].......................................................
161163
162164
 # We have internal dependencies to break. We now iterate over
163165
 # all positions in the list (which is chronological, at least
164166
 # as far as the timestamps are correct and unique) and
165167
 # determine the best position for the break, by trying to
@@ -261,11 +263,11 @@
261263
 trouble internal "Bad fragment border <$laste | $s>, gap or overlap"
262264
 }
263265
264266
 set new [$type %AUTO% $myproject $mytype $mysrcid [lrange $myrevisions $s $e]]
265267
266
- log write 4 csets "Breaking <$myid> @ $laste, new <[$new id]>, cutting $breaks($laste)"
268
+ log write 4 csets "Breaking [$self str ] @ $laste, new [$new str], cutting $breaks($laste)"
267269
268270
 set laste $e
269271
 }
270272
271273
 if {$laste != ([llength $myrevisions]-1)} {
@@ -356,10 +358,16 @@
356358
 }
357359
358360
 foreach c $newcsets { $c persist }
359361
 return $newcsets
360362
 }
363
+
364
+ typemethod strlist {changesets} {
365
+ return [join [struct::list map $changesets [myproc ID]]]
366
+ }
367
+
368
+ proc ID {cset} { $cset str }
361369
362370
 # # ## ### ##### ######## #############
363371
 ## State
364372
365373
 variable myid {} ; # Id of the cset for the persistent
366374
--- tools/cvs2fossil/lib/c2f_prev.tcl
+++ tools/cvs2fossil/lib/c2f_prev.tcl
@@ -50,10 +50,12 @@
50 set myidmap($myid) $self
51 foreach r $revisions { lappend myrevmap($r) $self }
52 return
53 }
54
 
 
55 method id {} { return $myid }
56 method revisions {} { return $myrevisions }
57 method data {} { return [list $myproject $mytype $mysrcid] }
58
59 method bysymbol {} { return [expr {$mytype eq "sym"}] }
@@ -155,11 +157,11 @@
155
156 array set dependencies {}
157 PullInternalSuccessorRevisions dependencies $myrevisions
158 if {![array size dependencies]} {return 0} ; # Nothing to break.
159
160 log write 6 csets ...<$myid>.......................................................
161
162 # We have internal dependencies to break. We now iterate over
163 # all positions in the list (which is chronological, at least
164 # as far as the timestamps are correct and unique) and
165 # determine the best position for the break, by trying to
@@ -261,11 +263,11 @@
261 trouble internal "Bad fragment border <$laste | $s>, gap or overlap"
262 }
263
264 set new [$type %AUTO% $myproject $mytype $mysrcid [lrange $myrevisions $s $e]]
265
266 log write 4 csets "Breaking <$myid> @ $laste, new <[$new id]>, cutting $breaks($laste)"
267
268 set laste $e
269 }
270
271 if {$laste != ([llength $myrevisions]-1)} {
@@ -356,10 +358,16 @@
356 }
357
358 foreach c $newcsets { $c persist }
359 return $newcsets
360 }
 
 
 
 
 
 
361
362 # # ## ### ##### ######## #############
363 ## State
364
365 variable myid {} ; # Id of the cset for the persistent
366
--- tools/cvs2fossil/lib/c2f_prev.tcl
+++ tools/cvs2fossil/lib/c2f_prev.tcl
@@ -50,10 +50,12 @@
50 set myidmap($myid) $self
51 foreach r $revisions { lappend myrevmap($r) $self }
52 return
53 }
54
55 method str {} { return "<${myid}>" }
56
57 method id {} { return $myid }
58 method revisions {} { return $myrevisions }
59 method data {} { return [list $myproject $mytype $mysrcid] }
60
61 method bysymbol {} { return [expr {$mytype eq "sym"}] }
@@ -155,11 +157,11 @@
157
158 array set dependencies {}
159 PullInternalSuccessorRevisions dependencies $myrevisions
160 if {![array size dependencies]} {return 0} ; # Nothing to break.
161
162 log write 6 csets ...[$self str].......................................................
163
164 # We have internal dependencies to break. We now iterate over
165 # all positions in the list (which is chronological, at least
166 # as far as the timestamps are correct and unique) and
167 # determine the best position for the break, by trying to
@@ -261,11 +263,11 @@
263 trouble internal "Bad fragment border <$laste | $s>, gap or overlap"
264 }
265
266 set new [$type %AUTO% $myproject $mytype $mysrcid [lrange $myrevisions $s $e]]
267
268 log write 4 csets "Breaking [$self str ] @ $laste, new [$new str], cutting $breaks($laste)"
269
270 set laste $e
271 }
272
273 if {$laste != ([llength $myrevisions]-1)} {
@@ -356,10 +358,16 @@
358 }
359
360 foreach c $newcsets { $c persist }
361 return $newcsets
362 }
363
364 typemethod strlist {changesets} {
365 return [join [struct::list map $changesets [myproc ID]]]
366 }
367
368 proc ID {cset} { $cset str }
369
370 # # ## ### ##### ######## #############
371 ## State
372
373 variable myid {} ; # Id of the cset for the persistent
374
M tools/cvs2fossil/lib/c2f_prevlink.tcl
+1 -1
--- tools/cvs2fossil/lib/c2f_prevlink.tcl
+++ tools/cvs2fossil/lib/c2f_prevlink.tcl
@@ -123,11 +123,11 @@
123123
 return 0 ; # Self is worse or equal, i.e. not better.
124124
 }
125125
126126
 method break {} {
127127
 if {![$self breakable]} {
128
- trouble internal "Changeset <[$mycset id]> is not breakable."
128
+ trouble internal "Changeset [$mycset str] is not breakable."
129129
 }
130130
131131
 # One thing to choose when splitting CSET is where the
132132
 # revision in categories 1 and 2 (none and passthrough
133133
 # respectively) are moved to. This is done using the counters.
134134
--- tools/cvs2fossil/lib/c2f_prevlink.tcl
+++ tools/cvs2fossil/lib/c2f_prevlink.tcl
@@ -123,11 +123,11 @@
123 return 0 ; # Self is worse or equal, i.e. not better.
124 }
125
126 method break {} {
127 if {![$self breakable]} {
128 trouble internal "Changeset <[$mycset id]> is not breakable."
129 }
130
131 # One thing to choose when splitting CSET is where the
132 # revision in categories 1 and 2 (none and passthrough
133 # respectively) are moved to. This is done using the counters.
134
--- tools/cvs2fossil/lib/c2f_prevlink.tcl
+++ tools/cvs2fossil/lib/c2f_prevlink.tcl
@@ -123,11 +123,11 @@
123 return 0 ; # Self is worse or equal, i.e. not better.
124 }
125
126 method break {} {
127 if {![$self breakable]} {
128 trouble internal "Changeset [$mycset str] is not breakable."
129 }
130
131 # One thing to choose when splitting CSET is where the
132 # revision in categories 1 and 2 (none and passthrough
133 # respectively) are moved to. This is done using the counters.
134

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button