//{{{  Banner                           

//============================================================================
//
//     base.cxx
//
//     Implementations of the various base classes
//
//============================================================================
//####COPYRIGHTBEGIN####
//                                                                          
// ----------------------------------------------------------------------------
// Copyright (C) 2002, 2003 Bart Veer
// Copyright (C) 1999, 2000 Red Hat, Inc.
//
// This file is part of the eCos host tools.
//
// This program is free software; you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by the Free 
// Software Foundation; either version 2 of the License, or (at your option) 
// any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT 
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
// more details.
// 
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// ----------------------------------------------------------------------------
//                                                                          
//####COPYRIGHTEND####
//============================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):   bartv
// Contact(s):  bartv
// Date:        1999/02/18
// Version:     0.02
// Description: libcdl defines a hierarchy of base classes, used for
//              constructing higher-level entities such as options
//              and packages.
//
//####DESCRIPTIONEND####
//============================================================================

//}}}
//{{{  #include's                       

// ----------------------------------------------------------------------------
#include "cdlconfig.h"

// Get the infrastructure types, assertions, tracing and similar
// facilities.
#include <cyg/infra/cyg_ass.h>
#include <cyg/infra/cyg_trac.h>

// <cdl.hxx> defines everything implemented in this module.
// It implicitly supplies <string>, <vector> and <map> because
// the class definitions rely on these headers.
#include <cdlcore.hxx>

//}}}

//{{{  Statics                          

// ----------------------------------------------------------------------------
CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlNodeBody);
CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlContainerBody);
CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlLoadableBody);
CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlToplevelBody);
CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlUserVisibleBody);
CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlParentableBody);

//}}}
//{{{  CdlNodeBody                      

//{{{  Construction                             

// ----------------------------------------------------------------------------
// The real constructor takes a string argument and should get invoked first.
// Because of the way virtual inheritance is used it is also necessary to have
// a default constructor, but that need not do anything. A newly constructed
// object does not yet live in the hierarchy.

CdlNodeBody::CdlNodeBody(std::string name_arg)
{
    CYG_REPORT_FUNCNAME("CdlNode:: constructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITIONC("" != name_arg);

    name        = name_arg;
    parent      = 0;
    owner       = 0;
    toplevel    = 0;
    active      = false;
    remove_node_container_position = -1;

    // The STL containers will take care of themselves.
    
    cdlnodebody_cookie = CdlNodeBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();

    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

CdlNodeBody::CdlNodeBody()
{
    CYG_PRECONDITION_THISC();
}

//}}}
//{{{  Destructor                               

// ----------------------------------------------------------------------------
// By the time the destructor gets invoked the node should already
// have been unbound and removed from the hierarchy.

CdlNodeBody::~CdlNodeBody()
{
    CYG_REPORT_FUNCNAME("CdlNode:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    // Make sure that the node is unbound: all references to and from
    // this node should have been destroyed already inside a
    // transaction.
    CYG_PRECONDITIONC(0 == referrers.size());

    // Make sure that the node has been removed from the hierarchy
    CYG_PRECONDITIONC(0 == toplevel);
    CYG_PRECONDITIONC(0 == owner);
    CYG_PRECONDITIONC(0 == parent);
    
    // Destroy all properties associated with this object.
    std::vector<CdlProperty>::iterator prop_i;
    for (prop_i= properties.begin(); prop_i != properties.end(); prop_i++) {
        delete *prop_i;
        *prop_i = 0;
    }
    properties.clear();

    cdlnodebody_cookie  = CdlNodeBody_Invalid;
    name   = "";
    active = false;
    unsupported_savefile_strings.clear();
    
    CYGDBG_MEMLEAK_DESTRUCTOR();

    CYG_REPORT_RETURN();
}

//}}}
//{{{  Trivial data access                      

// ----------------------------------------------------------------------------

std::string
CdlNodeBody::get_name() const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_name");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return name;
}

void
CdlNodeBody::set_name(std::string name_arg)
{
    CYG_REPORT_FUNCNAME("CdlNode::set_name");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    name = name_arg;

    CYG_REPORT_RETURN();
}

CdlContainer
CdlNodeBody::get_parent() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::get_parent", "parent %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlContainer result = parent;
    CYG_REPORT_RETVAL(result);
    return result;
}

CdlLoadable
CdlNodeBody::get_owner() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::get_owner", "owner %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlLoadable result = owner;
    CYG_REPORT_RETVAL(result);
    return result;
}

CdlToplevel
CdlNodeBody::get_toplevel() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::get_toplevel", "toplevel %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlToplevel result = toplevel;
    CYG_REPORT_RETVAL(result);
    return result;
}

std::string
CdlNodeBody::get_class_name() const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_class_name");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return "node";
}

//}}}
//{{{  The properties vector                    

// ----------------------------------------------------------------------------
// Trivial manipulation of the properties vector.

const std::vector<CdlProperty>&
CdlNodeBody::get_properties() const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_properties");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return properties;
}

CdlProperty
CdlNodeBody::get_property(std::string id) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::get_property", "result %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlProperty result = 0;
    std::vector<CdlProperty>::const_iterator prop_i;
    for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
        if ((*prop_i)->get_property_name() == id) {
            result = *prop_i;
            break;
        }
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

void
CdlNodeBody::get_properties(std::string id, std::vector<CdlProperty>& result) const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_properties");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    std::vector<CdlProperty>::const_iterator prop_i;
    for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
        if ((*prop_i)->get_property_name() == id) {
            result.push_back(*prop_i);
        }
    }

    CYG_REPORT_RETURN();
}

std::vector<CdlProperty>
CdlNodeBody::get_properties(std::string id) const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_properties");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    std::vector<CdlProperty> result;
    std::vector<CdlProperty>::const_iterator prop_i;
    for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
        if ((*prop_i)->get_property_name() == id) {
            result.push_back(*prop_i);
        }
    }

    CYG_REPORT_RETURN();
    return result;
}

bool
CdlNodeBody::has_property(std::string id) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::has_property", "result %d");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    bool result = false;
    std::vector<CdlProperty>::const_iterator prop_i;
    for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
        if ((*prop_i)->get_property_name() == id) {
            result = true;
            break;
        }
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

int
CdlNodeBody::count_properties(std::string id) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::count_properties", "result %d");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    int result = 0;
    std::vector<CdlProperty>::const_iterator prop_i;
    for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
        if ((*prop_i)->get_property_name() == id) {
            result++;
        }
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Conflicts                                

// ----------------------------------------------------------------------------
// Provide access to the current set of conflicts. This operates on the global
// state, more commonly these changes happen in the context of a transaction.

void
CdlNodeBody::get_conflicts(std::vector<CdlConflict>& result) const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_conflicts");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    const std::list<CdlConflict>& conflicts = toplevel->get_all_conflicts();
    std::list<CdlConflict>::const_iterator conf_i;
    for (conf_i = conflicts.begin(); conf_i != conflicts.end(); conf_i++) {
        if ((*conf_i)->get_node() == this) {
            result.push_back(*conf_i);
        }
    }

    CYG_REPORT_RETURN();
}

void
CdlNodeBody::get_conflicts(bool (*fn)(CdlConflict), std::vector<CdlConflict>& result) const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_conflicts");
    CYG_REPORT_FUNCARG2XV(this, fn);
    CYG_PRECONDITION_THISC();
    CYG_CHECK_FUNC_PTRC(fn);

    const std::list<CdlConflict>& conflicts = toplevel->get_all_conflicts();
    std::list<CdlConflict>::const_iterator conf_i;
    for (conf_i = conflicts.begin(); conf_i != conflicts.end(); conf_i++) {
        if (((*conf_i)->get_node() == this) && ((*fn)(*conf_i))) {
            result.push_back(*conf_i);
        }
    }
    
    CYG_REPORT_RETURN();
}

void
CdlNodeBody::get_structural_conflicts(std::vector<CdlConflict>& result) const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_structural_conflicts");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    const std::list<CdlConflict>& conflicts = toplevel->get_all_structural_conflicts();
    std::list<CdlConflict>::const_iterator conf_i;
    for (conf_i = conflicts.begin(); conf_i != conflicts.end(); conf_i++) {
        if ((*conf_i)->get_node() == this) {
            result.push_back(*conf_i);
        }
    }

    CYG_REPORT_RETURN();
}

void
CdlNodeBody::get_structural_conflicts(bool (*fn)(CdlConflict), std::vector<CdlConflict>& result) const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_conflicts");
    CYG_REPORT_FUNCARG2XV(this, fn);
    CYG_PRECONDITION_THISC();
    CYG_CHECK_FUNC_PTRC(fn);

    const std::list<CdlConflict>& conflicts = toplevel->get_all_structural_conflicts();
    std::list<CdlConflict>::const_iterator conf_i;
    for (conf_i = conflicts.begin(); conf_i != conflicts.end(); conf_i++) {
        if (((*conf_i)->get_node() == this) && ((*fn)(*conf_i))) {
            result.push_back(*conf_i);
        }
    }
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Referrers                                

// ----------------------------------------------------------------------------
// And access to the referrers vector.
const std::vector<CdlReferrer>&
CdlNodeBody::get_referrers() const
{
    CYG_REPORT_FUNCNAME("CdlNode::get_referrers");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return referrers;
}

//}}}
//{{{  Property parsers                         

// ----------------------------------------------------------------------------
// Property parsing. For now there are now properties guaranteed to be
// associated with every node. This may change in future, e.g.
// internal debugging-related properties.
void
CdlNodeBody::add_property_parsers(std::vector<CdlInterpreterCommandEntry>& parsers)
{
    CYG_REPORT_FUNCNAME("CdlNode::add_property_parsers");
    CYG_REPORT_RETURN();
}

void
CdlNodeBody::check_properties(CdlInterpreter interp)
{
    CYG_REPORT_FUNCNAME("CdlNode::check_properties");
    CYG_REPORT_FUNCARG2XV(this, interp);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);

    CYG_REPORT_RETURN();
}

//}}}
//{{{  is_active() etc.                         

// ----------------------------------------------------------------------------
// Associated with every node is a boolean that holds the current
// "active" state. Changes to this happen only at transaction
// commit time.

bool
CdlNodeBody::is_active() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::is_active", "result %d");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    bool result = active;
    CYG_REPORT_RETVAL(result);
    return result;
}

bool
CdlNodeBody::is_active(CdlTransaction transaction)
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::is_active", "result %d");
    CYG_REPORT_FUNCARG2XV(this, transaction);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_ZERO_OR_CLASSC(transaction);

    bool result;
    if (0 != transaction) {
        result = transaction->is_active(this);
    } else {
        result = active;
    }
    CYG_REPORT_RETVAL(result);
    return result;
}

// This virtual member function allows nodes to check whether or not
// they should be active. Derived classes may impose additional
// constraints.
bool
CdlNodeBody::test_active(CdlTransaction transaction)
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::test_active", "result %d");
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(transaction);

    bool result = false;
    if ((0 != parent) && (transaction->is_active(parent))) {
        CdlValuable valuable = dynamic_cast<CdlValuable>(parent);
        if (0 == valuable) {
            result = true;
        } else if (valuable->is_enabled(transaction)) {
            result = true;
        }
    }
    
    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Propagation support                      

// ----------------------------------------------------------------------------
// In the base class nothing needs doing for propagation.
void
CdlNodeBody::update(CdlTransaction transaction, CdlUpdate change)
{
    CYG_REPORT_FUNCNAME("CdlNode::update");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(transaction);
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Persistence support                      

// ----------------------------------------------------------------------------
// The CdlNode::save() member should never get invoked directly, it should
// get invoked indirectly from e.g. CdlOption::save(). Normally there is
// no information associated with a node that ends up in a save file
// (the calling code will have take care of the name etc.). However there
// is support in the library for storing application-specific data in the
// save file, for example GUI information, and this information must be
// preserved even if it is not recognised. Savefiles are self-describing,
// they contain details of all the commands that are applicable. 
// CdlNode::save() is responsible for outputting the unrecognised strings
// to the save file.

void
CdlNodeBody::save(CdlInterpreter interp, Tcl_Channel chan, int indentation, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlNode::save");
    CYG_REPORT_FUNCARG5XV(this, interp, chan, indentation, minimal);

    if (unsupported_savefile_strings.size() != 0) {
        // We should already be inside the body of a suitable command,
        // e.g. cdl_option xyz { ... }
        // CdlToplevel::savefile_handle_unsupported() is responsible for
        // putting suitably formatted strings into the
        // unsupported_savefile_strings vector, so all that is needed here
        // is to dump those strings to the channel.
        std::string data = "\n";
        std::vector<std::string>::const_iterator str_i;
        for (str_i = unsupported_savefile_strings.begin(); str_i != unsupported_savefile_strings.end(); str_i++) {
            data += std::string(indentation, ' ') + *str_i + " ;\n";
        }
        interp->write_data(chan, data);
    }

    CYG_UNUSED_PARAM(bool, minimal);
    CYG_REPORT_RETURN();
}

bool
CdlNodeBody::has_additional_savefile_information() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlNode::has_additional_savefile_information", "result %d");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    bool result = (0 != unsupported_savefile_strings.size());
    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  check_this()                             

// ----------------------------------------------------------------------------
// Because of multiple and virtual inheritance, check_this() may
// get called rather a lot. Unfortunately all of the checks are
// useful.

bool
CdlNodeBody::check_this(cyg_assert_class_zeal zeal) const
{
    if (CdlNodeBody_Magic != cdlnodebody_cookie) {
        return false;
    }
    CYGDBG_MEMLEAK_CHECKTHIS();
    
    if ("" == name) {
        return false;
    }

    // It is hard to validate the toplevel, owner, and parent
    // fields.
    //
    // 1) when a node is newly created all three fields will
    //    be null.
    // 2) the toplevel may be null if the node is in the process
    //    of being removed, e.g. during an unload operation.
    //    The node should still have a valid owner, and will
    //    have a parent unless the node is also the loadable.
    // 3) some nodes are special, e.g. the orphans container,
    //    and do not have an owner.
    //
    // So the following combinations can occur:
    //  Toplevel   Owner    Parent
    //     0         0         0          Creation & toplevel
    //     0       Valid       0          Loadable being unloaded
    //     0       Valid     Valid        Node being unloaded
    //   Valid       0       Valid        Orphans container
    //   Valid     Valid     Valid        Any node
    if (0 != toplevel) {
        if (0 == parent) {
            return false;
        }
    }
 
    switch(zeal) {
      case cyg_system_test :
      case cyg_extreme     :
      {
        if ((0 != toplevel) && (toplevel != this)) {
            if (!toplevel->check_this(cyg_quick)) {
                return false;
            }
            if (toplevel->lookup_table.find(name) == toplevel->lookup_table.end()) {
                return false;
            }
        }
        if (0 != parent) {
            if (!parent->check_this(cyg_quick)) {
                return false;
            }
            if (std::find(parent->contents.begin(), parent->contents.end(), this) == parent->contents.end()) {
                return false;
            }
        }
        if (0 != owner) {
            if (!owner->check_this(cyg_quick)) {
                return false;
            }
            if (std::find(owner->owned.begin(), owner->owned.end(), this) == owner->owned.end()) {
                return false;
            }
        }
        std::vector<CdlProperty>::const_iterator prop_i;
        for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
            if (!(*prop_i)->check_this(cyg_quick)) {
                return false;
            }
        }
        std::vector<CdlReferrer>::const_iterator ref_i;
        for (ref_i = referrers.begin(); ref_i != referrers.end(); ref_i++) {
            if (!ref_i->check_this(cyg_quick)) {
                return false;
            }
        }
      }
      case cyg_thorough    :
      case cyg_quick       :
      case cyg_trivial     :
      case cyg_none        :
      default              :
          break;
    }

    return true;
}

//}}}

//}}}
//{{{  CdlContainerBody                 

//{{{  Constructors                     

// ----------------------------------------------------------------------------
// A container simply holds other nodes in a hierarchy. Most
// containers correspond to data in CDL scripts, but there are
// exceptions. For example, if an option is reparented below some
// package or component that is not yet known then it can instead be
// reparented into an "orphans" container immediately below the
// toplevel.
//
// Adding and removing entries to a container is done inside the
// CdlToplevel add_node() and remove_node() members. These will update
// all the fields needed to keep the hierarchy consistent. This
// means that the CdlContainer class itself provides only limited
// functionality.

CdlContainerBody::CdlContainerBody()
{
    CYG_REPORT_FUNCNAME("CdlContainer:: default constructor");
    CYG_REPORT_FUNCARG1XV(this);

    cdlcontainerbody_cookie = CdlContainerBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();
    
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

// This variant is for internal use, to allow the library to create
// containers that do not correspond to CDL entities such as
// the orphans container.
CdlContainerBody::CdlContainerBody(std::string name_arg)
    : CdlNodeBody(name_arg)
{
    CYG_REPORT_FUNCNAME("CdlContainerBody:: constructor (name)");
    CYG_REPORT_FUNCARG1XV(this);

    cdlcontainerbody_cookie = CdlContainerBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();

    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Destructor                       

// ----------------------------------------------------------------------------

CdlContainerBody::~CdlContainerBody()
{
    CYG_REPORT_FUNCNAME("CdlContainer:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    // Containers should always be empty by the time they
    // get deleted. The toplevel and loadable destructors should
    // guarantee this.
    CYG_ASSERTC(0 == contents.size());
    
    cdlcontainerbody_cookie = CdlContainerBody_Invalid;
    CYGDBG_MEMLEAK_DESTRUCTOR();
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Accessing the contents           

// ----------------------------------------------------------------------------
// Simple contents access facilities, including searching. Note that
// the toplevel class maintains a <name,ptr> map, which will usually
// be more efficient.

const std::vector<CdlNode>&
CdlContainerBody::get_contents() const
{
    CYG_REPORT_FUNCNAME("CdlContainer::get_contents");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return contents;
}

bool
CdlContainerBody::contains(CdlConstNode node, bool recurse) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlContainer::contains (node)", "result %d");
    CYG_REPORT_FUNCARG3XV(this, node, recurse);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(node);

    bool result = false;
    std::vector<CdlNode>::const_iterator node_i;
    for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
        if (node == *node_i) {
            result = true;
            break;
        }
        if (recurse) {
            CdlConstContainer child = dynamic_cast<CdlConstContainer>(*node_i);
            if ((0 != child) && child->contains(node, true)) {
                result = true;
                break;
            }
        }
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

bool
CdlContainerBody::contains(const std::string name, bool recurse) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlContainer::contains (name)", "result %d");
    CYG_REPORT_FUNCARG2XV(this, recurse);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    bool result = false;
    std::vector<CdlNode>::const_iterator node_i;
    for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
        if ((*node_i)->get_name() == name) {
            result = true;
            break;
        }
        if (recurse) {
            CdlConstContainer child = dynamic_cast<CdlConstContainer>(*node_i);
            if ((0 != child) && child->contains(name, true)) {
                result = true;
                break;
            }
        }
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

CdlNode
CdlContainerBody::find_node(const std::string name, bool recurse) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlContainer::find_node", "result %p");
    CYG_REPORT_FUNCARG2XV(this, recurse);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    CdlNode result = 0;
    std::vector<CdlNode>::const_iterator node_i;
    for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
        if ((*node_i)->get_name() == name) {
            result = *node_i;
            break;
        }
        if (recurse) {
            CdlConstContainer child = dynamic_cast<CdlConstContainer>(*node_i);
            if (0 != child) {
                result = child->find_node(name, true);
                if (0 != result) {
                    break;
                }
            }
        }
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Misc                             

// ----------------------------------------------------------------------------

std::string
CdlContainerBody::get_class_name() const
{
    CYG_REPORT_FUNCNAME("CdlContainer::get_class_name");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return "container";
}

//}}}
//{{{  Propagation                      

// ----------------------------------------------------------------------------
// If a container becomes active and is enabled then it is necessary
// to check all the children in case they want to become active as well.

void
CdlContainerBody::update(CdlTransaction transaction, CdlUpdate change)
{
    CYG_REPORT_FUNCNAME("CdlContainer::update");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(transaction);

    if ((CdlUpdate_ActiveChange != change) && (CdlUpdate_ValueChange != change)) {
        CYG_REPORT_RETURN();
        return;
    }

    if (transaction->is_active(this)) {
        // The container has become active. It is necessary to check
        // all the children. If any of them should be active as well
        // but are not then this needs to change.
        std::vector<CdlNode>::iterator node_i;
            
        for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
            bool old_state = transaction->is_active(*node_i);
            bool new_state = (*node_i)->test_active(transaction);
            if (old_state != new_state) {
                transaction->set_active(*node_i, new_state);
            }
        }
    } else {
        // The container has become inactive. Any children that were
        // active should also become inactive.
        std::vector<CdlNode>::iterator node_i;
        for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
            if (transaction->is_active(*node_i)) {
                transaction->set_active(*node_i, false);
            }
        }
    }
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Persistence                      

// ----------------------------------------------------------------------------
// This member function is invoked while traversing the hierarchy.
// The container itself will have been saved already, this member
// is responsible only for the contents. There are marker comments
// in the output file to indicate a new level in the hierarchy.
//
// Note that this member can also be invoked for the "orphans" container.
// That container will not appear in the save file, but its contents
// will.

void
CdlContainerBody::save(CdlInterpreter interp, Tcl_Channel chan, int indentation, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlContainer::save");
    CYG_REPORT_FUNCARG4XV(this, interp, chan, indentation);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);
    CYG_PRECONDITIONC(0 == indentation);

    if (0 != contents.size()) {
        if (!minimal) {
            interp->write_data(chan, "# >\n");
        }
        std::vector<CdlNode>::const_iterator node_i;
        for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
            (*node_i)->save(interp, chan, indentation, minimal);
        }
        if (!minimal) {
            interp->write_data(chan, "# <\n");
        }
    }
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  check_this()                     

// ----------------------------------------------------------------------------
bool
CdlContainerBody::check_this(cyg_assert_class_zeal zeal) const
{
    if (CdlContainerBody_Magic != cdlcontainerbody_cookie) {
        return false;
    }
    CYGDBG_MEMLEAK_CHECKTHIS();

    if (cyg_extreme == zeal) {
        std::vector<CdlNode>::const_iterator node_i;
        for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
            if (!((*node_i)->check_this(cyg_quick))) {
                return false;
            }
        }
    }
    return CdlNodeBody::check_this(zeal);
}

//}}}

//}}}
//{{{  CdlLoadableBody                  

//{{{  Constructor                              

// ----------------------------------------------------------------------------
// A loadable object keeps track of all the nodes read in from a
// particular script, in an "owned" vector. Simply keeping things in a
// hierarchy is not enough because of possible re-parenting. Actual
// updates of the owned vector happen inside the CdlToplevel
// add_node() and remove_node() family.

CdlLoadableBody::CdlLoadableBody(CdlToplevel toplevel, std::string repo, std::string dir)
    : CdlContainerBody()
{
    CYG_REPORT_FUNCNAME("CdlLoadable:: constructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_CLASSC(toplevel);

    // Initialize enough of the object to support check_this()
    repository  = repo;
    directory   = dir;
    interp      = 0;
    remove_node_loadables_position = -1;
    cdlloadablebody_cookie = CdlLoadableBody_Magic;
    
    // The owned vector takes care of itself. It is necessary
    // to create a new slave interpreter, using the master
    // interpreter from the toplevel.
    CdlInterpreter master = toplevel->get_interpreter();
    CYG_ASSERTC(0 != master);
    interp      = master->create_slave(this, false);
    interp->push_context(this->get_name());
    CYGDBG_MEMLEAK_CONSTRUCTOR();
    
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

// Needed by derived classes, but should never actually be used.
CdlLoadableBody::CdlLoadableBody()
{
    CYG_FAIL("CdlLoadable default constructor should never get invoked");
}

//}}}
//{{{  Destructor                               

// ----------------------------------------------------------------------------
// The loadable destructor. This gets invoked from two places: after an
// unsuccessful load operation, and from inside the transaction commit
// code. Either way most of the clean-up will have happened already:
// all the nodes will have been removed from the toplevel's hierarchy,
// and all property references to and from this loadable will have been
// unbound.
//
// Since all nodes belonging to the loadable are also present in
// the owned vector, they must be destroyed before this destructor
// completes. Hence clearing out the contents cannot be left to
// the base CdlContainer destructor.

CdlLoadableBody::~CdlLoadableBody()
{
    CYG_REPORT_FUNCNAME("CdlLoadable:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    // Make sure that the loadable has already been removed from the
    // hierarchy: it should not have a toplevel or a parent.
    CYG_PRECONDITIONC(0 == toplevel);
    CYG_PRECONDITIONC(0 == parent);
    
    // Containers must have been created before any of their contents.
    // The only way to reverse this involves a parent property, but
    // all such properties will have been unbound already such that
    // the nodes can be safely deleted. The only worry is that
    // loadables own themselves.
    int i;
    for (i = owned.size() - 1; i >= 0; i--) {
        CdlNode node = owned[i];
        CYG_LOOP_INVARIANT_CLASSC(node);

        if (node != this) {
            CdlToplevelBody::remove_node(this, node->parent, node);
            delete node;
        }
    }
    
    // Now there should be exactly one entry in the owned vector,
    // the loadable itself. We already know that this is no longer
    // part of the toplevel and it does not have a parent, so
    // the only field we need to worry about is the owner.
    CYG_ASSERTC(1 == owned.size());
    CYG_ASSERTC(this == owned[0]);
    this->owner = 0;

    // Strictly speaking the owned vector should be clear by now,
    // but remove_node() does not actually bother to clear it.
    owned.clear();
    
    // The loadable should now be empty. It remains to clean up
    // a few odds and ends.
    cdlloadablebody_cookie = CdlLoadableBody_Invalid;
    CYG_ASSERTC(0 == owned.size());
    delete interp;
    interp      = 0;
    repository  = "";
    directory   = "";

    CYGDBG_MEMLEAK_DESTRUCTOR();
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Simple information access                

// ----------------------------------------------------------------------------

const std::vector<CdlNode>&
CdlLoadableBody::get_owned() const
{
    CYG_REPORT_FUNCNAME("CdlLoadable::get_owned");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return owned;
}

bool
CdlLoadableBody::owns(CdlConstNode node) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlLoadable::owns", "result %d");
    CYG_REPORT_FUNCARG2XV(this, node);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(node);

    bool result = false;
    std::vector<CdlNode>::const_iterator i = std::find(owned.begin(), owned.end(), node);
    if (i != owned.end()) {
        result = true;
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

CdlInterpreter
CdlLoadableBody::get_interpreter() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlLoadable::get_interpreter", "result %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlInterpreter result = interp;
    CYG_REPORT_RETVAL(result);
    return result;
}

std::string
CdlLoadableBody::get_repository() const
{
    CYG_REPORT_FUNCNAME("CdlLoadable::get_repository");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return repository;
}

std::string
CdlLoadableBody::get_directory() const
{
    CYG_REPORT_FUNCNAME("CdlLoadable::get_directory");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return directory;
}

//}}}
//{{{  Bind/unbind support                      

// ----------------------------------------------------------------------------
// Binding a loadable. This involves checking every property of every node
// in the loadable, which the properties do themselves by a suitable
// update() virtual function. Next, there may be properties in the
// existing configuration which could not previously be bound: there
// will be structural conflicts for all of these. Once all the pointers
// go to the right places it is possible to calculate the default values
// and generally process the properties. Finally each node's active
// state is checked - the default inactive state will be inappropriate
// in many cases.
//
// FIXME: error recovery?

void
CdlLoadableBody::bind(CdlTransaction transaction)
{
    CYG_REPORT_FUNCNAME("CdlLoadable::bind");
    CYG_REPORT_FUNCARG2XV(this, transaction);
    CYG_INVARIANT_THISC(CdlLoadableBody);
    CYG_INVARIANT_CLASSC(CdlTransactionBody, transaction);

    // The loadable must already be part of the hierarchy.
    CdlToplevel toplevel = this->get_toplevel();
    CYG_ASSERT_CLASSC(toplevel);
        
    // As a first step, bind all references in this loadable.
    // This is achieved via a Loaded update.
    const std::vector<CdlNode>& nodes = this->get_owned();
    std::vector<CdlNode>::const_iterator node_i;
    for (node_i = nodes.begin(); node_i != nodes.end(); node_i++) {
        const std::vector<CdlProperty>& properties = (*node_i)->get_properties();
        std::vector<CdlProperty>::const_iterator prop_i;
        for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
            (*prop_i)->update(transaction, *node_i, 0, CdlUpdate_Loaded);
        }
    }

    // Next, look for all structural conflicts which are unresolved
    // references and which can now be resolved. It is necessary
    // to check per-transaction structural conflicts, plus those
    // in any parent transactions, plus the global ones.
    std::list<CdlConflict>::const_iterator conf_i;
    CdlTransaction current_transaction = transaction;
    do {
        CYG_ASSERT_CLASSC(current_transaction);
        const std::list<CdlConflict>& new_structural_conflicts = current_transaction->get_new_structural_conflicts();
        
        for (conf_i = new_structural_conflicts.begin(); conf_i != new_structural_conflicts.end(); ) {
            
            CdlConflict conflict = *conf_i++;
            CYG_LOOP_INVARIANT_CLASSC(conflict);
            
            CdlConflict_Unresolved unresolved_conflict = dynamic_cast<CdlConflict_Unresolved>(conflict);
            if ((0 != unresolved_conflict) && !transaction->has_conflict_been_cleared(conflict)) {
                CdlNode dest = toplevel->lookup(unresolved_conflict->get_target_name());
                if (0 != dest) {
                    CdlNode     node = unresolved_conflict->get_node();
                    CdlProperty prop = unresolved_conflict->get_property();
                    prop->update(transaction, node, dest, CdlUpdate_Created);
                }                    
            }
        }
        current_transaction = current_transaction->get_parent();
    } while (0 != current_transaction);

    const std::list<CdlConflict>& structural_conflicts = toplevel->get_all_structural_conflicts();
    for (conf_i = structural_conflicts.begin(); conf_i != structural_conflicts.end(); ) {
        
        CdlConflict conflict = *conf_i++;
        CYG_LOOP_INVARIANT_CLASSC(conflict);
            
        CdlConflict_Unresolved this_conflict = dynamic_cast<CdlConflict_Unresolved>(conflict);
        if ((0 != this_conflict) && !transaction->has_conflict_been_cleared(conflict)) {
            CdlNode dest = toplevel->lookup(this_conflict->get_target_name());
            if (0 != dest) {
                CdlNode     node = this_conflict->get_node();
                CdlProperty prop = this_conflict->get_property();
                prop->update(transaction, node, dest, CdlUpdate_Created);
            }
        }
    }

    // Conflict resolution has happened. Next it is time
    // to evaluate default_value expressions and the like
    // in the new loadable.
    for (node_i = nodes.begin(); node_i != nodes.end(); node_i++) {
        const std::vector<CdlProperty>& properties = (*node_i)->get_properties();
        std::vector<CdlProperty>::const_iterator prop_i;
        for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
            (*prop_i)->update(transaction, *node_i, 0, CdlUpdate_Init);
        }
    }

    // Nodes start off inactive. Check each one whether or not it
    // should be active.
    // NOTE: possibly this should be done via a per-node init
    // update instead.
    for (node_i = nodes.begin(); node_i != nodes.end(); node_i++) {
        bool current_state = transaction->is_active(*node_i);
        bool new_state     = (*node_i)->test_active(transaction);
        if (current_state != new_state) {
            transaction->set_active(*node_i, new_state);
        }
    }

    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------

void
CdlLoadableBody::unbind(CdlTransaction transaction)
{
    CYG_REPORT_FUNCNAME("CdlLoadable::unbind");
    CYG_REPORT_FUNCARG2XV(this, transaction);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(transaction);
    
    // First take care of all references to nodes in the loadable
    // that is disappearing. This involves a Destroyed update.
    const std::vector<CdlNode>& nodes = this->get_owned();
    std::vector<CdlNode>::const_iterator node_i;
    for (node_i = nodes.begin(); node_i != nodes.end(); node_i++) {
        // The update will remove referrer objects, so it is best
        // to work from the back.
        std::vector<CdlReferrer>& referrers = (*node_i)->referrers;
        std::vector<CdlReferrer>::reverse_iterator ref_i;
        for (ref_i = referrers.rbegin(); ref_i != referrers.rend(); ref_i = referrers.rbegin()) {
            ref_i->update(transaction, *node_i, CdlUpdate_Destroyed);
            CYG_LOOP_INVARIANT(ref_i != referrers.rbegin(), "the vector should have shrunk");
        }
    }

    // Now repeat the loop, but unbind references from the unloaded objects
    // to ones which are going to stay loaded. This will not cause
    // the properties to disappear.
    for (node_i = nodes.begin(); node_i != nodes.end(); node_i++) {
        const std::vector<CdlProperty>& properties = (*node_i)->get_properties();
        std::vector<CdlProperty>::const_iterator prop_i;
        for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
            (*prop_i)->update(transaction, *node_i, 0, CdlUpdate_Unloading);
        }
    }

    // Eliminate any conflicts that belong to this loadable.
    // FIXME: why is his necessary? Should these conflicts not get
    // eliminated by the above property iterations?
    std::list<CdlConflict>::const_iterator conf_i;
    const std::list<CdlConflict>& global_conflicts = toplevel->get_all_conflicts();
    for (conf_i = global_conflicts.begin(); conf_i != global_conflicts.end(); ) {
        CdlConflict conflict = *conf_i++;
        CYG_LOOP_INVARIANT_CLASSC(conflict);
        CdlNode     node     = conflict->get_node();
        if ((node->get_owner() == this) && !transaction->has_conflict_been_cleared(conflict)) {
            transaction->clear_conflict(conflict);
        }
    }
    const std::list<CdlConflict>& global_structural_conflicts = toplevel->get_all_structural_conflicts();
    for (conf_i = global_structural_conflicts.begin(); conf_i != global_structural_conflicts.end(); ) {
        CdlConflict conflict = *conf_i++;
        CYG_LOOP_INVARIANT_CLASSC(conflict);
        CdlNode     node     = conflict->get_node();
        if ((node->get_owner() == this) && !transaction->has_conflict_been_cleared(conflict)) {
            transaction->clear_conflict(conflict);
        }
    }
    const std::list<CdlConflict>& transaction_conflicts = transaction->get_new_conflicts();
    for (conf_i = transaction_conflicts.begin(); conf_i != transaction_conflicts.end(); ) {
        CdlConflict conflict = *conf_i++;
        CYG_LOOP_INVARIANT_CLASSC(conflict);
        CdlNode     node     = conflict->get_node();
        if (node->get_owner() == this) {
            transaction->clear_conflict(conflict);
        }
    }
    const std::list<CdlConflict>& transaction_structural_conflicts = transaction->get_new_structural_conflicts();
    for (conf_i = transaction_structural_conflicts.begin(); conf_i != transaction_structural_conflicts.end(); ) {
        CdlConflict conflict = *conf_i++;
        CYG_LOOP_INVARIANT_CLASSC(conflict);
        CdlNode     node     = conflict->get_node();
        if (node->get_owner() == this) {
            transaction->clear_conflict(conflict);
        }
    }

    // FIXME: how about cleanup_orphans()
    
    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------
// These members are invoked for load and unload operations.
//
// Committing a load does not require anything, the loadable has
// already been fully bound and all propagation has happened.

void
CdlLoadableBody::transaction_commit_load(CdlTransaction transaction, CdlLoadable loadable)
{
    CYG_REPORT_FUNCNAME("CdlLoadable::transaction_commit_load");
    CYG_REPORT_FUNCARG2XV(transaction, loadable);
    CYG_PRECONDITION_CLASSC(transaction);
    CYG_PRECONDITION_CLASSC(loadable);

    CYG_UNUSED_PARAM(CdlTransaction, transaction);
    CYG_UNUSED_PARAM(CdlLoadable, loadable);
    
    CYG_REPORT_RETURN();
}

// Cancelling a load is more difficult. The loadable has to be
// unbound, removed from the toplevel, and deleted. If any of
// this fails then we are in trouble, there is no easy way to
// recover.
void
CdlLoadableBody::transaction_cancel_load(CdlTransaction transaction, CdlLoadable loadable)
{
    CYG_REPORT_FUNCNAME("CdlLoadable::transaction_cancel_load");
    CYG_REPORT_FUNCARG2XV(transaction, loadable);
    CYG_PRECONDITION_CLASSC(transaction);
    CYG_PRECONDITION_CLASSC(loadable);

    CdlToplevel toplevel = transaction->get_toplevel();
    CYG_PRECONDITION_CLASSC(toplevel);
    CYG_ASSERTC(toplevel == loadable->get_toplevel());

    loadable->unbind(transaction);
    toplevel->remove_loadable_from_toplevel(loadable);
    delete loadable;
    
    CYG_REPORT_RETURN();
}

// Committing an unload means that the loadable can now be deleted.
// It should already be unbound and removed from the toplevel.
void
CdlLoadableBody::transaction_commit_unload(CdlTransaction transaction, CdlLoadable loadable)
{
    CYG_REPORT_FUNCNAME("CdlLoadable::transaction_commit_unload");
    CYG_REPORT_FUNCARG2XV(transaction, loadable);
    CYG_PRECONDITION_CLASSC(transaction);
    CYG_PRECONDITION_CLASSC(loadable);

    CYG_UNUSED_PARAM(CdlTransaction, transaction);
    delete loadable;

    CYG_REPORT_RETURN();
}

// Cancelling an unload means that the loadable has to be re-added
// to the hierarchy and then rebound. This implies that value
// propagation needs to happen. However, since all value changes
// since the very start of the transaction are held inside the
// transaction and will be eliminated, the original state will
// be restored anyway so the propagation is not actually required.
void
CdlLoadableBody::transaction_cancel_unload(CdlTransaction transaction, CdlLoadable loadable)
{
    CYG_REPORT_FUNCNAME("CdlLoadable::transaction_cancel_unload");
    CYG_REPORT_FUNCARG2XV(transaction, loadable);
    CYG_PRECONDITION_CLASSC(transaction);
    CYG_PRECONDITION_CLASSC(loadable);

    CdlToplevel toplevel = transaction->get_toplevel();
    CYG_PRECONDITION_CLASSC(toplevel);
    toplevel->add_loadable_to_toplevel(loadable);
    CYG_ASSERT_CLASSC(loadable);
    loadable->bind(transaction);
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  File search facilities                   

// ----------------------------------------------------------------------------
// File search facilities. Given a file name such as hello.cxx from a compile
// property, or doc.html from a doc property, find the corresponding filename,
// for example /usr/local/eCos/kernel/v1_3/doc/threads.html#create
//
// The second argument (default value "") indicates a preferred directory
// where searching should begin. This would be src for a source file,
// doc for a URL, etc.
//
// For some properties the data may refer to a URL rather than to a local
// filename. This is controlled by the third argument, allow_urls.
// If false then only local filenames will be considered. allow_urls
// also controls whether or not anchor processing is performed.
//
// RFC1807: a URL consists of <scheme>:<rest>, where <scheme> can be
// any sequence of lower-case letters, digits, plus, dot or hyphen. It
// is recommended that upper-case letters should be accepted as well.
//
// RFC1807: an anchor is everything after the first # in the URL.

static char find_absolute_file_script[] = "                                     \n\
set cdl_anchor \"\"                                                             \n\
if {$::cdl_allow_urls} {                                                        \n\
  if { [regexp -- {^[a-zA-Z+.-]*:.*$} $::cdl_target] } {                        \n\
      return $::cdl_target                                                      \n\
  }                                                                             \n\
  set tmp \"\"                                                                  \n\
  set non_anchor \"\"                                                           \n\
  if { [regexp -- {^([^#])(#.*$)} $::cdl_target tmp non_anchor cdl_anchor] } {  \n\
      set ::cdl_target $non_anchor                                              \n\
  }                                                                             \n\
}                                                                               \n\
if {$::cdl_prefdir != \"\"} {                                                   \n\
    set filename [file join $::cdl_topdir $::cdl_pkgdir $::cdl_prefdir $::cdl_target]         \n\
    if {[file exists $filename]} {                                              \n\
        return \"[set filename][set cdl_anchor]\"                               \n\
    }                                                                           \n\
}                                                                               \n\
set filename [file join $::cdl_topdir $::cdl_pkgdir $::cdl_target]              \n\
if {[file exists $filename]} {                                                  \n\
    return \"[set filename][set cdl_anchor]\"                                   \n\
}                                                                               \n\
return \"\"                                                                     \n\
";

std::string
CdlLoadableBody::find_absolute_file(std::string filename, std::string dirname, bool allow_urls) const
{
    CYG_REPORT_FUNCNAME("CdlLoadable::find_absolute_file");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != filename);

    // These variable names should be kept in step with CdlBuildable::update_all_build_info()
    interp->set_variable("::cdl_topdir",  repository);
    interp->set_variable("::cdl_pkgdir",  directory);
    interp->set_variable("::cdl_prefdir", dirname);
    interp->set_variable("::cdl_target",  filename);
    interp->set_variable("::cdl_allow_urls", allow_urls ? "1" : "0");

    std::string result;
    int tmp = interp->eval(find_absolute_file_script, result);
    if (tmp != TCL_OK) {
        result = "";
    }
    
    // Replace any backslashes in the repository with forward slashes.
    // The latter are used throughout the library
    // NOTE: this is not i18n-friendly.
    for (unsigned int i = 0; i < result.size(); i++) {
        if ('\\' == result[i]) {
            result[i] = '/';
        }
    }

    CYG_REPORT_RETURN();
    return result;
}

static char find_relative_file_script[] = "                                     \n\
if {$::cdl_prefdir != \"\"} {                                                   \n\
    set filename [file join $::cdl_prefdir $::cdl_target]                       \n\
    if {[file exists [file join $::cdl_topdir $::cdl_pkgdir $filename]]} {      \n\
        return $filename                                                        \n\
    }                                                                           \n\
}                                                                               \n\
set filename $::cdl_target                                                      \n\
if {[file exists [file join $::cdl_topdir $::cdl_pkgdir $filename]]} {          \n\
    return \"[set filename][set cdl_anchor]\"                                   \n\
}                                                                               \n\
return \"\"                                                                     \n\
";

std::string
CdlLoadableBody::find_relative_file(std::string filename, std::string dirname) const
{
    CYG_REPORT_FUNCNAME("CdlLoadable::find_relative_file");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != filename);

    // These variable names should be kept in step with CdlBuildable::update_all_build_info()
    interp->set_variable("::cdl_topdir",  repository);
    interp->set_variable("::cdl_pkgdir",  directory);
    interp->set_variable("::cdl_prefdir", dirname);
    interp->set_variable("::cdl_target",  filename);

    std::string result;
    int tmp = interp->eval(find_relative_file_script, result);
    if (tmp != TCL_OK) {
        result = "";
    }
    
    // Replace any backslashes in the repository with forward slashes.
    // The latter are used throughout the library
    // NOTE: this is not i18n-friendly.
    for (unsigned int i = 0; i < result.size(); i++) {
        if ('\\' == result[i]) {
            result[i] = '/';
        }
    }

    CYG_REPORT_RETURN();
    return result;
}

static char has_subdirectory_script[] = "                               \n\
set dirname [file join $::cdl_topdir $::cdl_pkgdir $::cdl_target]       \n\
if {[file isdirectory $dirname] == 0} {                                 \n\
    return 0                                                            \n\
}                                                                       \n\
return 1                                                                \n\
";

bool
CdlLoadableBody::has_subdirectory(std::string name) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlLoadable::has_subdirectory", "result %d");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    bool        result = false;
    
    interp->set_variable("::cdl_topdir",  repository);
    interp->set_variable("::cdl_pkgdir",  directory);
    interp->set_variable("::cdl_target",  name);

    std::string tcl_result;
    int tmp = interp->eval(has_subdirectory_script, tcl_result);
    if ((TCL_OK == tmp) && ("1" == tcl_result)) {
        result = true;
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Misc                                     

// ----------------------------------------------------------------------------

std::string
CdlLoadableBody::get_class_name() const
{
    CYG_REPORT_FUNCNAME("CdlLoadable::get_class_name");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return "loadable";
}

//}}}
//{{{  check_this()                             

// ----------------------------------------------------------------------------
bool
CdlLoadableBody::check_this(cyg_assert_class_zeal zeal) const
{
    if (CdlLoadableBody_Magic != cdlloadablebody_cookie) {
        return false;
    }
    CYGDBG_MEMLEAK_CHECKTHIS();

    if ((zeal == cyg_extreme) || (zeal == cyg_thorough)) {
        std::vector<CdlNode>::const_iterator node_i;
        for (node_i = owned.begin(); node_i != owned.end(); node_i++) {
            if ((!(*node_i)->check_this(cyg_quick)) || ((*node_i)->get_owner() != this)) {
                return false;
            }
        }
    }
    return CdlContainerBody::check_this(zeal);
}

//}}}

//}}}
//{{{  CdlToplevelBody                  

//{{{  Constructor                              

// ----------------------------------------------------------------------------
// A toplevel is a container without a parent or owner. It keeps track
// of all the names in the hierarchy, thus guaranteeing uniqueness and
// providing a quick lookup facility.
//
// The member functions add_node() and remove_node() are the only
// way of modifying the hierarchy. Adding a node with a zero parent
// means adding it to a special container, Orphans.
//
// An interpreter object must be created explicitly, preventing
// toplevel objects from being statically allocated (although
// it is possible to play tricks with utility classes...)
// There are too many possible error conditions when creating
// an interpreter, so this should not happen until the world
// is ready to deal with such errors.

CdlToplevelBody::CdlToplevelBody(CdlInterpreter interp_arg)
    : CdlContainerBody()
{
    CYG_REPORT_FUNCNAME("CdlToplevel:: constructor");
    CYG_REPORT_FUNCARG2XV(this, interp_arg);
    CYG_PRECONDITION_CLASSC(interp_arg);

    // The STL containers will take care of themselves.
    interp      = interp_arg;
    transaction = 0;

    // A toplevel is always active, override the default setting for a node
    active      = true;
    
    // Make the object valid before creating the orphans container.
    orphans     = 0;
    description = "";
    cdltoplevelbody_cookie = CdlToplevelBody_Magic;
    
    // Arguably creating the orphans container should be left until
    // it is actually needed. The advantage of creating it at the
    // start is that it will appear in a fixed location in the contents,
    // right at the start. Arguably the end would be better, but the
    // end can move as loadables get added and removed.
    //
    // The GUI code will probably want to ignore any empty
    // containers that are not valuables and not user-visible.
    orphans = new CdlContainerBody("orphans");
    add_node(0, this, orphans);

    // Let the interpreter know about its owning toplevel, as well as
    // vice versa.
    interp->set_toplevel(this);
    
    // The orphans container needs to be active as well.
    orphans->active = true;

    CYGDBG_MEMLEAK_CONSTRUCTOR();
    
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Destructor                               

// ----------------------------------------------------------------------------
// The toplevel should have been mostly cleared already, by the
// appropriate derived class. Without any loadables there should not
// be any conflicts. It is necessary to clean up the orphans
// container, since that was created by the CdlToplevel constructor.
// If there are any other special nodes then these should have been
// cleared by higher level code.

CdlToplevelBody::~CdlToplevelBody()
{
    CYG_REPORT_FUNCNAME("CdlToplevel:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_PRECONDITIONC(0 == loadables.size());
    CYG_PRECONDITIONC(0 == conflicts.size());
    CYG_PRECONDITIONC(0 == structural_conflicts.size());
    CYG_PRECONDITIONC(0 == transaction);

    CYG_PRECONDITIONC(0 != orphans);
    this->remove_node_from_toplevel(orphans);
    CdlToplevelBody::remove_node(0, this, orphans);
    delete orphans;
    orphans = 0;

    CYG_PRECONDITIONC(0 == contents.size());
    
    cdltoplevelbody_cookie = CdlToplevelBody_Magic;
    description = "";
    limbo.clear();
    unsupported_savefile_toplevel_strings.clear();
    unsupported_savefile_commands.clear();
    unsupported_savefile_subcommands.clear();

    // Since the interpreter is not created by the toplevel, it is
    // not destroyed with the toplevel either. This leaves a potential
    // big memory leak in application code.
    interp = 0;

    CYGDBG_MEMLEAK_DESTRUCTOR();

    CYG_REPORT_RETURN();
}

//}}}
//{{{  Adding and removing nodes                

// ----------------------------------------------------------------------------
// Adding and removing a node, and changing a parent.
//
// These routines allow the hierarchy to be manipulated. All nodes should
// exist in a hierarchy below a toplevel, except for brief periods after
// construction and during destruction.
//
// Most nodes will belong to a loadable. An owner of 0 is allowed, for
// objects internal to the library such as the orphans container.
// Everything else must have an owner, and specifically a loadable owns
// itself.

void
CdlToplevelBody::add_node(CdlLoadable owner, CdlContainer parent, CdlNode node)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::add_node");
    CYG_REPORT_FUNCARG4XV(this, owner, parent, node);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_ZERO_OR_CLASSC(owner);
    CYG_PRECONDITION_CLASSC(parent);
    CYG_PRECONDITION_CLASSC(node);

    // The node must not be in the hierarchy already.
    CYG_ASSERTC(0 == node->toplevel);
    CYG_ASSERTC(0 == node->owner);
    CYG_ASSERTC(0 == node->parent);
    
    // The node's name should be unique. Checks for that should have happened
    // in higher-level code.
    CYG_ASSERTC(lookup_table.find(node->name) == lookup_table.end());
    node->toplevel              = this;
    lookup_table[node->name]    = node;

    node->owner                 = owner;
    if (0 != owner) {
        owner->owned.push_back(node);
    }

    // If the node is in fact a loadable, it should own itself and
    // in addition the toplevel class keeps track of its loadables
    // in a separate vector.
    if (0 != dynamic_cast<CdlLoadable>(node)) {
        CYG_ASSERTC(owner == dynamic_cast<CdlLoadable>(node));
        this->loadables.push_back(owner);
    }
    
    if (0 == parent) {
        parent = orphans;
    }
    node->parent = parent;
    parent->contents.push_back(node);

    CYG_REPORT_RETURN();
}

// Removing a node from a toplevel. This is the first step in deleting
// a node: the step may be undone by a call to add_node_to_toplevel(),
// or completed by a call to remove_node(). Removing a node from the
// toplevel involves undoing the name->node mapping. In the case
// of loadables, it also involves removing the node from the toplevel's
// contents and loadables containers.

void
CdlToplevelBody::remove_node_from_toplevel(CdlNode node)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::remove_node_from_toplevel");
    CYG_REPORT_FUNCARG2XV(this, node);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(node);
    CYG_ASSERTC(this == node->toplevel);
    CYG_ASSERTC(lookup_table[node->name] == node);

    node->toplevel = 0;
    lookup_table.erase(node->name);

    CdlLoadable loadable = dynamic_cast<CdlLoadable>(node);
    if (0 != loadable) {
        CYG_ASSERTC(loadable == node->owner);
        CYG_ASSERTC(this == node->parent);

        // Because remove_node_from_toplevel() is reversible, the
        // loadable should reappear in its old position. Hence we
        // had better keep track of that position. Note that
        // this code assumed that the remove_node and add_node
        // calls are exactly reversed.
        int i;
        for (i = 0; i < (int) this->contents.size(); i++) {
            if (this->contents[i] == node) {
                break;
            }
        }
        CYG_ASSERTC(i < (int) this->contents.size());
        node->remove_node_container_position = i;
        this->contents.erase(this->contents.begin() + i);
        node->parent = 0;

        // It is not clear that preserving the order of the loadables
        // in the toplevel is useful, but it is harmless.
        for (i = 0; i < (int) this->loadables.size(); i++) {
            if (this->loadables[i] == loadable) {
                break;
            }
        }
        CYG_ASSERTC(i < (int) this->loadables.size());
        loadable->remove_node_loadables_position = i;
        this->loadables.erase(this->loadables.begin() + i);
    }
    
    CYG_REPORT_RETURN();
}

void
CdlToplevelBody::remove_loadable_from_toplevel(CdlLoadable loadable)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::remove_loadable_from_toplevel");
    CYG_REPORT_FUNCARG2XV(this, loadable);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(loadable);

    const std::vector<CdlNode>& contents = loadable->get_owned();
    for (int i = contents.size() - 1; i >= 0; i--) {
        CdlToplevel toplevel = contents[i]->get_toplevel();
        CYG_LOOP_INVARIANT_ZERO_OR_CLASSC(toplevel);
        if (0 != toplevel) {
            CYG_LOOP_INVARIANTC(this == toplevel);
            this->remove_node_from_toplevel(contents[i]);
        }
    }
    
    CYG_REPORT_RETURN();
}

// Re-adding a node to a toplevel. This needs to undo all of the changes
// that may have been done by remove_node_from_toplevel() above.
void
CdlToplevelBody::add_node_to_toplevel(CdlNode node)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::add_node_to_toplevel");
    CYG_REPORT_FUNCARG2XV(this, node);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(node);
    CYG_ASSERTC(0 == node->toplevel);
    CYG_ASSERTC(0 != node->owner);

    CYG_ASSERTC(lookup_table.find(node->name) == lookup_table.end());
    node->toplevel = this;
    lookup_table[node->name] = node;

    CdlLoadable loadable = dynamic_cast<CdlLoadable>(node);
    if (0 != loadable) {
        CYG_ASSERTC(loadable == node->owner);
        CYG_ASSERTC(0 == node->parent);
        CYG_ASSERTC(-1 != node->remove_node_container_position);
        CYG_ASSERTC(node->remove_node_container_position <= (int) this->contents.size());

        this->contents.insert(this->contents.begin() + node->remove_node_container_position, node);
        node->remove_node_container_position = -1;
        node->parent = this;

        CYG_ASSERTC(-1 != loadable->remove_node_loadables_position);
        this->loadables.insert(this->loadables.begin() + loadable->remove_node_loadables_position, loadable);
        loadable->remove_node_loadables_position = -1;
    }

    CYG_REPORT_RETURN();
}

void
CdlToplevelBody::add_loadable_to_toplevel(CdlLoadable loadable)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::add_loadable_to_toplevel");
    CYG_REPORT_FUNCARG2XV(this, loadable);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(loadable);
    
    const std::vector<CdlNode>& contents = loadable->get_owned();
    for (int i = 0; i < (int) contents.size(); i++) {
        this->add_node_to_toplevel(contents[i]);
    }

    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------
// The second stage remove operation. This cannot be undone, and
// happens just before the node gets deleted and after a succesful
// remove_node_from_toplevel().
void
CdlToplevelBody::remove_node(CdlLoadable owner, CdlContainer parent, CdlNode node)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::remove_node");
    CYG_REPORT_FUNCARG3XV(owner, parent, node);
    CYG_PRECONDITION_CLASSC(node);
    CYG_PRECONDITION_ZERO_OR_CLASSC(owner);
    CYG_PRECONDITION_ZERO_OR_CLASSC(parent);
    CYG_PRECONDITIONC(node->owner  == owner);
    CYG_PRECONDITIONC(node->parent == parent);
    CYG_PRECONDITIONC(0 == node->toplevel);

    if (0 != owner) {
        node->owner = 0;
        owner->owned.erase(std::find(owner->owned.begin(), owner->owned.end(), node));
    }
    if (0 != parent) {
        node->parent = 0;
        parent->contents.erase(std::find(parent->contents.begin(), parent->contents.end(), node));
    }

    CYG_REPORT_RETURN();
}

// Changing a parent does not affect the node's standing in terms of the
// overall hierarchy or its owner, only the parent field.
void
CdlToplevelBody::change_parent(CdlLoadable owner, CdlContainer old_parent, CdlContainer new_parent, CdlNode node, int pos)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::change_parent");
    CYG_REPORT_FUNCARG6XV(this, owner, parent, new_parent, node, pos);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(old_parent);
    CYG_PRECONDITION_ZERO_OR_CLASSC(new_parent);
    CYG_PRECONDITION_CLASSC(node);
    CYG_PRECONDITIONC(node->owner  == owner);
    CYG_PRECONDITIONC(node->parent == old_parent);
    CYG_PRECONDITIONC(this == node->toplevel);
    CYG_PRECONDITIONC(lookup_table[node->name] == node);

    if (0 == new_parent) {
        new_parent = orphans;
    }
    old_parent->contents.erase(std::find(old_parent->contents.begin(), old_parent->contents.end(), node));
    node->parent = 0;

    if (-1 == pos) {
        new_parent->contents.push_back(node);
    } else {
        CYG_ASSERTC(pos <= (int) new_parent->contents.size());
        new_parent->contents.insert(new_parent->contents.begin() + pos, node);
    }
    node->parent = new_parent;

    CYG_REPORT_RETURN();
}

// Cleaning up orphans.
//
// Right now this is only relevant for interfaces. Consider the case
// where a loadable is being removed and that loadable defines an
// interface. There may be other loadables which still have
// "implements" properties affecting that interface, so instead of
// deleting the cdl_interface object it is necessary to turn it into
// an auto-generated orphan. At some stage there may no longer be
// any references to an interface, in which case it can be removed
// safely.
//
// In practice it is quite hard to do a clean-up purely on the basis
// of implements properties, for example there may be an external
// "requires" property as well which would need to have its references
// cleaned up, then the expression needs to get re-evaluated, etc.
// The transaction class does not currently provide a clean way
// in which a single object can be destroyed. Instead the code below
// checks for any references whose source is not the interface itself.

void
CdlToplevelBody::cleanup_orphans()
{
    CYG_REPORT_FUNCNAME("CdlToplevel::cleanup_orphans");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    // First figure out whether or not there are any interfaces along
    // these lines.
    std::vector<CdlInterface>   interfaces;
    const std::vector<CdlNode>& contents = orphans->get_contents();
    std::vector<CdlNode>::const_iterator node_i;

    for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
        CdlInterface intface = dynamic_cast<CdlInterface>(*node_i);
        if (0 == intface) {
            continue;
        }
        const std::vector<CdlReferrer>& referrers = intface->get_referrers();
        std::vector<CdlReferrer>::const_iterator ref_i;
        for (ref_i = referrers.begin(); ref_i != referrers.end(); ref_i++) {
            if (ref_i->get_source() != intface) {
                break;
            }
        }
        if (ref_i == referrers.end()) {
            // None of the existing references involve an "implements" property, so
            // this interface can be deleted.
            interfaces.push_back(intface);
        }
    }
    
    if (0 != interfaces.size()) {
        CYG_FAIL("Not yet implemented");
    }
}

//}}}
//{{{  Basic information                        

// ----------------------------------------------------------------------------

const std::vector<CdlLoadable>&
CdlToplevelBody::get_loadables() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::get_loadables", "result %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    const std::vector<CdlLoadable>& result = loadables;
    CYG_REPORT_RETVAL(&result);
    return result;
}


CdlNode
CdlToplevelBody::lookup(const std::string name) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::lookup", "result %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    CdlNode result = 0;
    std::map<std::string,CdlNode>::const_iterator i = lookup_table.find(name);
    if (i != lookup_table.end()) {
        result = i->second;
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

CdlInterpreter
CdlToplevelBody::get_interpreter() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::get_interpreter", "result %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlInterpreter result = interp;
    CYG_REPORT_RETVAL(result);
    return result;
}

std::string
CdlToplevelBody::get_description() const
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_description");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();
    return description;
}

void
CdlToplevelBody::set_description(std::string new_description)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::set_description");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    description = new_description;

    CYG_REPORT_RETURN();
}

std::string
CdlToplevelBody::get_class_name() const
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_class_name");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return "toplevel";
}

CdlTransaction
CdlToplevelBody::get_active_transaction() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::get_active_transaction", "result %p");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlTransaction result = transaction;
    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Conflict support                         

// ----------------------------------------------------------------------------
const std::list<CdlConflict>&
CdlToplevelBody::get_all_conflicts() const
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_all_conflicts");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    const std::list<CdlConflict>& result = conflicts;

    CYG_REPORT_RETURN();
    return result;
}

const std::list<CdlConflict>&
CdlToplevelBody::get_all_structural_conflicts() const
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_all_structural_conflicts");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    const std::list<CdlConflict>& result = structural_conflicts;

    CYG_REPORT_RETURN();
    return result;
}

// ----------------------------------------------------------------------------
// Resolve one or more conflicts. This involves creating a new transaction,
// invoking the per-transaction resolve code, and then CdlTransaction::body()
// takes care of everything else like propagation, further inference,
// callbacks, committing, ...
void
CdlToplevelBody::resolve_conflicts(const std::vector<CdlConflict>& conflicts_arg)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::resolve_conflicts");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlTransaction transact = CdlTransactionBody::make(this);
    
    std::vector<CdlConflict>::const_iterator conf_i;
    for (conf_i = conflicts_arg.begin(); conf_i != conflicts_arg.end(); conf_i++) {
        CYG_LOOP_INVARIANT_CLASSC(*conf_i);
        CYG_LOOP_INVARIANTC(0 == (*conf_i)->get_transaction());

        if (((*conf_i)->resolution_implemented()) &&
            !transact->has_conflict_been_cleared(*conf_i) &&
            !(*conf_i)->has_known_solution() &&
            !(*conf_i)->has_no_solution() ) {
            transact->resolve(*conf_i);
        }
    }
    transact->body();
    delete transact;
    
    CYG_REPORT_RETURN();
}

void
CdlToplevelBody::resolve_all_conflicts()
{
    CYG_REPORT_FUNCNAME("CdlToplevel::resolve_all_conflicts");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlTransaction transact = CdlTransactionBody::make(this);
    std::list<CdlConflict>::const_iterator conf_i;

    for (conf_i = conflicts.begin(); conf_i != conflicts.end(); conf_i++) {
        CYG_LOOP_INVARIANT_CLASSC(*conf_i);
        CYG_LOOP_INVARIANTC(0 == (*conf_i)->get_transaction());
        if ((*conf_i)->resolution_implemented() &&
            !transact->has_conflict_been_cleared(*conf_i) &&
            !(*conf_i)->has_known_solution() &&
            !(*conf_i)->has_no_solution() ) {
            transact->resolve(*conf_i);
        }
    }
    for (conf_i = structural_conflicts.begin(); conf_i != structural_conflicts.end(); conf_i++) {
        CYG_LOOP_INVARIANT_CLASSC(*conf_i);
        CYG_LOOP_INVARIANTC(0 == (*conf_i)->get_transaction());
        if (((*conf_i)->resolution_implemented()) &&
            !transact->has_conflict_been_cleared(*conf_i) &&
            !(*conf_i)->has_known_solution() &&
            !(*conf_i)->has_no_solution() ) {
            transact->resolve(*conf_i);
        }
    }

    transact->body();
    delete transact;

    CYG_REPORT_RETURN();
}

//}}}
//{{{  Limbo support                            

// ----------------------------------------------------------------------------
// Limbo support. This is basically trivial, an STL map does all the
// right things.
void
CdlToplevelBody::set_limbo_value(CdlValuable valuable)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::set_limbo_value");
    CYG_REPORT_FUNCARG2XV(this, valuable);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(valuable);

    limbo[valuable->get_name()] = valuable->get_whole_value();

    CYG_REPORT_RETURN();
}

bool
CdlToplevelBody::has_limbo_value(std::string name) const
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::has_limbo_value", "result %d");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    bool result = false;
    if (limbo.find(name) != limbo.end()) {
        result = true;
    }

    CYG_REPORT_RETVAL(result);
    return result;
}

CdlValue
CdlToplevelBody::get_limbo_value(std::string name) const
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_limbo_value");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    std::map<std::string,CdlValue>::const_iterator limbo_i = limbo.find(name);
    CYG_ASSERTC(limbo_i != limbo.end());

    CYG_REPORT_RETURN();
    return limbo_i->second;
}

CdlValue
CdlToplevelBody::get_and_remove_limbo_value(std::string name)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_and_remove_limbo_value");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    std::map<std::string,CdlValue>::iterator limbo_i = limbo.find(name);
    CYG_ASSERTC(limbo_i != limbo.end());

    CdlValue local_copy = limbo_i->second;
    limbo.erase(limbo_i);

    CYG_REPORT_RETURN();
    return local_copy;
}

void
CdlToplevelBody::clear_limbo()
{
    CYG_REPORT_FUNCNAME("CdlToplevel::clear_limbo");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    limbo.clear();

    CYG_REPORT_RETURN();
}

//}}}
//{{{  Persistence support                      

//{{{  Description                      

// ----------------------------------------------------------------------------
// Toplevels do not have any data specifically associated with them which
// should go into savefiles (not quite true, there is a description field,
// but that can be handled easily by the derived classes).
//
// However there is a need in the library for some generic savefile support:
//
// 1) it is an important goal that savefiles should be self-describing.
//    This is handled by having a header section at the start of each
//    savefile which describes what commands will appear in the savefile
//    (note that savefiles are actually just Tcl scripts). In addition
//    each savefile contains a version number so that individual commands
//    can detect and adapt to older versions of the library.
//
// 2) savefiles should also be extensible, so for example a GUI tool should
//    be able to add its own information. This can be toplevel information,
//    i.e. a new command that gets executed at the savefile's toplevel,
//    or it can be a subcommand extending an existing command such as
//    cdl_option. Right now only one level of nesting is available, but
//    this should suffice.
//
// 3) extensibility means that the application reading in a savefile may
//    not support the same set of commands as the application that generated
//    the savefile. Care is taken to avoid loss of data. However exact
//    ordering is not guaranteed to be preserved, and neither is formatting.
//
// These needs are interrelated, and supported by the CdlToplevelBody
// class. The functions of interest are:
//
// virtual void initialize_savefile_support()
//    This should be called from higher-level code such as
//    CdlConfiguration::initialize_savefile_support() at the start of
//    any savefile-related operation.
//
//    The support operates on a per-application basis rather than a
//    per-toplevel basis, in spite of being a virtual member function
//    rather than a static. A virtual member function facilitates
//    automatic initialization. This causes some problems if you need
//    to load in toplevels with different application-specific
//    extensions, but it makes life a lot simpler for the application.
//
// static bool savefile_support_initialized()
//    Has there been a call to initialize_savefile_support() yet?
//
// virtual void add_savefile_command(std::string, CdlSaveCallback, CdlInterpreterCommand)
//    Register a new savefile toplevel command. The string must be a
//    valid command name. The callback function will be 0 for savedata
//    supported directly by the library, non-zero for application-specific
//    data, and is invoked during a save operation to allow application
//    code to add extra data to the savefile. The command procedure must
//    be provided and is registered with the Tcl interpreter.
//
// virtual void add_savefile_subcommand(std::string cmd, std::string subcommand, CdlSaveCallback, CdlInterpreterCommand)
//    Typically savefile commands take the form <command> <name> <body>,
//    where <body> contains a set of subcommands. This function is used
//    to register a new subcommand.
//
// void save_command_details(CdlInterpreter, Tcl_Channel, int)
//    This should be invoked early on when generating a savefile. Its
//    purpose is to store information about the current set of savefile
//    commands in the savefile, thus making savefiles self-describing.
//    This command acts on a per-toplevel basis, since each toplevel
//    may have been created via a load operation and hence may contain
//    unrecognised commands.
//
// static void get_savefile_commands(std::vector<CdlInterpreterCommandEntry>&)
//    Work out the set of commands that should be supported by the
//    interpreter used to process a savefile. Note that this set gets
//    updated magically by savefile_handle_command().
//
// static void get_savefile_subcommands(std::string, std::vector<CdlInterpreterCommandEntry>&)
//    Ditto for subcommands.
//
// static int savefile_handle_command(CdlInterpreter, int, char**)
//    This implements cdl_savefile_command, and makes sure that
//    all of the commands that may be present in the savefile will
//    be processed.
//
// static int savefile_handle_unsupported(CdlInterpreter, int, char**)
//    This takes care of commands present in the savefile which are
//    not supported by the current application.
//
// static int savefile_handle_unknown(CdlInterpreter, int, char**)
//    This is an implementation of "unknown" suitable for savefiles.
//    All commands that may get used in a savefile should be specified
//    via cdl_savefile_command, so an unknown command is an error.
//
// cdl_int get_library_savefile_version()
//    Savefiles contain a format version number. This function can be used
//    to determine the current version used in the library.
//
// int savefile_handle_version(CdlInterpreter, int, char**)
//    This is the implementation of the cdl_savefile_version command. It
//    stores the version information in the interpreter, allowing it
//    to be retrieved by other commands.
//
// cdl_int get_savefile_version(CdlInterpreter)
//    This can be used to retrieve the version number that was present
//    in the current savefile.
//
//    The version number should not be used for application-specific
//    commands. It is possible for a savefile to be read in by a
//    different program and then updated: the updated savefile will
//    contain the unrecognised commands unchanged, but it will also
//    have the version number corresponding to that program rather
//    than to the original savefile.
//
// void save_conflicts(CdlInterpreter, Tcl_Channel, int)
//    Output details of all the conflicts in the current configuration
//
// void save_separator(CdlInterpreter, Tcl_Channel, int)
//    A utility to add a separator line to a savefile. This has to
//    go somewhere....
//
// FIXME: add limbo support

//}}}
//{{{  Statics and initialization       

// ----------------------------------------------------------------------------
bool CdlToplevelBody::savefile_commands_initialized = false;
std::vector<CdlSavefileCommand> CdlToplevelBody::savefile_commands;
std::map<std::string,std::vector<CdlSavefileCommand> > CdlToplevelBody::savefile_subcommands;

void
CdlToplevelBody::initialize_savefile_support()
{
    CYG_REPORT_FUNCNAME("CdlToplevel::initialize_savefile_support");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
    
    // This assignment avoids circular dependencies. It is not
    // completely accurate but close enough - the full set of
    // commands will be initialised shortly.
    savefile_commands_initialized = true;

    // The commands cdl_savefile_version and cdl_command are a core
    // part of the CDL savefile support.
    add_savefile_command("cdl_savefile_version", 0, &savefile_handle_version);
    add_savefile_command("cdl_savefile_command", 0, &savefile_handle_command);

    CYG_REPORT_RETURN();
}

bool
CdlToplevelBody::savefile_support_initialized()
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::check_savefile_support_initialized", "result %d");

    bool result = savefile_commands_initialized;
    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Command details                  

// ----------------------------------------------------------------------------
// These routines are used to keep track of the savefile commands that
// are understood by the current application. There may have been
// additional per-toplevel commands when a savefile was read in, but
// these are stored separately.
//
// Currently there is only support for toplevel savefile commands
// and for one level of subcommands. Multiple levels can probably
// be accommodated by using the equivalent of a directory separator
// in the savefile_subcommands map key.

void
CdlToplevelBody::add_savefile_command(std::string name, CdlSaveCallback save_callback, CdlInterpreterCommand load_command)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::add_savefile_command");
    CYG_REPORT_FUNCARG3XV(this, save_callback, load_command);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITIONC("" != name);

    if (!savefile_commands_initialized) {
        this->initialize_savefile_support();
    }
    
    std::vector<CdlSavefileCommand>::const_iterator cmd_i;
    for (cmd_i = savefile_commands.begin(); cmd_i != savefile_commands.end(); cmd_i++) {
        if (cmd_i->name == name) {
            if ((cmd_i->save_callback != save_callback) || (cmd_i->load_command != load_command)) {
                CYG_FAIL("Internal error: attempt to define two toplevel savefile commands with the same name.");
            }
            break;
        }
    }
    if (cmd_i == savefile_commands.end()) {
        CdlSavefileCommand cmd;
        cmd.name                = name;
        cmd.save_callback       = save_callback;
        cmd.load_command        = load_command;
        savefile_commands.push_back(cmd);

        std::vector<CdlSavefileCommand> subcommands;
        savefile_subcommands[name] = subcommands;
    }

    CYG_REPORT_RETURN();
}

// Add a new subcommand for a given command. The command should have been
// defined already.
void
CdlToplevelBody::add_savefile_subcommand(std::string cmd, std::string subcommand, CdlSaveCallback save_callback,
                                         CdlInterpreterCommand load_command)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::add_savefile_subcommand");
    CYG_REPORT_FUNCARG3XV(this, save_callback, load_command);
    CYG_PRECONDITION_THISC();
    
    if (!savefile_commands_initialized) {
        this->initialize_savefile_support();
    }
    
    std::vector<CdlSavefileCommand>::iterator cmd_i;
    for (cmd_i = savefile_commands.begin(); cmd_i != savefile_commands.end(); cmd_i++) {
        if (cmd_i->name == cmd) {
            break;
        }
    }
    CYG_ASSERTC(cmd_i != savefile_commands.end());

    for (cmd_i = savefile_subcommands[cmd].begin(); cmd_i != savefile_subcommands[cmd].end(); cmd_i++) {
        if (cmd_i->name == subcommand) {
            if ((cmd_i->save_callback != save_callback) || (cmd_i->load_command != load_command)) {
                CYG_FAIL("Internal error: attempt to define two subcommands with the same name.");
            }
        }
    }
    if (cmd_i == savefile_subcommands[cmd].end()) {
        CdlSavefileCommand new_subcommand;
        new_subcommand.name          = subcommand;
        new_subcommand.save_callback = save_callback;
        new_subcommand.load_command  = load_command;
        savefile_subcommands[cmd].push_back(new_subcommand);
    }

    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------
// This member function is invoked by e.g. CdlConfiguraton::save() to
// take care of the generic savefile information, specifically the
// savefile format version number and the various commands and subcommands
// Note that it has to cope with per-toplevel commands from the original
// savefile, as well as the global set.

void
CdlToplevelBody::save_command_details(CdlInterpreter interp, Tcl_Channel chan, int indentation, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::save_command_details");
    CYG_REPORT_FUNCARG4XV(this, interp, chan, indentation);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);
    CYG_ASSERTC(0 == indentation);

    // The parent code should have provided the first couple of lines,
    // identifying whether this is an eCos configuration or some other
    // CDL-based entity.
    //
    // Immediately after these lines we want a nice big comment
    // telling people that they can edit bits of this file, but
    // that other bits are automatically generated and will
    // be overwritten.

    if (!minimal) {
        interp->write_data(chan,
"# This section contains information about the savefile format.\n\
# It should not be edited. Any modifications made to this section\n\
# may make it impossible for the configuration tools to read\n\
# the savefile.\n\
\n");
    }

    // Next output details of the savefile format version. This allows
    // all other code to adapt to the version.
    std::string savefile_data;
    Cdl::integer_to_string(savefile_version, savefile_data);
    savefile_data = "cdl_savefile_version " + savefile_data + ";\n";

    std::vector<CdlSavefileCommand>::const_iterator cmd_i, cmd_j;
    std::vector<std::string>::const_iterator cmd_k, cmd_l;
    
    for (cmd_i = savefile_commands.begin(); cmd_i != savefile_commands.end(); cmd_i++) {
        savefile_data += "cdl_savefile_command " + cmd_i->name + " ";
        
        if ((0 == savefile_subcommands[cmd_i->name].size()) &&
            (0 == this->unsupported_savefile_subcommands[cmd_i->name].size())) {
            
            savefile_data += "{};\n";
            
        } else {
            
            savefile_data += "{";
            for (cmd_j = savefile_subcommands[cmd_i->name].begin();
                 cmd_j != savefile_subcommands[cmd_i->name].end();
                 cmd_j++) {
                
                savefile_data += " " + cmd_j->name;
            }
            for (cmd_l = this->unsupported_savefile_subcommands[cmd_i->name].begin();
                 cmd_l != this->unsupported_savefile_subcommands[cmd_i->name].end();
                 cmd_l++) {

                savefile_data += " " + *cmd_l;
            }
            savefile_data += " };\n";
        }
    }
    for (cmd_k = this->unsupported_savefile_commands.begin();
         cmd_k != this->unsupported_savefile_commands.end();
         cmd_k++) {
        savefile_data += "cdl_savefile_command " + *cmd_k + " ";
        if (0 == this->unsupported_savefile_subcommands[*cmd_k].size()) {
            
            savefile_data += "{};\n";
            
        } else {

            savefile_data += "{";
            for (cmd_l = this->unsupported_savefile_subcommands[*cmd_k].begin();
                 cmd_l != this->unsupported_savefile_subcommands[*cmd_k].end();
                 cmd_l++) {

                savefile_data += " " + *cmd_l;
            }
            savefile_data += " };\n";
        }
    }
    savefile_data += "\n";

    interp->write_data(chan, savefile_data);

    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------
// Get hold of the commands that should be added to the interpreter for
// processing a savefile. Note that this will only deal with commands
// supported by the library or the application, not any additional
// unsupported commands specified in the savefile itself. The latter
// will be taken care of magically by savefile_handle_command().

void
CdlToplevelBody::get_savefile_commands(std::vector<CdlInterpreterCommandEntry>& cmds)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_savefile_commands");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlInterpreterCommandEntry local_cmd;
    std::vector<CdlSavefileCommand>::const_iterator cmd_i;
    for (cmd_i = savefile_commands.begin(); cmd_i != savefile_commands.end(); cmd_i++) {
        // NOTE: this use of c_str() is somewhat dubious, but the string should not
        // change so the c_str() array should remain ok as well.
        local_cmd.name = cmd_i->name;
        local_cmd.command = cmd_i->load_command;
        cmds.push_back(local_cmd);
    }

    // There is no point in iterating over this->unsupported_savefile_commands,
    // that vector should be empty since we have not actually started
    // processing the savefile yet.
    CYG_ASSERTC(0 == this->unsupported_savefile_commands.size());

    // Add an implementation of the "unknown" command.
    local_cmd.name = "unknown";
    local_cmd.command = &CdlToplevelBody::savefile_handle_unknown;
    cmds.push_back(local_cmd);
    
    CYG_REPORT_RETURN();
}

// Having repeated calls of this for e.g. every cdl_option statement in
// a savefile is expensive. Some sort of caching mechanism should be
// used to avoid unnecessary overheads.
void
CdlToplevelBody::get_savefile_subcommands(std::string main_command, std::vector<CdlInterpreterCommandEntry>& cmds)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::get_savefile_subcommands");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    CdlInterpreterCommandEntry local_cmd;
    std::vector<CdlSavefileCommand>::const_iterator cmd_i;
    for (cmd_i = savefile_subcommands[main_command].begin();
         cmd_i != savefile_subcommands[main_command].end();
         cmd_i++) {

        local_cmd.name = cmd_i->name.c_str();
        local_cmd.command = cmd_i->load_command;
        cmds.push_back(local_cmd);
    }

    std::vector<std::string>::const_iterator cmd_j;
    for (cmd_j = this->unsupported_savefile_subcommands[main_command].begin();
         cmd_j != this->unsupported_savefile_subcommands[main_command].end();
         cmd_j++) {

        local_cmd.name = cmd_j->c_str();
        local_cmd.command = &savefile_handle_unsupported;
        cmds.push_back(local_cmd);
    }

    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------
// This implements cdl_savefile_command which should appear near the
// start of savefiles. The command takes two arguments, a primary
// command name and a set of subcommand names.
int
CdlToplevelBody::savefile_handle_command(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAME("CdlToplevel::savefile_handle_command");
    CYG_REPORT_FUNCARG2XV(interp, argc);
    CYG_PRECONDITION_CLASSC(interp);
    
    CdlToplevel toplevel = interp->get_toplevel();
    CYG_ASSERT_CLASSC(toplevel);
    CYG_ASSERTC(toplevel->savefile_commands_initialized);

    if (1 == argc) {
        CdlParse::report_error(interp, "", "Expecting at least one argument to cdl_savefile_command");
    } else if (2 == argc) {
        CdlParse::report_warning(interp, "",
                                 std::string("Missing third argument to `cdl_savefile_command ") + argv[1] +
                                 "'\n.Expecting an additional list of subcommands.");
    } else if (3 != argc) {
        CdlParse::report_warning(interp, "", std::string("Unexpected additional arguments to `cdl_savefile_command ") +
                                 argv[1] + " { " + argv[2] + " }");
    }

    // Is the primary command one of the known ones?
    bool known_command = false;
    std::vector<CdlSavefileCommand>::const_iterator cmd_i;
    std::vector<std::string>::const_iterator cmd_j;
        
    if (1 != argc) {
        // Make sure that the primary command is known.
        for (cmd_i = savefile_commands.begin(); cmd_i != savefile_commands.end(); cmd_i++) {
            if (cmd_i->name == argv[1]) {
                known_command = true;
                break;
            }
        }
        if (!known_command) {
            // Detect duplicate definitions, just in case.
            for (cmd_j = toplevel->unsupported_savefile_commands.begin();
                 cmd_j != toplevel->unsupported_savefile_commands.end();
                 cmd_j++) {
                if (*cmd_j == argv[1]) {
                    break;
                }
            }
            if (cmd_j == toplevel->unsupported_savefile_commands.end()) {
                toplevel->unsupported_savefile_commands.push_back(argv[1]);
            }
        }
    }

    // Now take care of all the subcommands.
    if (2 != argc) {

        int          list_count = 0;
        const char** list_entries = 0;

        try {
            Tcl_Interp* tcl_interp = interp->get_tcl_interpreter();
            if (TCL_OK != Tcl_SplitList(tcl_interp, CDL_TCL_CONST_CAST(char*, argv[2]), &list_count, CDL_TCL_CONST_CAST(char***, &list_entries))) {
                CdlParse::report_error(interp, "", std::string("Invalid subcommand list for `cdl_command ") + argv[1] + "'.");
            }

            for (int i = 0; i < list_count; i++) {
                bool known_subcommand = false;
                if (known_command) {
                    for (cmd_i = savefile_subcommands[argv[1]].begin();
                         cmd_i != savefile_subcommands[argv[1]].end();
                         cmd_i++) {

                        if (cmd_i->name == list_entries[i]) {
                            known_subcommand = true;
                        }
                    }
                }
                if (!known_subcommand) {
                    for (cmd_j = toplevel->unsupported_savefile_subcommands[argv[1]].begin();
                         cmd_j != toplevel->unsupported_savefile_subcommands[argv[1]].end();
                         cmd_j++) {

                        if (*cmd_j == list_entries[i]) {
                            known_subcommand = true;
                            break;
                        }
                    }
                }
                if (!known_subcommand) {
                    toplevel->unsupported_savefile_subcommands[argv[1]].push_back(list_entries[i]);
                }
                
            }

            if (0 != list_entries) {
                Tcl_Free((char *)list_entries);
            }
            
        } catch(...) {
            if (0 != list_entries) {
                Tcl_Free((char *)list_entries);
            }
            throw;
        }
    }
    
    return TCL_OK;
}

//}}}
//{{{  handle_unsupported()             

// ----------------------------------------------------------------------------
// This function is invoked when an unsupported command is detected in
// a savefile. It turns the data back into a string which can go back
// into the next savefile, thus avoiding loss of data.
//
// It is possible that the savefile contents involved variable or
// command substitution. If so then this information will have been
// lost, there is no simple way of retrieving this from the interpreter.
// Care has to be taken when generating the new command string to
// perform appropriate quoting.
//
// Ideally the original data could be extracted from the Tcl
// interpreter somehow. Currently this data is not readily available,
// and the resulting string may not match the original data exactly.
int
CdlToplevelBody::savefile_handle_unsupported(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAME("CdlNode::savefile_handle_unsupported");
    CYG_REPORT_FUNCARG2XV(interp, argc);
    CYG_ASSERT_CLASSC(interp);

    CdlToplevel toplevel = interp->get_toplevel();
    CYG_ASSERT_CLASSC(toplevel);
    CdlNode node = interp->get_node();
    CYG_ASSERT_ZERO_OR_CLASSC(node);

    std::string tmp = CdlInterpreterBody::quote(argv[0]);
    for (int i = 1; i < argc; i++) {
        tmp = tmp + " " + CdlInterpreterBody::quote(argv[i]);
    }
    // Unknown commands may occur at the toplevel or inside
    // e.g. a cdl_option body. Toplevels are also nodes.
    if (0 == node) {
        toplevel->unsupported_savefile_toplevel_strings.push_back(tmp);
    } else {
        node->unsupported_savefile_strings.push_back(tmp);
    }

    return TCL_OK;
}

//}}}
//{{{  save_unsupported()               

// ----------------------------------------------------------------------------
// This code deals with any toplevel data present in the original save
// file that was not recognised.
void
CdlToplevelBody::save_unsupported_commands(CdlInterpreter interp, Tcl_Channel chan, int indentation, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlToplevelBody::save_unsupported_commands");
    CYG_REPORT_FUNCARG3XV(this, interp, chan);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);
    CYG_PRECONDITIONC(0 == indentation);

    std::string data = "\n";
    std::vector<std::string>::const_iterator str_i;
    for (str_i = unsupported_savefile_toplevel_strings.begin();
         str_i != unsupported_savefile_toplevel_strings.end();
         str_i++) {
        data += *str_i + " ;\n";
    }
    interp->write_data(chan, data);

    CYG_UNUSED_PARAM(bool, minimal);
    CYG_REPORT_RETURN();
}

//}}}
//{{{  handle_unknown()                 

// ----------------------------------------------------------------------------

int
CdlToplevelBody::savefile_handle_unknown(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAME("CdlToplevel::savefile_handle_unknown");
    CYG_REPORT_FUNCARG2XV(interp, argc);
    CYG_PRECONDITION_CLASSC(interp);

    CdlParse::report_error(interp, "", std::string("Unknown command `") + argv[1] + "'.");
    
    CYG_UNUSED_PARAM(int, argc);
    return TCL_OK;
}

//}}}
//{{{  versioning                       

// ----------------------------------------------------------------------------
// Savefiles include a version number that can be used by library
// commands to cope with old and incompatible savefiles. This
// version number should be changed only very rarely, hopefully never.
cdl_int CdlToplevelBody::savefile_version = 1;

cdl_int
CdlToplevelBody::get_library_savefile_version()
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::get_library_savefile_version", "result %ld");

    cdl_int result = savefile_version;
    CYG_REPORT_RETVAL((long) result);
    return result;
}

// This implements the cdl_savefile_version command. It stores the
// version number with the interpreter, allowing it to be retrieved
// by other commands.
int
CdlToplevelBody::savefile_handle_version(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAME("CdlToplevel::savefile_handle_version");
    CYG_REPORT_FUNCARG2XV(interp, argc);
    CYG_PRECONDITION_CLASSC(interp);

    if (1 == argc) {
        CdlParse::report_warning(interp, "", "Expecting one argument to cdl_savefile_version");
    } else {
        if (2 != argc) {
            CdlParse::report_warning(interp, "",
                                     std::string("Unexpected number of arguments to cdl_savefile_version\n") +
                                     "There should be exactly one argument, the savefile format version number.");
        }
        cdl_int tmp;
        if (!Cdl::string_to_integer(argv[1], tmp)) {
            CdlParse::report_error(interp, "",
                                   std::string("Invalid version number `") + argv[1] + "' for cdl_savefile_version");
        } else {
            // Store the data in a Tcl variable. This is at least as convenient
            // as assoc data.
            interp->set_variable("cdl_savefile_version", argv[1]);
        }
    }

    return TCL_OK;
}

cdl_int
CdlToplevelBody::get_savefile_version(CdlInterpreter interp)
{
    CYG_REPORT_FUNCNAMETYPE("CdlToplevel::get_savefile_version", "result %ld");
    CYG_REPORT_FUNCARG1XV(interp);
    CYG_PRECONDITION_CLASSC(interp);
    
    cdl_int result = 0;
    std::string version = interp->get_variable("cdl_savefile_version");
    if ("" != version) {
        if (!Cdl::string_to_integer(version, result)) {
            CdlParse::report_error(interp, "", std::string("Invalid cdl_savefile_version number `") + version + "'");
        }
    }

    CYG_REPORT_RETVAL((long) result);
    return result;
}

//}}}
//{{{  conflicts                        

// ----------------------------------------------------------------------------
void
CdlToplevelBody::save_conflicts(CdlInterpreter interp, Tcl_Channel chan, int indentation, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::save_conflicts");
    CYG_REPORT_FUNCARG4XV(this, interp, chan, indentation);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);
    CYG_PRECONDITIONC(0 == indentation);

    // For now only comments are generated here, so in a minimal save
    // there is no need for any of this data
    if (!minimal) {
        std::string data = "";
        if (0 == conflicts.size()) {
            data += "# There are no conflicts.\n";
        } else {
            std::string tmp;
            Cdl::integer_to_string((cdl_int) this->conflicts.size(), tmp);
            data += "# There are " + tmp + " conflicts.\n";

            std::list<CdlConflict>::const_iterator conf_i;
            for (conf_i = this->conflicts.begin(); conf_i != this->conflicts.end(); conf_i++) {
                data += "#\n";

                CdlNode node = (*conf_i)->get_node();
                CdlProperty prop = (*conf_i)->get_property();
                std::string description = (*conf_i)->get_explanation();
                data += "# " + node->get_class_name() + " "  + node->get_name() + "\n";
                data += "#   Property " + prop->get_property_name() + "\n";
                data += CdlInterpreterBody::multiline_comment(description, 0, 2) + "\n";
            }
            data += '\n';
        }
        data += '\n';

        interp->write_data(chan, data);
    }
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  save_separator()                 

// ----------------------------------------------------------------------------
void
CdlToplevelBody::save_separator(CdlInterpreter interp, Tcl_Channel chan, std::string msg, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlToplevel::save_separator");
    CYG_REPORT_FUNCARG1XV(interp);
    CYG_PRECONDITION_CLASSC(interp);

    if (!minimal) {
        std::string data = "# ---- " + msg + ' ';
        if (72 > data.size()) {
            data += std::string(72 - data.size(), '-');
        }
        data += '\n';
        interp->write_data(chan, data);
    }
    
    CYG_REPORT_RETURN();
}

//}}}

//}}}
//{{{  check_this()                             

// ----------------------------------------------------------------------------
bool
CdlToplevelBody::check_this(cyg_assert_class_zeal zeal) const
{
    if (CdlToplevelBody_Magic != cdltoplevelbody_cookie) {
        return false;
    }
    CYGDBG_MEMLEAK_CHECKTHIS();

    if ((zeal == cyg_extreme) || (zeal == cyg_thorough)) {
        if (!interp->check_this(cyg_quick)) {
            return false;
        }
        if ((0 == orphans) || !orphans->check_this(cyg_quick)) {
            return false;
        }
        if (orphans != *contents.begin()) {
            return false;
        }
        if ((0 != transaction) && !transaction->check_this(cyg_quick)) {
            return false;
        }
    }

    return CdlContainerBody::check_this(zeal);
}

//}}}

//}}}
//{{{  CdlUserVisiblebody               

//{{{  Basics                           

// ----------------------------------------------------------------------------
// All user-visible object can have (and usually should have) three
// properties: display (originally known as alias), description, and
// doc. There is no additional data associated with a user-visible
// object, everything is handled via the properties.

CdlUserVisibleBody::CdlUserVisibleBody()
{
    CYG_REPORT_FUNCNAME("CdlUserVisible:: default constructor");
    CYG_REPORT_FUNCARG1XV(this);

    cdluservisiblebody_cookie  = CdlUserVisibleBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();
    
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

CdlUserVisibleBody::~CdlUserVisibleBody()
{
    CYG_REPORT_FUNCNAME("CdlUserVisible:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    cdluservisiblebody_cookie = CdlUserVisibleBody_Invalid;
    CYGDBG_MEMLEAK_DESTRUCTOR();
    
    CYG_REPORT_RETURN();
}

std::string
CdlUserVisibleBody::get_class_name() const
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::get_class_name");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return "uservisible";
}

bool
CdlUserVisibleBody::check_this(cyg_assert_class_zeal zeal) const
{
    if (CdlUserVisibleBody_Magic != cdluservisiblebody_cookie) {
        return false;
    }
    CYGDBG_MEMLEAK_CHECKTHIS();
    return CdlNodeBody::check_this(zeal);
}

//}}}
//{{{  Extracting information           

// ----------------------------------------------------------------------------
// Extracting the information.

std::string
CdlUserVisibleBody::get_display() const
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::get_display");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    std::string result = "";
    CdlProperty property = get_property(CdlPropertyId_Display);
    if (0 != property) {
        
        CdlProperty_String string_property = dynamic_cast<CdlProperty_String>(property);
        CYG_ASSERTC(0 != string_property);

        result = string_property->get_string();
    }

    CYG_REPORT_RETURN();
    return result;
}

std::string
CdlUserVisibleBody::get_description() const
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::get_description");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    std::string result = "";
    CdlProperty property = get_property(CdlPropertyId_Description);
    if (0 != property) {
        
        CdlProperty_String string_property = dynamic_cast<CdlProperty_String>(property);
        CYG_ASSERTC(0 != string_property);

        result = string_property->get_string();
    }

    CYG_REPORT_RETURN();
    return result;
}

std::string
CdlUserVisibleBody::get_doc() const
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::get_doc");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    std::string result = "";
    CdlProperty property = get_property(CdlPropertyId_Doc);
    if (0 != property) {
        
        CdlProperty_String string_property = dynamic_cast<CdlProperty_String>(property);
        CYG_ASSERTC(0 != string_property);

        result = string_property->get_string();
    }

    CYG_REPORT_RETURN();
    return result;
}

std::string
CdlUserVisibleBody::get_doc_url() const
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::get_doc_url");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    std::string result = "";
    std::string doc_property = get_doc();
    if ("" != doc_property) {
        CdlLoadable owner = get_owner();
        CYG_ASSERTC(0 != owner);
        result = owner->find_absolute_file(doc_property, "doc", true);
    }

    CYG_REPORT_RETURN();
    return result;
}

//}}}
//{{{  Parsing                          

// ----------------------------------------------------------------------------
// Parsing support. There are three property parsers to be added to
// the current set. The checking code should make sure that at most
// one of each property has been specified. In addition it is
// necessary to recurse into the base class.

void
CdlUserVisibleBody::add_property_parsers(std::vector<CdlInterpreterCommandEntry>& parsers)
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::add_property_parsers");

    static CdlInterpreterCommandEntry commands[] =
    {
        CdlInterpreterCommandEntry("display",     &parse_display),
        CdlInterpreterCommandEntry("description", &parse_description),
        CdlInterpreterCommandEntry("doc",         &parse_doc),
        CdlInterpreterCommandEntry("",            0)
    };

    for (int i = 0; commands[i].command != 0; i++) {
        std::vector<CdlInterpreterCommandEntry>::const_iterator j;
        for (j = parsers.begin(); j != parsers.end(); j++) {
            if (commands[i].name == j->name) {
                if (commands[i].command != j->command) {
                    CYG_FAIL("Property names are being re-used");
                }
                break;
            }
        }
        if (j == parsers.end()) {
            parsers.push_back(commands[i]);
        }
    }
    CdlNodeBody::add_property_parsers(parsers);
    
    CYG_REPORT_RETURN();
}

void
CdlUserVisibleBody::check_properties(CdlInterpreter interp)
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::check_properties");
    CYG_REPORT_FUNCARG2XV(this, interp);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);

    if (count_properties(CdlPropertyId_Display) > 1) {
        CdlParse::report_error(interp, "", "There should be at most one display property.");
    }
    if (count_properties(CdlPropertyId_Description) > 1) {
        CdlParse::report_error(interp, "", "There should be at most one description property.");
    }
    if (count_properties(CdlPropertyId_Doc) > 1) {
        CdlParse::report_error(interp, "", "There should be at most one doc property.");
    }
    
    // FIXME: more validation of the doc property, in particular check that
    // the resulting URL would be either remote or to an existing file.

    CdlNodeBody::check_properties(interp);
    
    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------
// Syntax: description <string>

int
CdlUserVisibleBody::parse_description(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAMETYPE("parse_description", "result %d");

    int result = CdlParse::parse_string_property(interp, argc, argv, CdlPropertyId_Description, 0, 0);
    
    CYG_REPORT_RETVAL(result);
    return result;
}


// ----------------------------------------------------------------------------
// Syntax: display <short description>

int
CdlUserVisibleBody::parse_display(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAMETYPE("parse_display", "result %d");

    int result = CdlParse::parse_string_property(interp, argc, argv, CdlPropertyId_Display, 0, 0);
    
    CYG_REPORT_RETVAL(result);
    return result;
}

// ----------------------------------------------------------------------------
// Syntax: doc <url>

int
CdlUserVisibleBody::parse_doc(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAMETYPE("parse_doc", "result %d");
    
    int result = CdlParse::parse_string_property(interp, argc, argv, CdlPropertyId_Doc, 0, 0);
    
    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Persistence                      

// ----------------------------------------------------------------------------
// There is no data in a user visible object that users will want to edit,
// but the display string, the documentation, and the description are all
// useful and should be present in the savefile as comments.
//
// The intention is that the UserVisible information appears immediately
// above the option/component/whatever definition, e.g.:
// # <display string.
// # doc <URL>
// # <description
// # ...>
// #

void
CdlUserVisibleBody::save(CdlInterpreter interp, Tcl_Channel chan, int indentation, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlUserVisible::save");
    CYG_REPORT_FUNCARG5XV(this, interp, chan, indentation, minimal);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);
    CYG_ASSERTC(0 == indentation);

    if (!minimal) {
        std::string data = "";
        std::string display = get_display();
        if ("" != display) {
            data = std::string("# ") + display + "\n";
        }
        // Note that this uses get_doc(), not get_doc_url(). The latter
        // would give an absolute pathname that is applicable to the
        // current user, but it would change if a different user loaded
        // and saved the file. This is a bad idea in terms of version
        // control.
        std::string doc = get_doc();
        if ("" != doc) {
            data += "# doc: " + doc + "\n";
        }
        std::string description = get_description();
        if ("" != description) {
            unsigned int i = 0;
            while (i < description.size()) {
                data += "# ";
                while ((i < description.size()) && isspace(description[i])) {
                    i++;
                }
                while ((i < description.size()) && ('\n' != description[i])) {
                    data += description[i++];
                }
                data += '\n';
            }
        }
        data += "#\n";
        
        interp->write_data(chan, data);
    }
    
    CYG_REPORT_RETURN();
}

//}}}

//}}}
//{{{  CdlParentableBody                

// ----------------------------------------------------------------------------
// A parentable object can have the parent property, i.e. it can be
// positioned anywhere in the hierarchy. There is no data associated
// with such an object.

CdlParentableBody::CdlParentableBody()
{
    CYG_REPORT_FUNCNAME("CdlParentable:: default constructor");
    CYG_REPORT_FUNCARG1XV(this);

    change_parent_save_position = -1;
    cdlparentablebody_cookie  = CdlParentableBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();
    
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

CdlParentableBody::~CdlParentableBody()
{
    CYG_REPORT_FUNCNAME("CdlParentable:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    cdlparentablebody_cookie = CdlParentableBody_Invalid;
    CYGDBG_MEMLEAK_DESTRUCTOR();
    
    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------

std::string
CdlParentableBody::get_class_name() const
{
    CYG_REPORT_FUNCNAME("CdlParentable::get_class_name");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return "parentable";
}

// ----------------------------------------------------------------------------

bool
CdlParentableBody::check_this(cyg_assert_class_zeal zeal) const
{
    if (CdlParentableBody_Magic != cdlparentablebody_cookie) {
        return false;
    }
    CYGDBG_MEMLEAK_CHECKTHIS();
    return CdlNodeBody::check_this(zeal);
}

// ----------------------------------------------------------------------------
// Parsing support. There is just one property parser to be added.

void
CdlParentableBody::add_property_parsers(std::vector<CdlInterpreterCommandEntry>& parsers)
{
    CYG_REPORT_FUNCNAME("CdlParentable::add_property_parsers");

    static CdlInterpreterCommandEntry commands[] =
    {
        CdlInterpreterCommandEntry("parent", &CdlParentableBody::parse_parent),
        CdlInterpreterCommandEntry("",       0)
    };

    for (int i = 0; commands[i].command != 0; i++) {
        std::vector<CdlInterpreterCommandEntry>::const_iterator j;
        for (j = parsers.begin(); j != parsers.end(); j++) {
            if (commands[i].name == j->name) {
                if (commands[i].command != j->command) {
                    CYG_FAIL("Property names are being re-used");
                }
                break;
            }
        }
        if (j == parsers.end()) {
            parsers.push_back(commands[i]);
        }
    }
    CdlNodeBody::add_property_parsers(parsers);
    
    CYG_REPORT_RETURN();
}

void
CdlParentableBody::check_properties(CdlInterpreter interp)
{
    CYG_REPORT_FUNCNAME("CdlParentable::check_properties");
    CYG_REPORT_FUNCARG2XV(this, interp);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);

    if (has_property(CdlPropertyId_Parent)) {
        if (count_properties(CdlPropertyId_Parent) > 1) {
            CdlParse::report_error(interp, "", "There should be at most one `parent' property.");
        }
        CdlProperty_Reference refprop = dynamic_cast<CdlProperty_Reference>(get_property(CdlPropertyId_Parent));
        CYG_ASSERT_CLASSC(this);
        if (get_name() == refprop->get_destination_name()) {
            CdlParse::report_error(interp, "", std::string("Node ") + get_name() + " cannot be its own parent.");
        }
    }

    CdlNodeBody::check_properties(interp);
    
    CYG_REPORT_RETURN();
}

// ----------------------------------------------------------------------------
// Syntax:: parent <reference to container>

void
CdlParentableBody::update_handler(CdlTransaction transaction, CdlNode source, CdlProperty prop, CdlNode dest, CdlUpdate change)
{
    CYG_REPORT_FUNCNAME("CdlParentable::update_handler");
    CYG_PRECONDITION_CLASSC(source);
    CYG_PRECONDITION_ZERO_OR_CLASSC(dest);

    // Value and activity updates are of no interest.
    if ((CdlUpdate_ValueChange == change) || (CdlUpdate_ActiveChange == change)) {
        CYG_REPORT_RETURN();
        return;
    }

    // Ditto for the second stage Init.
    if (CdlUpdate_Init == change) {
        CYG_REPORT_RETURN();
        return;
    }
    
    // If this object is being unloaded then we need to clean up the hierarchy.
    // Ordinary nodes must be re-parented below the owning loadable. The
    // loadable itself must be re-parented below the toplevel. A subsequent
    // calls to remove_loadable_from_toplevel() will ensure that the loadable
    // is now completely isolated from the remaining configuration, but can
    // still be put back.
    if (CdlUpdate_Unloading == change) {
        CdlToplevel toplevel = source->get_toplevel();
        CYG_ASSERT_CLASSC(toplevel);
        CdlLoadable owner = source->get_owner();
        CYG_ASSERT_CLASSC(owner);
        CdlLoadable loadable = dynamic_cast<CdlLoadable>(source);
        CYG_ASSERT_ZERO_OR_CLASSC(loadable);
        
        if (0 != loadable) {
            toplevel->change_parent(owner, source->get_parent(), toplevel, source);
        } else {
            toplevel->change_parent(owner, source->get_parent(), owner, source);
        }
        
        CYG_REPORT_RETURN();
        return;
    }

    // We should have:
    // 1) change == Loaded, dest == (0 | valid)
    // 2) change == Created, dest == valid
    // 3) change == Destroyed, dest == valid (still)
    CYG_ASSERTC((CdlUpdate_Loaded == change)    || (CdlUpdate_Created == change) || (CdlUpdate_Destroyed == change));
    CYG_ASSERTC((CdlUpdate_Created != change)   || (0 != dest));
    CYG_ASSERTC((CdlUpdate_Destroyed != change) || (0 != dest));

    if (CdlUpdate_Destroyed == change) {
        dest = 0;
    }
    
    // Now either dest is valid or it is not. If it is then we need to
    // reparent below the destination. Otherwise if the specified
    // parent is "" then we need to reparent below the root. Otherwise
    // the node ends up in the orphans container. There are a few
    // nasty special cases to consider like reparenting below
    // something that is not a container.
    if (0 == dest) {
        CdlToplevel  toplevel = source->get_toplevel();
        
        CdlProperty_Reference refprop = dynamic_cast<CdlProperty_Reference>(prop);
        if ("" == refprop->get_destination_name()) {
            dest = toplevel;
            // Now to find the correct insertion point. Nodes which should be
            // reparented below the root should come first, ahead of any nodes
            // which are not specifically reparented.
            const std::vector<CdlNode>& contents = toplevel->get_contents();
            unsigned int index;
            for (index = 0; index < contents.size(); index++) {
                if (!contents[index]->has_property(CdlPropertyId_Parent)) {
                    break;
                }
            }
            toplevel->change_parent(source->get_owner(), source->get_parent(), toplevel, source, index);
            
        } else {
            // Orphan the node. It still has a parent, either as a
            // consequence of the loading process or because of a previous
            // binding operation.
            toplevel->change_parent(source->get_owner(), source->get_parent(), 0, source);
        }
        
        // The Unresolved conflict is handled by
        // CdlProperty_Reference::update(). The "else" code below may
        // have created some additional data conflicts.
        transaction->clear_structural_conflicts(source, prop, &CdlConflict_DataBody::test);

        // Changing the parent may affect the "active" status.
        bool old_state = transaction->is_active(source);
        bool new_state = source->test_active(transaction);
        if (old_state != new_state) {
            transaction->set_active(source, new_state);
        }

    } else {
        // The node should no longer be an orphan - probably.

        // Check that the destination is actually a container. If it is,
        // reparenting is possible.
        CdlContainer dest_container = dynamic_cast<CdlContainer>(dest);
        if (0 == dest_container) {
            
            // The reference might be resolved, but reparenting is still not possible.
            // Leave the object orphaned as at present, and create a suitable conflict
            // object.
            std::string msg = source->get_class_name() + " " + source->get_name() + " cannot be reparented below " +
                dest->get_class_name() + " " + dest->get_name() + "\n    The latter is not a container.";
            CdlConflict_DataBody::make(transaction, source, prop, msg);
            
        } else {
            
            CdlContainer tmp = dynamic_cast<CdlContainer>(source);
            if ((0 != tmp) && tmp->contains(dest_container, true)) {
                
                // Somebody trying to be clever and reparent an object
                // below one of its existing children? Note that with
                // sufficiently careful use of parent statements this
                // might actually be legal, but for now treat it as
                // too dangerous.
                std::string msg = source->get_class_name() + " " + source->get_name() + " cannot be reparented below " +
                    dest->get_class_name() + " " + dest->get_name() + "\n    This would introduce a cycle.";
                CdlConflict_DataBody::make(transaction, source, prop, msg);
                
            } else {
                
                // It is possible to reparent the object to its correct location
                CdlToplevel toplevel = source->get_toplevel();
                CYG_ASSERTC(toplevel == dest->get_toplevel());
                toplevel->change_parent(source->get_owner(), source->get_parent(), dest_container, source);
                
                bool old_state = transaction->is_active(source);
                bool new_state = source->test_active(transaction);
                if (old_state != new_state) {
                    transaction->set_active(source, new_state);
                }
            }
        }
    }

    CYG_REPORT_RETURN();
}

int
CdlParentableBody::parse_parent(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAMETYPE("parse_parent", "result %d");

    int result = CdlParse::parse_reference_property(interp, argc, argv, CdlPropertyId_Parent, 0, 0, true, &update_handler);
    
    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
