package.cxx

eCos1.31版

//{{{  Banner                           

//============================================================================
//
//     package.cxx
//
//     Implementation of the CdlPackage 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>

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

//}}}

//{{{  Statics                          

// ----------------------------------------------------------------------------
CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlPackageBody);

//}}}
//{{{  Constructor                      

// ----------------------------------------------------------------------------
// Constructor. The real work is actually done in the base classes
// and the parser.
CdlPackageBody::CdlPackageBody(std::string name_arg, CdlConfiguration toplevel, std::string dir)
    : CdlNodeBody(name_arg),
      CdlContainerBody(),
      CdlUserVisibleBody(),
      CdlValuableBody(CdlValueFlavor_BoolData),
      CdlParentableBody(),
      CdlBuildableBody(),
      CdlDefinableBody(),
      CdlLoadableBody(toplevel, dir),
      CdlBuildLoadableBody(),
      CdlDefineLoadableBody()
{
    CYG_REPORT_FUNCNAME("CdlPackageBody:: constructor");
    CYG_REPORT_FUNCARG1XV(this);

    loaded_for_template   = false;
    loaded_for_hardware   = false;
    cdlpackagebody_cookie = CdlPackageBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();
    
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Destructor                       

// ----------------------------------------------------------------------------
// Most of the work is done in the base classes.

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

    loaded_for_template   = false;
    loaded_for_hardware   = false;
    cdlpackagebody_cookie = CdlPackageBody_Invalid;
    CYGDBG_MEMLEAK_DESTRUCTOR();
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  parse_package()                  

// ----------------------------------------------------------------------------
// Parsing a package definition. This routine gets invoked directly from the
// Tcl interpreter, when the cdl_package command is encountered. The
// command takes two arguments, a name and a body of properties, and there
// should only be one cdl_package command per package.
//
// At the point that the cdl_package command is executed the CdlPackage
// object should already exist, and in fact it should be the current
// interpreter's loadable. Obviously the name should be checked. The
// main purpose of the cdl_package command is to fill in some extra
// information in the form of properties.
//
// A package is a buildable, valuable, uservisible, ... object so it
// inherits properties from all three. In practice some of the
// properties from the base classes are not actually legal, but that
// will be caught by the validation code. Additional properties
// relevant to a package are: parent, license_proc, install_proc, and
// wizard. It is harmless (but unnecessary) to allow components etc.
// to be defined inside a package definition.

int
CdlPackageBody::parse_package(CdlInterpreter interp, int argc, char** argv)
{
    CYG_REPORT_FUNCNAMETYPE("CdlPackageBody::parse_package", "result %d");
    CYG_REPORT_FUNCARG1("argc %d", argc);
    CYG_PRECONDITION_CLASSC(interp);
    
    const char* diag_argv0      = CdlParse::get_tcl_cmd_name(argv[0]);

    CdlLoadable  loadable       = interp->get_loadable();
    CdlPackage   package        = dynamic_cast<CdlPackage>(loadable);
    CdlContainer parent         = package->get_parent();       
    CdlToplevel  toplevel       = interp->get_toplevel();
    std::string filename        = interp->get_filename();
 
    CYG_ASSERT_CLASSC(loadable);        // There should always be a loadable during parsing
    CYG_ASSERT_CLASSC(package);         // And packages are the only loadable for software CDL
    CYG_ASSERT_CLASSC(toplevel);
    CYG_ASSERTC(dynamic_cast<CdlToplevel>(parent) == toplevel);    // The package cannot have been reparented yet.
    CYG_ASSERTC("" != filename);
    CYG_UNUSED_PARAM(CdlContainer, parent);
    CYG_UNUSED_PARAM(CdlToplevel, toplevel);

    // Push the package as the current base object early on.
    // This aids diagnostics.
    CdlNode old_node        = interp->push_node(package);

    // There should be no current node, in fact the cdl_package command
    // can only exist at the toplevel of the original script courtesy
    // of commands being pushed and popped.
    CYG_ASSERTC(0 == old_node);

    // Also, the package should be the current container.
    CYG_ASSERTC(package == dynamic_cast<CdlPackage>(interp->get_container()));

    // Declare these outside the scope of the try statement, to allow
    // goto calls for the error handling.
    const std::vector<CdlProperty>& properties = package->get_properties();
    std::string tcl_result;
    std::vector<CdlInterpreterCommandEntry>  new_commands;
    std::vector<CdlInterpreterCommandEntry>* old_commands = 0;
    static CdlInterpreterCommandEntry commands[] =
    {
        CdlInterpreterCommandEntry("hardware",           &parse_hardware                    ),
        CdlInterpreterCommandEntry("license_proc",       &parse_license_proc                ),
        CdlInterpreterCommandEntry("install_proc",       &parse_install_proc                ),
        CdlInterpreterCommandEntry("cdl_component",      &CdlComponentBody::parse_component ),
        CdlInterpreterCommandEntry("cdl_option",         &CdlOptionBody::parse_option       ),
        CdlInterpreterCommandEntry("cdl_interface",      &CdlInterfaceBody::parse_interface ),
        CdlInterpreterCommandEntry("cdl_dialog",         &CdlDialogBody::parse_dialog       ),
        CdlInterpreterCommandEntry("cdl_wizard",         &CdlWizardBody::parse_wizard       ),
        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.
    int result = TCL_OK;
    try {

        // Currently there are no options. This may change in future.
        if (3 != argc) {
            CdlParse::report_error(interp, std::string("Incorrect number of arguments to ") + diag_argv0 +
                                   "\n    Expecting name and properties list.");
            goto done;
        }
        if (argv[1] != loadable->get_name()) {
            CdlParse::report_error(interp, std::string("Incorrect package name in CDL script.\n") +
                                   "    This package is " + loadable->get_name() + "\n" +
                                   "    The CDL script " + filename + " defines a package " + argv[1]);
            goto done;
        }
        
        if (0 != properties.size()) {
            CdlParse::report_error(interp, std::string("Duplicate cdl_package commands for package ") + argv[1]);
            goto done;
        }
        
        if (!Tcl_CommandComplete(argv[2])) {
            CdlParse::report_error(interp, std::string("Invalid property list for cdl_package ") + argv[1]);
            goto done;
        }

        for (i = 0; 0 != commands[i].command; i++) {
            new_commands.push_back(commands[i]);
        }
        
        CdlBuildLoadableBody::add_property_parsers(new_commands);
        CdlBuildableBody::add_property_parsers(new_commands);
        CdlDefineLoadableBody::add_property_parsers(new_commands);
        CdlDefinableBody::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) {
            // No point in taking any further action, just go with the flow
            goto done;
        }

        // Even if there were errors, they were not fatal. There may
        // now be a number of properties for this package, and some
        // validation should take place. Start with the base classes.
        package->CdlNodeBody::check_properties(interp);
        package->CdlUserVisibleBody::check_properties(interp);
        package->CdlValuableBody::check_properties(interp);
        package->CdlParentableBody::check_properties(interp);
        package->CdlBuildableBody::check_properties(interp);
        package->CdlBuildLoadableBody::check_properties(interp);
        package->CdlDefinableBody::check_properties(interp);
        package->CdlDefineLoadableBody::check_properties(interp);

        // Some of the properties in the base classes are not actually
        // appropriate. A package is valuable, but it can only be
        // modified by loading and unloading. Many of the value-related
        // properties do not make sense.
        if (package->count_properties(CdlPropertyId_Flavor) > 0) {
            CdlParse::report_error(interp, "A package should not have a `flavor' property.");
        }
        if (package->count_properties(CdlPropertyId_EntryProc) > 0) {
            CdlParse::report_error(interp, "A package should not have an `entry_proc' property.");
        }
        if (package->count_properties(CdlPropertyId_CheckProc) > 0) {
            CdlParse::report_error(interp, "A package should not have a `check_proc' property.");
        }
        // BLV: this reasoning is faulty, it should be possible to
        // control the enabled aspect via an expression. That would
        // need option processing for the default_value property.
        if (package->count_properties(CdlPropertyId_DefaultValue) > 0) {
            CdlParse::report_error(interp, "A package should not have a `default_value' property.");
        }
        if (package->count_properties(CdlPropertyId_LegalValues) > 0) {
            CdlParse::report_error(interp, "A package should not have a `legal_values' property.");
        }
        if (package->count_properties(CdlPropertyId_Calculated) > 0) {
            CdlParse::report_error(interp, "A package should not have a `calculated' property.");
        }
        if (package->count_properties(CdlPropertyId_Dialog) > 0) {
            CdlParse::report_error(interp, "A package should not have a `dialog' property.");
        }

#if 0
        // BLV: this reasoning is faulty, since packages can get loaded
        // because of templates or hardware without the user
        // necesssarily understanding all the implications.
        // Packages should not have active_if statements, only
        // requires statements. It makes little sense to load
        // a package and have it inactive, instead there should
        // be conflicts re. unsatisfied goals.
        if (package->count_properties(CdlPropertyId_ActiveIf) > 0) {
            CdlParse::report_error(interp, "A package should not have an `active_if' property.");
        }
#endif
#if 0
        // BLV: allow hardware packages to have a define_header property for now.
        // This simplifies things during the transition
        // If this is a hardware package then it cannot also have a define_header property.
        // Hardware packages always send their output to hardware.h
        if (package->has_property(CdlPropertyId_Hardware) && package->has_property(CdlPropertyId_DefineHeader)) {
            CdlParse::report_error(interp, "Hardware packages cannot specify their configuration header");
        }
#endif  

        // There should be at most one each of license_proc, install_proc, include_dir,
        // export_to, library, makefile, and wizard.
        if (package->count_properties(CdlPropertyId_LicenseProc) > 1) {
            CdlParse::report_error(interp, "A package should have at most one `license_proc' property.");
        }
        if (package->count_properties(CdlPropertyId_InstallProc) > 1) {
            CdlParse::report_error(interp, "A package should have at most one `install_proc' property.");
        }

      done:
        // Dummy command just to keep the compiler happy
        filename = "";
        
    } catch (std::bad_alloc e) {
        // Errors at this stage should be reported via Tcl, not via C++
        interp->set_result(CdlParse::get_diagnostic_prefix(interp) + "Out of memory.");
        result = TCL_ERROR;
    } catch (CdlParseException e) {
        interp->set_result(e.get_message());
        result = TCL_ERROR;
    } catch(...) {
        interp->set_result(CdlParse::get_diagnostic_prefix(interp) + "internal error, unexpected C++ exception.");
        result = TCL_ERROR;
    }

    // Restore the interpreter to its prior state.
    interp->pop_node(old_node);
    
    CYG_REPORT_RETVAL(result);
    return result;
}

//}}}
//{{{  Package properties               

// ----------------------------------------------------------------------------
// Syntax: hardware
int
CdlPackageBody::parse_hardware(CdlInterpreter interp, int argc, char** argv)
{
    CYG_REPORT_FUNCNAMETYPE("parse_hardware", "result %d");