Subversion Repositories openrisc_2011-10-31

//{{{  Banner                           
 
//============================================================================
//
//     interface.cxx
//
//     Implementation of the CdlInterface class
//
//============================================================================
//####COPYRIGHTBEGIN####
//                                                                          
// ----------------------------------------------------------------------------
// Copyright (C) 2002 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/03/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(CdlInterfaceBody);
 
//}}}
//{{{  Constructor                      
 
// ----------------------------------------------------------------------------
CdlInterfaceBody::CdlInterfaceBody(std::string name_arg, bool generated_arg)
    : CdlNodeBody(name_arg),
      CdlUserVisibleBody(),
      CdlValuableBody(CdlValueFlavor_Data),
      CdlParentableBody(),
      CdlBuildableBody(),
      CdlDefinableBody()
{
    CYG_REPORT_FUNCNAME("CdlInterfaceBody:: constructor");
    CYG_REPORT_FUNCARG1XV(this);
 
    generated = generated_arg;
    cdlinterfacebody_cookie = CdlInterfaceBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();
 
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}
 
//}}}
//{{{  Destructor                       
 
// ----------------------------------------------------------------------------
CdlInterfaceBody::~CdlInterfaceBody()
{
    CYG_REPORT_FUNCNAME("CdlInterfaceBody:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
 
    cdlinterfacebody_cookie = CdlInterfaceBody_Invalid;
    CYGDBG_MEMLEAK_DESTRUCTOR();
 
    CYG_REPORT_RETURN();
}
 
//}}}
//{{{  parse_interface()                
 
// ----------------------------------------------------------------------------
// Parsing an interface definition. This is basically the same as parsing
// an option, component, or package.
 
int
CdlInterfaceBody::parse_interface(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAMETYPE("CdlInterface::parse_interface", "result %d");
    CYG_REPORT_FUNCARG1("argc %d", argc);
    CYG_PRECONDITION_CLASSC(interp);
 
    std::string  diag_argv0      = CdlParse::get_tcl_cmd_name(argv[0]);
 
    CdlLoadable  loadable       = interp->get_loadable();
    CdlContainer parent         = interp->get_container();       
    CdlToplevel  toplevel       = interp->get_toplevel();
    CYG_ASSERT_CLASSC(loadable);        // There should always be a loadable during parsing
    CYG_ASSERT_CLASSC(parent);
    CYG_ASSERT_CLASSC(toplevel);
 
    // The new interface should be created and added to the loadable.
    // early on. If there is a parsing error it will get cleaned up
    // automatically as a consequence of the loadable destructor.
    // However it is necessary to validate the name first. Errors
    // should be reported via CdlParse::report_error(), which
    // may result in an exception.
    CdlInterface new_interface  = 0;
    bool         ok             = true;
    int          result         = TCL_OK;
    try {
 
        // Currently there are no command-line options. This may change in future.
        if (3 != argc) {
            CdlParse::report_error(interp, "", std::string("Incorrect number of arguments to `") + diag_argv0 +
                                   "'\nExpecting name and properties list.");
            ok = false;
        } else if (!Tcl_CommandComplete(CDL_TCL_CONST_CAST(char*, argv[2]))) {
            CdlParse::report_error(interp, "", std::string("Invalid property list for cdl_interface `") + argv[1] + "'.");
            ok = false;
        } else if (0 != toplevel->lookup(argv[1])) {
            // FIXME: interfaces can be generated implicitly because of an
            // unresolved implements property. This code should look for
            // an existing auto-generated interface object and replace it
            // if necessary.
            CdlParse::report_error(interp, "", std::string("Interface `") + argv[1] +
                                   "' cannot be loaded.\nThe name is already in use.");
            ok = false;
        } else {
            new_interface = new CdlInterfaceBody(argv[1], false);
            toplevel->add_node(loadable, parent, new_interface);
        }
 
        if (!ok) {
            // Just because this component cannot be created, that is no
            // reason to abort the whole parsing process.
            CYG_REPORT_RETVAL(TCL_OK);
            return TCL_OK;
        }
    } catch(std::bad_alloc e) {
        interp->set_result(CdlParse::construct_diagnostic(interp, "internal error", "", "Out of memory"));
        result = TCL_ERROR;
    } catch(CdlParseException e) {
        interp->set_result(e.get_message());
        result = TCL_ERROR;
    } catch(...) {
        interp->set_result(CdlParse::construct_diagnostic(interp, "internal error", "", "Unexpected C++ exception"));
        result = TCL_ERROR;
    }
    if (TCL_OK != result) {
        CYG_REPORT_RETVAL(result);
        return result;
    }
 
    // At this stage new_interface has been created and added to the
    // hierarchy. The main work now is to add the properties.
 
    // Push the option as the current node early on. This aids
    // diagnostics.
    CdlNode old_node = interp->push_node(new_interface);
 
    // Declare these outside the scope of the try statement, to allow
    // goto calls for the error handling.
    std::string tcl_result;
    std::vector<CdlInterpreterCommandEntry>  new_commands;
    std::vector<CdlInterpreterCommandEntry>* old_commands = 0;
    static CdlInterpreterCommandEntry   commands[] =
    {
        CdlInterpreterCommandEntry("", 0)
    };
    int i;
 
    // All parsing errors may result in an exception, under the control of
    // application code. This exception must not pass through the Tcl interpreter.
    try {
 
        for (i = 0; 0 != commands[i].command; i++) {
            new_commands.push_back(commands[i]);
        }
        CdlDefinableBody::add_property_parsers(new_commands);
        CdlBuildableBody::add_property_parsers(new_commands);
        CdlParentableBody::add_property_parsers(new_commands);
        CdlValuableBody::add_property_parsers(new_commands);
        CdlUserVisibleBody::add_property_parsers(new_commands);
        CdlNodeBody::add_property_parsers(new_commands);
 
        // Now evaluate the body. If an error occurs then typically
        // this will be reported via CdlParse::report_error(),
        // but any exceptions will have been intercepted and
        // turned into a Tcl error.
        old_commands = interp->push_commands(new_commands);
        result = interp->eval(argv[2], tcl_result);
        interp->pop_commands(old_commands);
 
        if (TCL_OK == result) {
            // Even if there were errors, they were not fatal. There may
            // now be a number of properties for this option, and some
            // validation should take place. Start with the base classes.
            new_interface->CdlNodeBody::check_properties(interp);
            new_interface->CdlUserVisibleBody::check_properties(interp);
            new_interface->CdlValuableBody::check_properties(interp);
            new_interface->CdlParentableBody::check_properties(interp);
            new_interface->CdlBuildableBody::check_properties(interp);
            new_interface->CdlDefinableBody::check_properties(interp);
 
            // The flavor "none" makes no sense for interfaces.
            // The flavor "bool" makes very little sense, but may be useful
            // in weird cases. Both booldata and data make sense.
            // The default flavor is "data", because interfaces are
            // essentially just counters.
            if (new_interface->has_property(CdlPropertyId_Flavor)) {
                if (CdlValueFlavor_None == new_interface->get_flavor()) {
                    CdlParse::report_error(interp, "", "An interface should not have the `none' flavor.");
                }
            }
 
            // Interfaces cannot be modified directly by the user, so
            // there is no point in entry_proc, check_proc, dialog or
            // wizard
            if (new_interface->has_property(CdlPropertyId_EntryProc)) {
                CdlParse::report_error(interp, "", "An interface should not have an `entry_proc' property.");
            }
            if (new_interface->has_property(CdlPropertyId_CheckProc)) {
                CdlParse::report_error(interp, "", "An interface should not have a `check_proc' property.");
            }
            if (new_interface->has_property(CdlPropertyId_Dialog)) {
                CdlParse::report_error(interp, "", "An interface should not have a `dialog' property.");
            }
            if (new_interface->has_property(CdlPropertyId_Wizard)) {
                CdlParse::report_error(interp, "", "An interface should not have a `wizard' property.");
            }
            // Calculated does not make sense, an interface is implicitly calculated
            // Nor does default_value.
            if (new_interface->has_property(CdlPropertyId_Calculated)) {
                CdlParse::report_error(interp, "", "An interface should not have a `calculated' property.");
            }
            if (new_interface->has_property(CdlPropertyId_DefaultValue)) {
                CdlParse::report_error(interp, "", "An interface should not have a `default_value' property.");
            }
            // active_if might make sense, as a way of controlling
            // whether or not a #define will be generated.
 
            // legal_values, requires and implements are all sensible
            // properties for an interface.
 
            // group may or may not make sense, allow it for now.
 
            // For the uservisible base class, allow all of display,
            // doc and description. At worst these are harmless
 
            // For the parentable base class, allow parent. Again this
            // is harmless.
 
            // Also allow all of the definable and buildable
            // properties.
        }
    } catch (std::bad_alloc e) {
        // Errors at this stage should be reported via Tcl, not via C++.
        // However there is no point in continuing with the parsing operation,
        // just give up.
        interp->set_result(CdlParse::construct_diagnostic(interp, "internal error", "", "Out of memory"));
        result = TCL_ERROR;
    } catch (CdlParseException e) {
        interp->set_result(e.get_message());
        result = TCL_ERROR;
    } catch(...) {
        interp->set_result(CdlParse::construct_diagnostic(interp, "internal error", "", "Unexpected C++ exception"));
        result = TCL_ERROR;
    }
 
    // Restore the interpreter to its prior state.
    interp->pop_node(old_node);
    if (0 != old_commands) {
        interp->pop_commands(old_commands);
    }
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}
//{{{  Persistence support              
 
// ----------------------------------------------------------------------------
 
void
CdlInterfaceBody::initialize_savefile_support(CdlToplevel toplevel)
{
    CYG_REPORT_FUNCNAME("CdlInterface::initialize_savefile_support");
 
    toplevel->add_savefile_command("cdl_interface", 0, &savefile_interface_command);
    CdlValuableBody::initialize_savefile_support(toplevel, "cdl_interface");
 
    CYG_REPORT_RETURN();
}
 
void
CdlInterfaceBody::save(CdlInterpreter interp, Tcl_Channel chan, int indentation, bool minimal)
{
    CYG_REPORT_FUNCNAME("CdlInterface::save");
    CYG_REPORT_FUNCARG5XV(this, interp, chan, indentation, minimal);
    CYG_PRECONDITION_THISC();
    CYG_PRECONDITION_CLASSC(interp);
 
    // Interfaces contain only calculated data, so for a minimal save
    // there is no point in storing any of the data.
    if (!minimal || this->has_additional_savefile_information()) {
        // Start with the UserVisible data, which will result in a suitable set
        // of comments before the package definition itself.
        this->CdlUserVisibleBody::save(interp, chan, indentation, minimal);
 
        // Now output the line "cdl_interface <name> {"
        // The name is guaranteed to be a valid C preprocessor symbol, so it
        // is not going to need any quoting.
        std::string data = std::string(indentation, ' ') + "cdl_interface " + get_name() + " {\n";
 
        // Start with details of everything that implements this interface.
        if (!minimal) {
            const std::vector<CdlReferrer>& referrers = this->get_referrers();
            std::vector<CdlReferrer>::const_iterator ref_i;
            int real_referrers = 0;
            for (ref_i = referrers.begin(); ref_i != referrers.end(); ref_i++) {
                CdlNode     node = ref_i->get_source();
                CdlProperty prop = ref_i->get_source_property();
 
                CdlValuable valuable = dynamic_cast<CdlValuable>(node);
                if ((0 != valuable) && (CdlPropertyId_Implements == prop->get_property_name())) {
                    real_referrers++;
                    data += std::string(indentation, ' ') + "    # Implemented by " + valuable->get_name() + ", " +
                        (valuable->is_active()  ? "active"  : "inactive") + ", " +
                        (valuable->is_enabled() ? "enabled" : "disabled") + '\n';
                }
            }
            if (0 == real_referrers) {
                data += std::string(indentation, ' ') + "    # No options implement this inferface\n";
            }
        }
        interp->write_data(chan, data);
 
        // Deal with the value
        this->CdlValuableBody::save(interp, chan, indentation + 4, false, minimal);
 
        // Close the cdl_interface body. A blank line is added here.
        data = "};\n\n";
        interp->write_data(chan, data);
    }
 
    CYG_REPORT_RETURN();
}
 
int
CdlInterfaceBody::savefile_interface_command(CdlInterpreter interp, int argc, const char* argv[])
{
    CYG_REPORT_FUNCNAMETYPE("CdlInterface::savefile_interface_command", "result %d");
    CYG_PRECONDITION_CLASSC(interp);
 
    int result = TCL_OK;
    CdlToplevel toplevel = interp->get_toplevel();
    CYG_ASSERT_CLASSC(toplevel);
 
    std::vector<CdlInterpreterCommandEntry> subcommands;
    std::vector<CdlInterpreterCommandEntry>* toplevel_commands = 0;
    CdlNode old_node = 0;
 
    try {
 
        if (3 != argc) {
            CdlParse::report_error(interp, "", "Invalid cdl_interface command in savefile, expecting two arguments.");
        } else {
 
            CdlNode current_node = toplevel->lookup(argv[1]);
            if (0 == current_node) {
                // FIXME: save value in limbo
                CdlParse::report_error(interp, "",
                                       std::string("The savefile contains a cdl_interface command for an unknown interface `")
                                       + argv[1] + "'.");
            } else {
                toplevel->get_savefile_subcommands("cdl_interface", subcommands);
                toplevel_commands = interp->push_commands(subcommands);
                old_node = interp->push_node(current_node);
 
                std::string tcl_result;
                result = interp->eval(argv[2], tcl_result);
 
                interp->pop_commands(toplevel_commands);
                toplevel_commands = 0;
                interp->pop_node(old_node);
                old_node = 0;
            }
        }
    } catch(...) {
        if (0 != old_node) {
            interp->pop_node(old_node);
        }
        if (0 != toplevel_commands) {
            interp->pop_commands(toplevel_commands);
        }
        throw;
    }
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}
//{{{  check_this()                     
 
// ----------------------------------------------------------------------------
 
bool
CdlInterfaceBody::check_this(cyg_assert_class_zeal zeal) const
{
    if (CdlInterfaceBody_Magic != cdlinterfacebody_cookie) {
        return false;
    }
    CYGDBG_MEMLEAK_CHECKTHIS();
    return CdlNodeBody::check_this(zeal)        &&
           CdlUserVisibleBody::check_this(zeal) &&
           CdlValuableBody::check_this(zeal)    &&
           CdlParentableBody::check_this(zeal)  &&
           CdlBuildableBody::check_this(zeal)   &&
           CdlDefinableBody::check_this(zeal);
}
 
//}}}
//{{{  recalculate()                    
 
// ----------------------------------------------------------------------------
// There has been a change in the configuration which may affect the value
// of an interface. This can happen for a variety of reasons. For simplicity
// the entire value is just recalculated, with no attempt at optimisation.
// This may have to change in future.
 
void
CdlInterfaceBody::recalculate(CdlTransaction transaction)
{
    CYG_REPORT_FUNCNAME("CdlInterface::recalculate");
 
    const CdlValue& old_value = transaction->get_whole_value(this);
 
    cdl_int count = 0;
    std::vector<CdlValuable> implementers;
    std::vector<CdlValuable>::const_iterator valuable_i;
    this->get_implementers(implementers);
    for (valuable_i = implementers.begin(); valuable_i != implementers.end(); valuable_i++) {
        if (transaction->is_active(*valuable_i)) {
            const CdlValue& implementer_value = transaction->get_whole_value(*valuable_i);
            if (implementer_value.is_enabled()) {
                count++;
            }
        }
    }
 
    // What to do with the count depends on the flavor.
    switch(this->get_flavor()) {
      case CdlValueFlavor_Bool :
        {
            bool new_bool = (count > 0);
            if (new_bool != old_value.is_enabled()) {
                CdlValue new_value = old_value;
                new_value.set_enabled(new_bool, CdlValueSource_Default);
                transaction->set_whole_value(this, old_value, new_value);
            }
            break;
        }
      case CdlValueFlavor_BoolData:
        {
            // The only thing that actually needs checking is the count value.
            // Iff that has changed then the boolean part may need changing as well.
            if (count != old_value.get_integer_value()) {
                CdlValue new_value = old_value;
                new_value.set_enabled_and_value(count > 0, count, CdlValueSource_Default);
                transaction->set_whole_value(this, old_value, new_value);
            }
 
            break;
        }
      case CdlValueFlavor_Data:
        {
            if (count != old_value.get_integer_value()) {
                CdlValue new_value = old_value;
                new_value.set_integer_value(count, CdlValueSource_Default);
                transaction->set_whole_value(this, old_value, new_value);
            }
            break;
        }
 
      default:
        break;
    }
 
    CYG_REPORT_RETURN();
}
 
//}}}
//{{{  misc                             
 
// ----------------------------------------------------------------------------
 
bool
CdlInterfaceBody::is_modifiable() const
{
    CYG_REPORT_FUNCNAME("CdlInterface::is_modifiable (false)");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return false;
}
 
std::string
CdlInterfaceBody::get_class_name() const
{
    CYG_REPORT_FUNCNAME("CdlInterface::get_class_name");
    CYG_PRECONDITION_THISC();
    CYG_REPORT_RETURN();
    return "interface";
}
 
void
CdlInterfaceBody::get_implementers(std::vector<CdlValuable>& implementers) const
{
    CYG_REPORT_FUNCNAME("CdlInterface::get_implementers");
    CYG_PRECONDITION_THISC();
 
    const std::vector<CdlReferrer>& referrers = this->get_referrers();
    std::vector<CdlReferrer>::const_iterator ref_i;
    for (ref_i = referrers.begin(); ref_i != referrers.end(); ref_i++) {
        CdlNode     node = ref_i->get_source();
        CdlProperty prop = ref_i->get_source_property();
 
        CdlValuable valuable = dynamic_cast<CdlValuable>(node);
        if ((0 != valuable) && (CdlPropertyId_Implements == prop->get_property_name())) {
            implementers.push_back(valuable);
        }
    }
 
    CYG_REPORT_RETURN();
}
 
// Interfaces are somewhat peculiar, in that they can be defined implicitly
// simply by occurring in an "implements" property, or explicitly inside
// a CDL script. Worse, they can switch between these two states when
// loadables are added or removed.
 
bool
CdlInterfaceBody::was_generated() const
{
    CYG_REPORT_FUNCNAMETYPE("CdlInterface::was_generated", "result %d");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();
 
    bool result = this->generated;
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}