Fossil

	    trouble fatal "File $mypath contains duplicate definitions for revision $revnr."
	    return
	}

	set myaid($revnr) [$myproject defauthor $author]
	set myrev($revnr) [rev %AUTO% $revnr $date $state $self]

	RecordBasicDependencies $revnr $next
	$self RecordBasicDependencies $revnr $next
	return
    }

    method defdone {} {
	# This is all done after the revision tree has been extracted
	# from the file, before the commit mesages and delta texts are
	# processed.

	ProcessPrimaryDependencies
	ProcessBranchDependencies
	SortBranches
	ProcessTagDependencies
	DetermineTheRootRevision
	$self ProcessPrimaryDependencies
	$self ProcessBranchDependencies
	$self SortBranches
	$self ProcessTagDependencies
	$self DetermineTheRootRevision
	return
    }

    method setdesc {d} {# ignore}

    method extend {revnr commitmsg textrange} {
	set cmid [$myproject defcmessage [string trim $commitmsg]]

	# level). This gives us the branchid too, required for the
	# meta data group the revision is in. (Note: By putting both
	# branch/lod and project information into the group we ensure
	# that any cross-project and cross-branch commits are
	# separated into multiple commits, one in each of the projects
	# and/or branches).

	set lod [GetLOD $revnr]
	set lod [$self GetLOD $revnr]

	$rev setmeta [$myproject defmeta [$lod id] $myaid($revnr) $cmid]
	$rev settext $textrange
	$rev setlod  $lod

	# If this is revision 1.1, we have to determine whether the
	# file seems to have been created through 'cvs add' instead of

    }

    method done {} {
	# Complete the revisions, branches, and tags. This includes
	# looking for a non-trunk default branch, marking its members
	# and linking them into the trunk.

	DetermineRevisionOperations
	DetermineLinesOfDevelopment
	HandleNonTrunkDefaultBranch
	RemoveIrrelevantDeletions
	RemoveInitialBranchDeletions
	$self DetermineRevisionOperations
	$self DetermineLinesOfDevelopment
	$self HandleNonTrunkDefaultBranch
	$self RemoveIrrelevantDeletions
	$self RemoveInitialBranchDeletions

	if {[$myproject trunkonly]} {
	    ExcludeNonTrunkInformation
	    $self ExcludeNonTrunkInformation
	}
	return
    }

    # # ## ### ##### ######## #############
    ## State

    method AddTag {name revnr} {
	set tag [sym %AUTO% tag $revnr [$myproject getsymbol $name]]
	lappend mytags($revnr) $tag
	return $tag
    }

    proc RecordBasicDependencies {revnr next} {
    method RecordBasicDependencies {revnr next} {
	# Handle the revision dependencies. Record them for now, do
	# nothing with them yet.

	# On the trunk the 'next' field points to the previous
	# revision, i.e. the _parent_ of the current one. Example:
	# 1.6's next is 1.5 (modulo cvs admin -o).

	# Contrarily on a branch the 'next' field points to the
	# primary _child_ of the current revision. As example,
	# 1.1.3.2's 'next' will be 1.1.3.3.

	# The 'next' field actually always refers to the revision
	# containing the delta needed to retrieve that revision.

	# The dependencies needed here are the logical structure,
	# parent/child, and not the implementation dependent delta
	# pointers.

	if {$next eq ""} return

	upvar 1 mydependencies mydependencies

	#                          parent -> child
	if {[rev istrunkrevnr $revnr]} {
	    lappend mydependencies $next $revnr
	} else {
	    lappend mydependencies $revnr $next
	}
	return
    }

    proc ProcessPrimaryDependencies {} {
    method ProcessPrimaryDependencies {} {
	upvar 1 mydependencies mydependencies myrev myrev

	foreach {parentrevnr childrevnr} $mydependencies {
	    set parent $myrev($parentrevnr)
	    set child  $myrev($childrevnr)
	    $parent setchild $child
	    $child setparent $parent
	}
	return
    }

    proc ProcessBranchDependencies {} {
    method ProcessBranchDependencies {} {
	upvar 1 mybranches mybranches myrev myrev

	foreach {branchnr branch} [array get mybranches] {
	    set revnr [$branch parentrevnr]

	    if {![info exists myrev($revnr)]} {
		log write 1 file "In '$mypath': The branch '[$branch name]' references"
		log write 1 file "the bogus revision '$revnr' and will be ignored."
		$branch destroy

		    $rev addchildonbranch $child
		}
	    }
	}
	return
    }

    proc SortBranches {} {
    method SortBranches {} {
	upvar 1 myrev myrev

	foreach {revnr rev} [array get myrev] {
	foreach {revnr rev} [array get myrev] { $rev sortbranches }
	    $rev sortbranches
	}
	return
    }

    proc ProcessTagDependencies {} {
    method ProcessTagDependencies {} {
	upvar 1 mytags mytags myrev myrev

	foreach {revnr taglist} [array get mytags] {
	    if {![info exists myrev($revnr)]} {
		set n [llength $taglist]
		log write 1 file "In '$mypath': The following [nsp $n tag] reference"
		log write 1 file "the bogus revision '$revnr' and will be ignored."
		foreach tag $taglist {
		    log write 1 file "    [$tag name]"

		    $tag settagrev $rev
		}
	    }
	}
	return
    }

    proc DetermineTheRootRevision {} {
    method DetermineTheRootRevision {} {
	upvar 1 myrev myrev myroot myroot

	# The root is the one revision which has no parent. By
	# checking all revisions we ensure that we can detect and
	# report the case of multiple roots. Without that we could
	# simply take one revision and follow the parent links to
	# their root (sic!).

	foreach {revnr rev} [array get myrev] {
	    if {[$rev hasparent]} continue
	    if {$myroot ne ""} { trouble internal "Multiple root revisions found" }
	    set myroot $rev
	}

	# In the future we also need a list, as branches can become
	# severed from their parent, making them their own root.
	set myroots [list $myroot]
	return
    }

    proc DetermineRevisionOperations {} {
    method DetermineRevisionOperations {} {
	upvar 1 myrevisions myrevisions
	foreach rev $myrevisions { $rev determineoperation }
	return
    }

    proc DetermineLinesOfDevelopment {} {
    method DetermineLinesOfDevelopment {} {
	# For revisions this has been done already, in 'extend'. Now
	# we do this for the branches and tags.

	upvar 1 self self mybranches mybranches mytags mytags mytrunk mytrunk

	foreach {_ branch} [array get mybranches] {
	    $branch setlod [GetLOD [$branch parentrevnr]]
	    $branch setlod [$self GetLOD [$branch parentrevnr]]
	}

	foreach {_ taglist} [array get mytags] {
	    foreach tag $taglist {
		$tag setlod [GetLOD [$tag tagrevnr]]
		$tag setlod [$self GetLOD [$tag tagrevnr]]
	    }
	}
	return
    }

    proc GetLOD {revnr} {
    method GetLOD {revnr} {
	if {[rev istrunkrevnr $revnr]} {
	    upvar 1 mytrunk mytrunk
	    return $mytrunk
	} else {
	    upvar 1 self self
	    return [$self Rev2Branch $revnr]
	}
    }

    proc HandleNonTrunkDefaultBranch {} {
    method HandleNonTrunkDefaultBranch {} {
	upvar 1 myprincipal myprincipal myroot myroot mybranches mybranches myimported myimported myroots myroots myrev myrev

	set revlist [NonTrunkDefaultRevisions]
	set revlist [$self NonTrunkDefaultRevisions]
	if {![llength $revlist]} return

	AdjustNonTrunkDefaultBranch $revlist
	CheckLODs
	$self AdjustNonTrunkDefaultBranch $revlist
	$self CheckLODs
	return
    }

    proc NonTrunkDefaultRevisions {} {
    method NonTrunkDefaultRevisions {} {
	# From cvs2svn the following explanation (with modifications
	# for our algorithm):

	# Determine whether there are any non-trunk default branch
	# revisions.

	# If a non-trunk default branch is determined to have existed,

	# some period in the past it probably *did* have one.  For
	# example, the file has vendor revisions 1.1.1.1 -> 1.1.1.96,
	# all of which are dated before 1.2, and then it has 1.1.1.97
	# -> 1.1.1.100 dated after 1.2.  In this case, we should
	# record 1.1.1.96 as the last vendor revision to have been the
	# head of the default branch.

	upvar 1 myprincipal myprincipal myroot myroot mybranches mybranches myimported myimported

	if {$myprincipal ne ""} {
	    # There is still a default branch; that means that all
	    # revisions on that branch get marked.

	    log write 5 file "Found explicitly marked NTDB"

	    set rnext [$myroot child]

	    return $res

	} else {
	    return {}
	}
    }

    proc AdjustNonTrunkDefaultBranch {revlist} {
    method AdjustNonTrunkDefaultBranch {revlist} {
	upvar 1 myroot myroot myimported myimported myroots myroots myrev myrev mybranches mybranches
	set stop [$myroot child] ;# rev '1.2'

	log write 5 file "Adjusting NTDB containing [nsp [llength $revlist] revision]"

	# From cvs2svn the following explanation (with modifications
	# for our algorithm):

	    set last [lindex $revlist end]
	    $stop setdefaultbranchparent $last ; # Retypes the revision too.
	    $last setdefaultbranchchild  $stop
	}
	return
    }

    proc CheckLODs {} {
    method CheckLODs {} {
	upvar 1 mybranches mybranches mytags mytags

	foreach {_ branch} [array get mybranches] { $branch checklod }
	foreach {_ branch}  [array get mybranches] { $branch checklod }

	foreach {_ taglist} [array get mytags] {
	    foreach tag $taglist { $tag checklod }
	}
	return
    }

    proc RemoveIrrelevantDeletions {} {
    method RemoveIrrelevantDeletions {} {
    }

    proc RemoveInitialBranchDeletions {} {
    method RemoveInitialBranchDeletions {} {
    }

    proc ExcludeNonTrunkInformation {} {
    method ExcludeNonTrunkInformation {} {
    }

    # # ## ### ##### ######## #############
    ## Configuration

    pragma -hastypeinfo    no  ; # no type introspection
    pragma -hasinfo        no  ; # no object introspection