wizard.cxx

Intel XScale PXA255 引导Linux的Redboot 版bootloader源代码！

//{{{  Banner                           

//============================================================================
//
//     wizard.cxx
//
//     Implementation of the CdlWizard 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.01
//
//####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(CdlWizardBody);

//}}}
//{{{  Constructor                      

// ----------------------------------------------------------------------------
// Constructor. The real work is actually done in the parse routine.
CdlWizardBody::CdlWizardBody(std::string name_arg)
    : CdlNodeBody(name_arg),
      CdlParentableBody(),
      CdlUserVisibleBody()
{
    CYG_REPORT_FUNCNAME("CdlWizardBody:: constructor");
    CYG_REPORT_FUNCARG1XV(this);

    cdlwizardbody_cookie = CdlWizardBody_Magic;
    CYGDBG_MEMLEAK_CONSTRUCTOR();
    
    CYG_POSTCONDITION_THISC();
    CYG_REPORT_RETURN();
}

//}}}
//{{{  Destructor                       

// ----------------------------------------------------------------------------
// The real work is done in the base classes.
CdlWizardBody::~CdlWizardBody()
{
    CYG_REPORT_FUNCNAME("CdlWizardBody:: destructor");
    CYG_REPORT_FUNCARG1XV(this);
    CYG_PRECONDITION_THISC();

    cdlwizardbody_cookie = CdlWizardBody_Invalid;
    CYGDBG_MEMLEAK_DESTRUCTOR();
    
    CYG_REPORT_RETURN();
}

//}}}
//{{{  parse_wizard()                   

// ----------------------------------------------------------------------------
// Parsing a wizard definition.

int
CdlWizardBody::parse_wizard(CdlInterpreter interp, int argc, char** argv)
{
    CYG_REPORT_FUNCNAMETYPE("CdlWizard::parse_wizard", "result %d");
    CYG_REPORT_FUNCARG1("argc %d", argc);
    CYG_PRECONDITION_CLASSC(interp);

    int         result          = TCL_OK;
    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 wizard 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.
    CdlWizard    new_wizard     = 0;
    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.");
        } else if (!Tcl_CommandComplete(argv[2])) {
            CdlParse::report_error(interp, "", std::string("Invalid property list for cdl_wizard `") + argv[1]+ "'.");
        } else if (0 != toplevel->lookup(argv[1])) {
            CdlParse::report_error(interp, "", std::string("Wizard `") + argv[1] +
                                   "' cannot be loaded.\nThe name is already in use.");
        } else {
            new_wizard = new CdlWizardBody(argv[1]);
            toplevel->add_node(loadable, parent, new_wizard);

            // At this stage new_wizard has been created and added to the hierarchy.
            // The main work now is to add the properties.
    
            // Push the wizard as the current base object early on.
            // This aids diagnostics.
            CdlNode old_node = 0;

            std::string tcl_result;
            std::vector<CdlInterpreterCommandEntry>  new_commands;
            std::vector<CdlInterpreterCommandEntry>* old_commands = 0;
            static CdlInterpreterCommandEntry commands[] =
            {
                CdlInterpreterCommandEntry("init_proc",          &parse_init_proc       ),
                CdlInterpreterCommandEntry("decoration_proc",    &parse_decoration_proc ),
                CdlInterpreterCommandEntry("screen",             &parse_screen          ),
                CdlInterpreterCommandEntry("confirm_proc",       &parse_confirm_proc    ),
                CdlInterpreterCommandEntry("cancel_proc",        &parse_cancel_proc     ),
                CdlInterpreterCommandEntry("",                   0                      ),
            };
            int i;
            for (i = 0; 0 != commands[i].command; i++) {
                new_commands.push_back(commands[i]);
            }
            CdlParentableBody::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_node = interp->push_node(new_wizard);
            old_commands = interp->push_commands(new_commands);
            result = interp->eval(argv[2], tcl_result);
            interp->pop_node(old_node);
            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_wizard->CdlNodeBody::check_properties(interp);
                new_wizard->CdlUserVisibleBody::check_properties(interp);
                new_wizard->CdlParentableBody::check_properties(interp);

                // The init_proc and decoration_proc properties are
                // optional. The confirm_proc and cancel_proc properties
                // are compulsory, and there should be at least one screen
                // definition.
                if (new_wizard->count_properties(CdlPropertyId_InitProc) > 1) {
                    CdlParse::report_error(interp, "", "A wizard should have only one `init_proc' property.");
                }
                if (new_wizard->count_properties(CdlPropertyId_DecorationProc) > 1) {
                    CdlParse::report_error(interp, "", "A wizard should have only one `decoration_proc' property.");
                }
                if (new_wizard->count_properties(CdlPropertyId_ConfirmProc) != 1) {
                    CdlParse::report_error(interp, "", "A wizard should have one `confirm_proc' property.");
                }
                if (new_wizard->count_properties(CdlPropertyId_CancelProc) != 1) {
                    CdlParse::report_error(interp, "", "A wizard should have one `cancel_proc' property.");
                }
                if (new_wizard->count_properties(CdlPropertyId_Screen) < 1) {
                    CdlParse::report_error(interp, "", "A wizard should have at least one `screen' property.");
                }

                // It is necessary to check that all the screen properties have unique numbers
                const std::vector<CdlProperty>& properties = new_wizard->get_properties();
                std::vector<CdlProperty>::const_iterator prop_i, prop_j;
                for (prop_i = properties.begin(); prop_i != properties.end(); prop_i++) {
                    if (CdlPropertyId_Screen != (*prop_i)->get_property_name()) {
                        continue;
                    }
                    CdlProperty_TclCode tclprop = dynamic_cast<CdlProperty_TclCode>(*prop_i);
                    CYG_ASSERT_CLASSC(tclprop);
                    cdl_int num1 = tclprop->get_number();

                    for (prop_j = ++prop_i; prop_j != properties.end(); prop_j++) {
                        if (CdlPropertyId_Screen != (*prop_j)->get_property_name()) {
                            continue;
                        }
                        CdlProperty_TclCode tclprop2 = dynamic_cast<CdlProperty_TclCode>(*prop_j);
                        CYG_ASSERT_CLASSC(tclprop2);
                        cdl_int num2 = tclprop2->get_number();

                        if (num1 == num2) {
                            std::string tmp = "";
                            Cdl::integer_to_string(num1, tmp);
                            CdlParse::report_error(interp, "", "Duplicate definition of screen `" + tmp + "'.");
                            break;
                        }
                    } 
               }

                // There is no restriction on what screen numbers can be
                // defined (screens may appear and disappear during
                // development). It would be nice to validate that the
                // Tcl fragments never switch to an invalid screen, but
                // there is no easy way to do that.
            }
        }
            
    } catch(...) {
        if (0 != new_wizard) {
            delete new_wizard;
        }
        throw;
    }
    
    CYG_REPORT_RETVAL(result);
    return result;
}

// ----------------------------------------------------------------------------
// Syntax: cancel_proc <tclcode>

int
CdlWizardBody::parse_cancel_proc(CdlInterpreter interp, int argc, char** argv)
{
    CYG_REPORT_FUNCNAMETYPE("parse_cancel_proc", "result %d");

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

// ----------------------------------------------------------------------------
// Syntax: confirm_proc <tclcode>

int
CdlWizardBody::parse_confirm_proc(CdlInterpreter interp, int argc, char** argv)
{
    CYG_REPORT_FUNCNAMETYPE("parse_confirm_proc", "result %d");

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

// ----------------------------------------------------------------------------
// syntax: decoration_proc <tclcode>

int
CdlWizardBody::parse_decoration_proc(CdlInterpreter interp, int argc, char** argv)
{
    CYG_REPORT_FUNCNAMETYPE("parse_decoration_proc", "result %d");

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

// ----------------------------------------------------------------------------
// Syntax: init_proc <tclcode>

int
CdlWizardBody::parse_init_proc(CdlInterpreter interp, int argc, char** argv)
{
    CYG_REPORT_FUNCNAMETYPE("parse_init_proc", "result %d");

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

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