GenerateProcessorDialog Class Reference

#include <GenerateProcessorDialog.hh>

Inheritance diagram for GenerateProcessorDialog:

Collaboration diagram for GenerateProcessorDialog:

Public Member Functions
	GenerateProcessorDialog (wxWindow *parent, TTAMachine::Machine &machine, const IDF::MachineImplementation &impl)
virtual	~GenerateProcessorDialog ()

Private Types
enum	{   ID_GENERATE_BEM , ID_LOAD_BEM , ID_SAVE_BEM , ID_BROWSE_BEM_LOAD ,   ID_BEM_LOAD_PATH , ID_BROWSE_BEM_SAVE , ID_BEM_SAVE_PATH , ID_TARGET ,   ID_BROWSE_TARGET , ID_LINE , ID_VHDL , ID_VERILOG }
	Widget IDs. More...

Private Member Functions
void	onOK (wxCommandEvent &event)
void	onBrowseBEMLoad (wxCommandEvent &event)
void	onBrowseBEMSave (wxCommandEvent &event)
void	onBrowseTargetDir (wxCommandEvent &event)
ProGe::ICDecoderGeneratorPlugin *	loadICDecoderGeneratorPlugin (const std::string &pluginFile, const std::string &pluginName)
wxSizer *	createContents (wxWindow *parent, bool call_fit, bool set_sizer)

Private Attributes
TTAMachine::Machine &	machine_
	Processor architecture.
const IDF::MachineImplementation &	impl_
	Processor implementation definition.
BinaryEncoding *	bem_
	Binary Encosing Map.

Detailed Description

Dialog for generating processor implementation using ProGe.

Definition at line 56 of file GenerateProcessorDialog.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Widget IDs.

Enumerator
ID_GENERATE_BEM
ID_LOAD_BEM
ID_SAVE_BEM
ID_BROWSE_BEM_LOAD
ID_BEM_LOAD_PATH
ID_BROWSE_BEM_SAVE
ID_BEM_SAVE_PATH
ID_TARGET
ID_BROWSE_TARGET
ID_LINE
ID_VHDL
ID_VERILOG

Definition at line 84 of file GenerateProcessorDialog.hh.

         {
        ID_GENERATE_BEM,
        ID_LOAD_BEM,
        ID_SAVE_BEM,
        ID_BROWSE_BEM_LOAD,
        ID_BEM_LOAD_PATH,
        ID_BROWSE_BEM_SAVE,
        ID_BEM_SAVE_PATH,
        ID_TARGET,
        ID_BROWSE_TARGET,
        ID_LINE,
        ID_VHDL,
        ID_VERILOG
    };

Constructor & Destructor Documentation

GenerateProcessorDialog()

GenerateProcessorDialog::GenerateProcessorDialog	(	wxWindow *	parent,
		TTAMachine::Machine &	machine,
		const IDF::MachineImplementation &	impl
	)

The Constructor.

Parameters

paren	Parent window of the dialog.
machine	Processor architecture.
imp	Processor implementation definition.

Definition at line 87 of file GenerateProcessorDialog.cc.

                                          :
    wxDialog(parent, -1, _T("Generate Processor"), wxDefaultPosition),
    machine_(machine), impl_(impl), bem_(NULL) {
 
    createContents(this, true, true);
}

~GenerateProcessorDialog()

GenerateProcessorDialog::~GenerateProcessorDialog ( )

virtual

The Destructor.

Definition at line 101 of file GenerateProcessorDialog.cc.

                                                  {
    if (bem_ != NULL) {
        delete bem_;
    }
}

References bem_.

Member Function Documentation

createContents()

wxSizer * GenerateProcessorDialog::createContents ( wxWindow *  parent, bool  call_fit, bool  set_sizer  )

private

Craetes the dialog contents.

Definition at line 358 of file GenerateProcessorDialog.cc.

                                                     {
 
    wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
 
    wxBoxSizer *item1 = new wxBoxSizer( wxVERTICAL );
 
    //HDL type radio buttons
    wxStaticBox *hdl_box = new wxStaticBox( parent, -1, wxT("HDL type selection:") );
    wxStaticBoxSizer *hdl_boxsizer = new wxStaticBoxSizer( hdl_box, wxVERTICAL );
 
    wxRadioButton *vhdl_item = new wxRadioButton( parent, ID_VHDL, wxT("VHDL"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
    vhdl_item->SetValue( TRUE );
 
    wxRadioButton *verilog_item = new wxRadioButton( parent, ID_VERILOG, wxT("Verilog"), wxDefaultPosition, wxDefaultSize, 0 );
 
    hdl_boxsizer->Add( vhdl_item, 0, wxALL, 5 );
    hdl_boxsizer->Add( verilog_item, 0, wxALL, 5 );
    item1->Add( hdl_boxsizer, 0, wxGROW|wxALL, 5 );
    //
 
    wxStaticBox *item3 = new wxStaticBox( parent, -1, wxT("Binary Encoding Map:") );
    wxStaticBoxSizer *item2 = new wxStaticBoxSizer( item3, wxVERTICAL );
 
    wxRadioButton *item4 = new wxRadioButton( parent, ID_GENERATE_BEM, wxT("Generate new"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
    item4->SetValue( TRUE );
    item2->Add( item4, 0, wxALL, 5 );
 
    wxBoxSizer *item5 = new wxBoxSizer( wxVERTICAL );
 
    wxBoxSizer *item6 = new wxBoxSizer( wxHORIZONTAL );
 
    wxCheckBox *item7 = new wxCheckBox( parent, ID_SAVE_BEM, wxT("Save to file:"), wxDefaultPosition, wxDefaultSize, 0 );
    item6->Add( item7, 0, wxLEFT, 5 );
 
    item5->Add( item6, 0, wxALL, 5 );
 
    wxBoxSizer *item8 = new wxBoxSizer( wxHORIZONTAL );
 
    wxTextCtrl *item9 = new wxTextCtrl( parent, ID_BEM_SAVE_PATH, wxT(""), wxDefaultPosition, wxSize(300,-1), 0 );
    item8->Add( item9, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxButton *item10 = new wxButton( parent, ID_BROWSE_BEM_SAVE, wxT("Browse..."), wxDefaultPosition, wxDefaultSize, 0 );
    item8->Add( item10, 0, wxALIGN_CENTER|wxALL, 5 );
 
    item5->Add( item8, 0, wxALL, 5 );
 
    item2->Add( item5, 0, wxGROW|wxALL, 5 );
 
    wxRadioButton *item11 = new wxRadioButton( parent, ID_LOAD_BEM, wxT("Load from file"), wxDefaultPosition, wxDefaultSize, 0 );
    item2->Add( item11, 0, wxALL, 5 );
 
    wxBoxSizer *item12 = new wxBoxSizer( wxHORIZONTAL );
 
    wxTextCtrl *item13 = new wxTextCtrl( parent, ID_BEM_LOAD_PATH, wxT(""), wxDefaultPosition, wxSize(300,-1), 0 );
    item12->Add( item13, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxButton *item14 = new wxButton( parent, ID_BROWSE_BEM_LOAD, wxT("Browse..."), wxDefaultPosition, wxDefaultSize, 0 );
    item12->Add( item14, 0, wxALIGN_CENTER|wxALL, 5 );
 
    item2->Add( item12, 0, wxALL, 5 );
 
    item1->Add( item2, 0, wxGROW|wxALL, 5 );
 
    item1->Add( 20, 20, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxStaticBox *item16 = new wxStaticBox( parent, -1, wxT("Target directory:") );
    wxStaticBoxSizer *item15 = new wxStaticBoxSizer( item16, wxVERTICAL );
 
    wxBoxSizer *item17 = new wxBoxSizer( wxHORIZONTAL );
 
    wxTextCtrl *item18 = new wxTextCtrl( parent, ID_TARGET, wxT(""), wxDefaultPosition, wxSize(300,-1), 0 );
    item17->Add( item18, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxButton *item19 = new wxButton( parent, ID_BROWSE_TARGET, wxT("Browse..."), wxDefaultPosition, wxDefaultSize, 0 );
    item17->Add( item19, 0, wxALIGN_CENTER|wxALL, 5 );
 
    item15->Add( item17, 0, wxALL, 5 );
 
    item1->Add( item15, 0, wxGROW|wxALL, 5 );
 
    wxStaticLine *item20 = new wxStaticLine( parent, ID_LINE, wxDefaultPosition, wxSize(20,-1), wxLI_HORIZONTAL );
    item1->Add( item20, 0, wxGROW|wxALL, 5 );
 
    wxBoxSizer *item21 = new wxBoxSizer( wxHORIZONTAL );
 
    wxButton *item22 = new wxButton( parent, wxID_CANCEL, wxT("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    item21->Add( item22, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxButton *item23 = new wxButton( parent, wxID_OK, wxT("OK"), wxDefaultPosition, wxDefaultSize, 0 );
    item21->Add( item23, 0, wxALIGN_CENTER|wxALL, 5 );
 
    item1->Add( item21, 0, wxALL, 5 );
 
    item0->Add( item1, 0, wxGROW|wxALL, 5 );
 
    if (set_sizer)
    {
        parent->SetSizer( item0 );
        if (call_fit)
            item0->SetSizeHints( parent );
    }
 
    return item0;
}

References ID_BEM_LOAD_PATH, ID_BEM_SAVE_PATH, ID_BROWSE_BEM_LOAD, ID_BROWSE_BEM_SAVE, ID_BROWSE_TARGET, ID_GENERATE_BEM, ID_LINE, ID_LOAD_BEM, ID_SAVE_BEM, ID_TARGET, ID_VERILOG, ID_VHDL, and TRUE.

loadICDecoderGeneratorPlugin()

ProGe::ICDecoderGeneratorPlugin * GenerateProcessorDialog::loadICDecoderGeneratorPlugin ( const std::string &  pluginFile, const std::string &  pluginName  )

private

Loads the given IC/decoder generator plugin.

Parameters

pluginFile	The file that implements the plugin.
pluginName	Name of the plugin.

Definition at line 318 of file GenerateProcessorDialog.cc.

                              {
 
    PluginTools pluginTool;
 
    // initialize the plugin tool
    vector<string> pluginPaths = Environment::icDecoderPluginPaths();
    for (vector<string>::const_iterator iter = pluginPaths.begin();
         iter != pluginPaths.end(); iter++) {
        try {
            pluginTool.addSearchPath(*iter);
        } catch (const FileNotFound&) {
        }
    }
 
    try {
        pluginTool.registerModule(pluginFile);
    } catch (Exception& e) {
        wxString message = _T("Error loading IC/Decoder generator plugin:\n");
        message.Append(WxConversion::toWxString(e.errorMessage()));
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        return NULL;
    }
 
    ProGe::ICDecoderGeneratorPlugin* (*creator)(
        TTAMachine::Machine&, BinaryEncoding&);
 
    pluginTool.importSymbol(
        "create_generator_plugin_" + pluginName, creator, pluginFile);
 
    ProGe::ICDecoderGeneratorPlugin* plugin = creator(machine_, *bem_);
    return plugin;
}

References PluginTools::addSearchPath(), bem_, Exception::errorMessage(), Environment::icDecoderPluginPaths(), PluginTools::importSymbol(), machine_, PluginTools::registerModule(), and WxConversion::toWxString().

Here is the call graph for this function:

onBrowseBEMLoad()

void GenerateProcessorDialog::onBrowseBEMLoad ( wxCommandEvent &  event )

private

Event handler for the ben loading Browse... button.

Definition at line 264 of file GenerateProcessorDialog.cc.

                                                        {
 
    wxTextCtrl* ctrl = dynamic_cast<wxTextCtrl*>(FindWindow(ID_BEM_LOAD_PATH));
 
    wxFileDialog dialog(
        this, _T("Choose a file"), _T(""), _T(""),
        _T("Binary Encoding Maps (*.bem)|*.bem|All files|*"),
        (wxOPEN | wxFILE_MUST_EXIST));
 
    if (dialog.ShowModal() == wxID_OK) {
        if (bem_ != NULL) {
            delete bem_;
            bem_ = NULL;
            ctrl->SetValue(_T(""));
        }
        string path = WxConversion::toString(dialog.GetPath());
        try {
            BEMSerializer serializer;
            serializer.setSourceFile(path);
            bem_ = serializer.readBinaryEncoding();
        } catch (Exception& e) {
            wxString message = _T("Error loading binary encoding map:\n");
            message.Append(WxConversion::toWxString(e.errorMessage()));
            ErrorDialog dialog(this, message);
            dialog.ShowModal();
            return;
        }
        ctrl->SetValue(dialog.GetPath());
    }
}

References bem_, Exception::errorMessage(), ID_BEM_LOAD_PATH, BEMSerializer::readBinaryEncoding(), XMLSerializer::setSourceFile(), WxConversion::toString(), and WxConversion::toWxString().

Here is the call graph for this function:

onBrowseBEMSave()

void GenerateProcessorDialog::onBrowseBEMSave ( wxCommandEvent &  event )

private

Event handler for the bem saving Browse... button.

Definition at line 245 of file GenerateProcessorDialog.cc.

                                                        {
 
    wxString fileTypes = _T("Binary Encoding Map (.bem)|*.bem|");
    wxFileDialog dialog(
        this, _T("Choose a file"), _T("."), _T(""), fileTypes,
        wxSAVE | wxOVERWRITE_PROMPT);
 
    if (dialog.ShowModal() == wxID_OK) {
        wxTextCtrl* ctrl = dynamic_cast<wxTextCtrl*>(
            FindWindow(ID_BEM_SAVE_PATH));
        ctrl->SetValue(dialog.GetPath());
    }
}

References ID_BEM_SAVE_PATH.

onBrowseTargetDir()

void GenerateProcessorDialog::onBrowseTargetDir ( wxCommandEvent &  event )

private

Event handler for the target directory Browse... button.

Definition at line 300 of file GenerateProcessorDialog.cc.

                                                          {
 
    wxDirDialog dialog(
        this, _T("Choose a directory"), _T(""), wxDD_NEW_DIR_BUTTON);
 
    if (dialog.ShowModal() == wxID_OK) {
        wxTextCtrl* ctrl = dynamic_cast<wxTextCtrl*>(FindWindow(ID_TARGET));
        ctrl->SetValue(dialog.GetPath());
    }
}

References ID_TARGET.

onOK()

void GenerateProcessorDialog::onOK ( wxCommandEvent &  event )

private

Event handler for the OK button.

Definition at line 111 of file GenerateProcessorDialog.cc.

                                             {
 
    std::ostringstream errorStream;
    std::ostringstream warningStream;
 
    // Binary encoding map.
    if (dynamic_cast<wxRadioButton*>(
            FindWindow(ID_GENERATE_BEM))->GetValue()) {
 
        // Generate new bem.
        if (bem_ != NULL) {
            delete bem_;
            bem_ = NULL;
        }
        BEMGenerator generator(machine_);
        bem_ = generator.generate();
 
        if (dynamic_cast<wxCheckBox*>(FindWindow(ID_SAVE_BEM))->IsChecked()) {
            wxTextCtrl* ctrl =
                dynamic_cast<wxTextCtrl*>(FindWindow(ID_BEM_SAVE_PATH));
            string bemPath = WxConversion::toString(ctrl->GetValue());
            if (bemPath != "") {
                BEMSerializer serializer;
                serializer.setDestinationFile(bemPath);
                try {
                    serializer.writeBinaryEncoding(*bem_);
                } catch (Exception& e) {
                    wxString message = _T("Error saving BEM:");
                    message.Append(WxConversion::toWxString(e.errorMessage()));
                    ErrorDialog dialog(this, message);
                    dialog.ShowModal();
                    return;
                }
            } else {
                wxString message = _T("BEM target file not defined.");
                ErrorDialog dialog(this, message);
                dialog.ShowModal();
                return;
            }
        }
        
    } else {
        if (bem_ == NULL) {
            wxString message = _T("Error: No binary encoding map loaded.");
            ErrorDialog dialog(this, message);
            dialog.ShowModal();
            return;
        }
    }
 
    // Target directory.
    wxTextCtrl* ctrl = dynamic_cast<wxTextCtrl*>(FindWindow(ID_TARGET));
    string targetDir = WxConversion::toString(ctrl->GetValue());
    if (!FileSystem::fileExists(targetDir) ||
        !FileSystem::fileIsDirectory(targetDir)) {
 
        wxString message = _T("Target directory '");
        message.Append(WxConversion::toWxString(targetDir));
        message.Append(_T("' does not exist."));
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        return;
    }
 
    ProGeOptions options;
    options.outputDirectory = targetDir;
    options.sharedOutputDirectory = targetDir;
    options.generateTestbench = true;
    options.validate();
    // validate() would override this based on the given string option
    wxRadioButton *VHDLItem = (wxRadioButton *) FindWindow(ID_VHDL);
    options.language = (VHDLItem->GetValue()) ? ProGe::VHDL : ProGe::Verilog;
 
    ProGe::ProGeUI progeUI;
    try {
        std::ostringstream verboseStream;
 
 
        progeUI.loadMachine(machine_);
        progeUI.loadBinaryEncoding(*bem_);
        progeUI.loadMachineImplementation(impl_);
        progeUI.generateProcessor(options, 1,
                                  errorStream, warningStream, verboseStream);
    } catch (Exception& e) {
        wxString message = WxConversion::toWxString(e.errorMessage());
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        return;
    }
 
    string testBenchDir = targetDir + FileSystem::DIRECTORY_SEPARATOR + "tb";
    try {
        progeUI.generateTestBench(options.language, testBenchDir, targetDir);
    } catch (const Exception& e) {
        std::cerr << e.errorMessage() << std::endl;
        wxString message = WxConversion::toWxString(e.errorMessage());
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
    }
 
    try {
        progeUI.generateScripts(options.language, targetDir, targetDir,
                                targetDir, testBenchDir, "52390");
    } catch (const Exception& e) {
        std::cerr << "Warning: Processor Generator failed to "
                << "generate simulation/compilation scripts."
                << std::endl;
        std::cerr << e.errorMessage() << std::endl;
    }
 
    string warningMessages = warningStream.str();
    if (warningMessages != "") {
        WarningDialog dialog(this, WxConversion::toWxString(warningMessages));
        dialog.ShowModal();
    }
 
    string errorMessages = errorStream.str();
    if (errorMessages != "") {
        ErrorDialog dialog(this, WxConversion::toWxString(errorMessages));
        dialog.ShowModal();
        return;
    }
 
    wxString message = _T("Processor was succesfully generated.");
    InformationDialog dialog(this, message);
    dialog.ShowModal();
 
    EndModal(wxID_OK);
}

References bem_, FileSystem::DIRECTORY_SEPARATOR, Exception::errorMessage(), FileSystem::fileExists(), FileSystem::fileIsDirectory(), BEMGenerator::generate(), ProGe::ProGeUI::generateProcessor(), ProGe::ProGeUI::generateScripts(), ProGe::ProGeUI::generateTestBench(), ID_BEM_SAVE_PATH, ID_GENERATE_BEM, ID_SAVE_BEM, ID_TARGET, ID_VHDL, impl_, ProGe::ProGeUI::loadBinaryEncoding(), ProGe::ProGeUI::loadMachine(), ProGe::ProGeUI::loadMachineImplementation(), machine_, options, XMLSerializer::setDestinationFile(), WxConversion::toString(), WxConversion::toWxString(), ProGe::Verilog, ProGe::VHDL, and BEMSerializer::writeBinaryEncoding().

Here is the call graph for this function:

Member Data Documentation

bem_

BinaryEncoding* GenerateProcessorDialog::bem_

private

Binary Encosing Map.

Definition at line 81 of file GenerateProcessorDialog.hh.

Referenced by loadICDecoderGeneratorPlugin(), onBrowseBEMLoad(), onOK(), and ~GenerateProcessorDialog().

impl_

const IDF::MachineImplementation& GenerateProcessorDialog::impl_

private

Processor implementation definition.

Definition at line 79 of file GenerateProcessorDialog.hh.

Referenced by onOK().

machine_

TTAMachine::Machine& GenerateProcessorDialog::machine_

private

Processor architecture.

Definition at line 77 of file GenerateProcessorDialog.hh.

Referenced by loadICDecoderGeneratorPlugin(), and onOK().

---

The documentation for this class was generated from the following files:

• GenerateProcessorDialog.hh
• GenerateProcessorDialog.cc