//{{{  Banner                           //============================================================================////     interface.cxx////     Implementation of the CdlInterface class////============================================================================//####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/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.intCdlInterfaceBody::parse_interface(CdlInterpreter interp, int argc, 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(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;