DictionaryTool.cc File Reference

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "ADFSerializer.hh"
#include "Application.hh"
#include "Machine.hh"
#include "ProgrammabilityValidator.hh"
#include "ProgrammabilityValidatorResults.hh"
#include "CmdLineOptions.hh"
#include "Exception.hh"
#include "Binary.hh"
#include "TPEFWriter.hh"
#include "TPEFProgramFactory.hh"
#include "ProgramWriter.hh"
#include "BinaryStream.hh"
#include "MoveElement.hh"
#include "tce_config.h"

Include dependency graph for DictionaryTool.cc:

Go to the source code of this file.

Classes
class	DictionaryToolCmdLineOptions

Functions
int	main (int argc, char *argv[])

Detailed Description

DictionaryTool main application.

Author

Jari M�ntyneva 2006 (jari.mantyneva-no.spam-tut.fi)

Note

rating: red

Definition in file DictionaryTool.cc.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

The dictionary_tool main function.

Definition at line 162 of file DictionaryTool.cc.

                                 {
 
    DictionaryToolCmdLineOptions options;
 
    try {
        options.parse(argv, argc);
    } catch (ParserStopRequest const&) {
        return EXIT_SUCCESS;
    } catch (const IllegalCommandLine& e) {
        cerr << e.errorMessage() << endl;
        return EXIT_FAILURE;
    }
    
    if (options.numberOfArguments() == 0) {
        options.printHelp();
        return EXIT_SUCCESS;
    } else if (options.numberOfArguments() > 1) {
        cerr << "Illegal number of arguments" << endl;
        return EXIT_FAILURE;
    }
 
    string adfFileName = options.argument(1);
 
    ADFSerializer adfSerializer;
    adfSerializer.setSourceFile(adfFileName);
 
    TTAMachine::Machine* mach;
 
    try {
        mach = adfSerializer.readMachine();
    } catch (...) {
        cout.flush();
        cerr << "Error opening ADF file:" << endl
             << "- Is the filename correct?" << endl
             << "- Is the machine legal?" << endl;
        return EXIT_FAILURE;
    }
 
    ProgrammabilityValidator* validator;
   
    try {   
    validator = new ProgrammabilityValidator(*mach);
    } catch (IllegalMachine& e) {   
    cerr << e.errorMessage() << endl;
    return EXIT_FAILURE;
    }
 
    ProgrammabilityValidatorResults booleanResults;
    validator->checkBooleanRegister(booleanResults);
    if (booleanResults.errorCount() != 0) {
        for (int i = 0; i < booleanResults.errorCount(); i++) {
            ProgrammabilityValidatorResults::Error error = 
                booleanResults.error(i);
            
            cerr << error.second << endl;
        }
        cerr << "Execution stopped." << endl;
        return EXIT_SUCCESS;
    }
 
    bool gcrError = false;
 
    ProgrammabilityValidatorResults results;
    TPEF::Binary* binaryProgram = NULL;
    try {
        binaryProgram = validator->profile(results);
    } catch (NotAvailable& e) {
        cerr << e.errorMessage() << endl;
        cerr << "Check that all operations are found in OSAL." << endl;
        cerr << "Create new ones with OSEd." << endl;
        cerr << "Execution stopped." << endl;
        return EXIT_FAILURE;
    } catch (InstanceNotFound& e) {
        cerr << e.errorMessage() << endl;
    }
 
    if (options.writeBinary()) {
        string outputFile = adfFileName.append("_profiled.tpef");
        BinaryStream tpefOut(outputFile);
        TPEFWriter::instance().writeBinary(tpefOut, binaryProgram);
    }
 
    if (!options.doNotPrintErrors()) {
        for (int i = 0; i < results.errorCount(); i++) {
            ProgrammabilityValidatorResults::Error error = results.error(i);
            if (error.first == 
                ProgrammabilityValidator::
                OPERATION_MISSING_FROM_THE_PRIMITIVE_OPERATION_SET) {
                if (options.printPrimitive()) {
                    cerr << error.second << endl;
                }
            }
            else if (error.first == 
                     ProgrammabilityValidator::
                     GLOBAL_CONNECTION_REGISTER_NOT_FOUND) {
                if (options.printGlobalRegister()) {
                    gcrError = true;
                    cerr << error.second << endl;
                }
            }
            else if (error.first ==
                     ProgrammabilityValidator::
                     MISSING_CONNECTION) {
                if (options.printMissingConnections()) {
                    cerr << error.second << endl;
                }
            }
            else {
                cerr << error.second << endl;
            }
        }
    }
 
    if (options.printGlobalRegister() && !gcrError) {        
        cout << "* The global connection register in the machine is: " 
             << validator->findGlobalConnectionRegister()->name() 
             << endl;
    }
    
    if (options.printConnections()) {
        validator->printConnections();
    }
 
    if (options.printRFConnections()) {
        validator->printRegisterConnections();
    }
    
    return EXIT_SUCCESS;
}

References CmdLineParser::argument(), ProgrammabilityValidator::checkBooleanRegister(), ProgrammabilityValidatorResults::error(), ProgrammabilityValidatorResults::errorCount(), Exception::errorMessage(), ProgrammabilityValidator::findGlobalConnectionRegister(), TPEF::TPEFWriter::instance(), TTAMachine::Component::name(), CmdLineParser::numberOfArguments(), options, CmdLineOptions::parse(), ProgrammabilityValidator::printConnections(), MachInfoCmdLineOptions::printHelp(), ProgrammabilityValidator::printRegisterConnections(), ProgrammabilityValidator::profile(), ADFSerializer::readMachine(), XMLSerializer::setSourceFile(), and TPEF::BinaryWriter::writeBinary().

Here is the call graph for this function: