Subversion Repositories openrisc

//{{{  Banner                           

//============================================================================

//

//      refer.cxx

//

//      Implementation of the CdlReference and CdlReferrer classes.

//

//============================================================================

//####COPYRIGHTBEGIN####

//                                                                          

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

// 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/01

// Version:     0.02

//

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

// <cdlcore.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(CdlReference);

CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlReferrer);

//}}}

//{{{  CdlReference class               

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

// The default constructor. This should not normally get invoked, instead

// a string argument should be supplied. However it is occasionally useful

// to construct a reference and then set the name later.

CdlReference::CdlReference()

{

    CYG_REPORT_FUNCNAME("CdlReference:: default constructor");

    CYG_REPORT_FUNCARG1XV(this);

    dest_name           = "";

    dest                = 0;

    cdlreference_cookie = CdlReference_Magic;

    CYGDBG_MEMLEAK_CONSTRUCTOR();

    CYG_POSTCONDITION_THISC();

    CYG_REPORT_RETURN();

}

// This constructor typically gets used when parsing a property.

// The object may be created either on the stack or in the heap,

// depending on the requirements of the property. During a later

// phase in the parsing process the object may get bound.

CdlReference::CdlReference(const std::string dest_arg)

{

    CYG_REPORT_FUNCNAME("CdlReference:: constructor");

    CYG_REPORT_FUNCARG1("this %p", this);

    dest_name           = dest_arg;

    dest                = 0;

    cdlreference_cookie = CdlReference_Magic;

    CYGDBG_MEMLEAK_CONSTRUCTOR();

    CYG_POSTCONDITION_THISC();

    CYG_REPORT_RETURN();

}

// For some properties, notably LocalReference ones, it is convenient

// to create a temporary reference object on the stack and then

// derive the property from the temporary. This requires the

// copy constructor. When this operation is used the object

// should still be unbound.

CdlReference::CdlReference(const CdlReference& orig)

{

    CYG_REPORT_FUNCNAME("CdlReference:: copy constructor");

    CYG_REPORT_FUNCARG2("this %p, orig %p", this, &orig);

    CYG_INVARIANT_CLASSC(CdlReference, orig);

    CYG_PRECONDITIONC(0 == orig.dest);

    dest_name           = orig.dest_name;

    dest                = 0;

    cdlreference_cookie = CdlReference_Magic;

    CYGDBG_MEMLEAK_CONSTRUCTOR();

    CYG_POSTCONDITION_THISC();

    CYG_REPORT_RETURN();

}

// The assignment operator may be needed for similar reasons.

CdlReference&

CdlReference::operator=(const CdlReference& orig)

{

    CYG_REPORT_FUNCNAME("CdlReference:: assignment operator");

    CYG_REPORT_FUNCARG2("this %p, orig %p", this, &orig);

    CYG_INVARIANT_CLASSC(CdlReference, orig);

    CYG_PRECONDITIONC(0 == orig.dest);

    if (this != &orig) {

        dest_name               = orig.dest_name;

        dest                    = 0;

        cdlreference_cookie     = CdlReference_Magic;

    }

    CYG_POSTCONDITION_THISC();

    CYG_REPORT_RETURN();

    return *this;

}

// The destructor should only get invoked when a package is unloaded.

// All appropriate clean-ups should have happened already, in particular

// the reference should not currently be bound.

CdlReference::~CdlReference()

{

    CYG_REPORT_FUNCNAME("CdlReference:: destructor");

    CYG_REPORT_FUNCARG1("this %p", this);

    CYG_PRECONDITION_THISC();

    CYG_PRECONDITIONC(0 == dest);

    cdlreference_cookie = CdlReference_Invalid;

    dest_name           = "";

    CYGDBG_MEMLEAK_DESTRUCTOR();

    CYG_REPORT_RETURN();

}

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

// Accessing the fields.

void

CdlReference::set_destination_name(const std::string name)

{

    CYG_REPORT_FUNCNAME("CdlReference::set_destination_name");

    CYG_REPORT_FUNCARG1XV(this);

    CYG_PRECONDITION_THISC();

    CYG_PRECONDITIONC((0 == dest) && ("" == dest_name));

    dest_name = name;

    CYG_REPORT_RETURN();

}

const std::string&

CdlReference::get_destination_name(void) const

{

    CYG_REPORT_FUNCNAME("CdlReference::get_destination_name");

    CYG_REPORT_FUNCARG1("this %p", this);

    CYG_PRECONDITION_THISC();

    CYG_REPORT_RETURN();

    return dest_name;

}

CdlNode

CdlReference::get_destination() const

{

    CYG_REPORT_FUNCNAMETYPE("CdlReference::get_destination", "result %p");

    CYG_REPORT_FUNCARG1XV(this);

    CYG_PRECONDITION_THISC();

    CdlNode result = dest;

    CYG_REPORT_RETVAL(result);

    return result;

}

bool

CdlReference::check_this(cyg_assert_class_zeal zeal) const

{

    if (CdlReference_Magic != cdlreference_cookie) {

        return false;

    }

    CYGDBG_MEMLEAK_CHECKTHIS();

    switch(zeal) {

      case cyg_system_test:

      case cyg_extreme:

          // There is not enough information in the reference

          // object itself to allow for a check for a corresponding

          // referrer object. If more debugability is needed

          // then extra data will have to be stored.

          //

          // However, it is possible to do a basic check of dest itself.

          if (0 != dest) {

              if (!dest->check_this(cyg_quick)) {

                  return false;

              }

          }

      case cyg_thorough:

          if (0 != dest) {

              if (dest_name != dest->get_name()) {

                  return false;

              }

          }

      case cyg_quick:

      case cyg_trivial:

      case cyg_none   :

      default         :

          break;

    }

    return true;

}

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

// Binding. This is simply a case of filling in some fields in the reference

// object and pushing a new referrer object. Binding generally happens as

// a result of calling reference update handlers when a package gets loaded.

void

CdlReference::bind(CdlNode src_arg, CdlProperty src_prop_arg, CdlNode dest_arg)

{

    CYG_REPORT_FUNCNAME("CdlReference::bind");

    CYG_REPORT_FUNCARG4XV(this, src_arg, src_prop_arg, dest_arg);

    CYG_INVARIANT_THISC(CdlReference);

    CYG_PRECONDITION_CLASSC(src_arg);

    CYG_PRECONDITION_CLASSC(src_prop_arg);

    CYG_PRECONDITION_CLASSC(dest_arg);

    CYG_ASSERTC(dest_name == dest_arg->get_name());

    CdlReferrer local_copy;

    local_copy.source           = src_arg;

    local_copy.source_property  = src_prop_arg;

    dest_arg->referrers.push_back(local_copy);

    dest = dest_arg;

    CYG_REPORT_RETURN();

}

// Unbinding involves finding and removing the appropriate referrer object (there

// may be several, but each will result in a separate unbind() call.)

void

CdlReference::unbind(CdlNode src_arg, CdlProperty src_prop_arg)

{

    CYG_REPORT_FUNCNAME("CdlReference::unbind");

    CYG_REPORT_FUNCARG3XV(this, src_arg, src_prop_arg);

    CYG_PRECONDITION_THISC();

    CYG_PRECONDITION_CLASSC(src_arg);

    CYG_PRECONDITION_CLASSC(src_prop_arg);

    if (0 != dest) {

        std::vector<CdlReferrer>::iterator ref_i;

        for (ref_i = dest->referrers.begin(); ref_i != dest->referrers.end(); ref_i++) {

            if ((ref_i->source == src_arg) && (ref_i->source_property == src_prop_arg)) {

                dest->referrers.erase(ref_i);

                break;

            }

        }

    }

    dest = 0;

    CYG_REPORT_RETURN();

}

//}}}

//{{{  CdlReferrer class                

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

// The constructors etc. should only get invoked from

// CdlReference::bind() and unbind(). However because Referrer objects

// get held in  STL vectors/lists/whatever it is hard to know exactly

// what will happen when, so assertions are a bit thin on the ground.

CdlReferrer::CdlReferrer()

{

    CYG_REPORT_FUNCNAME("CdlReferrer:: default constructor");

    CYG_REPORT_FUNCARG1XV(this);

    source              = 0;

    source_property     = 0;

    cdlreferrer_cookie  = CdlReferrer_Magic;

    CYGDBG_MEMLEAK_CONSTRUCTOR();

    CYG_POSTCONDITION_THISC();

    CYG_REPORT_RETURN();

}

CdlReferrer::CdlReferrer(const CdlReferrer& original)

{

    CYG_REPORT_FUNCNAME("CdlReferrer:: copy constructor");

    CYG_REPORT_FUNCARG2XV(this, &original);

    CYG_PRECONDITION_CLASSOC(original);

    source              = original.source;

    source_property     = original.source_property;

    cdlreferrer_cookie  = CdlReferrer_Magic;

    CYGDBG_MEMLEAK_CONSTRUCTOR();

    CYG_POSTCONDITION_THISC();

    CYG_REPORT_RETURN();

}

CdlReferrer&

CdlReferrer::operator=(const CdlReferrer& original)

{

    CYG_REPORT_FUNCNAME("CdlReferrer:: assignment operator");

    CYG_REPORT_FUNCARG2XV(this, &original);

    CYG_PRECONDITION_CLASSOC(original);

    if (this != &original) {

        source                  = original.source;

        source_property         = original.source_property;

        cdlreferrer_cookie      = CdlReferrer_Magic;

    }

    CYG_POSTCONDITION_THISC();

    CYG_REPORT_RETURN();

    return *this;

}

CdlReferrer::~CdlReferrer()

{

    CYG_REPORT_FUNCNAME("CdlReferrer:: destructor");

    CYG_REPORT_FUNCARG1XV(this);

    CYG_PRECONDITION_THISC();

    cdlreferrer_cookie  = CdlReferrer_Magic;

    source              = 0;

    source_property     = 0;

    CYGDBG_MEMLEAK_DESTRUCTOR();

    CYG_REPORT_RETURN();

}

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

// This routine is the main reason for having reference and referrer

// objects around in the first place. It allows changes to an entity

// to be propagated back to anything else interested in the entity.

void

CdlReferrer::update(CdlTransaction transact, CdlNode dest_arg, CdlUpdate change)

{

    CYG_REPORT_FUNCNAME("CdlReferrer::update");

    CYG_REPORT_FUNCARG4XV(this, transact, dest_arg, change);

    CYG_PRECONDITION_THISC();

    source_property->update(transact, source, dest_arg, change);

    CYG_REPORT_RETURN();

}

CdlNode

CdlReferrer::get_source() const

{

    CYG_REPORT_FUNCNAMETYPE("CdlReferrer::get_source", "result %p");

    CYG_REPORT_FUNCARG1XV(this);

    CYG_PRECONDITION_THISC();

    CdlNode result = source;

    CYG_REPORT_RETVAL(result);

    return result;

}

CdlProperty

CdlReferrer::get_source_property() const

{

    CYG_REPORT_FUNCNAMETYPE("CdlReferrer::get_source_property", "result %p");

    CYG_REPORT_FUNCARG1XV(this);

    CYG_PRECONDITION_THISC();

    CdlProperty result = source_property;

    CYG_REPORT_RETVAL(result);

    return result;

}

bool

CdlReferrer::check_this(cyg_assert_class_zeal zeal) const

{

    if (CdlReferrer_Magic != cdlreferrer_cookie) {

        return false;

    }

    CYGDBG_MEMLEAK_CHECKTHIS();

    switch(zeal) {

      case cyg_system_test :

      case cyg_extreme:

      case cyg_thorough:

          if (0 != source) {

              if (!source->check_this(cyg_quick)) {

                  return false;

              }

          }

          if (0 != source_property) {

              if (!source_property->check_this(cyg_quick)) {

                  return false;

              }

          }

      case cyg_quick:

      case cyg_trivial:

      case cyg_none:

        break;

    }

    return true;

}

//}}}