1

/*****************************************************************************

     2

 *

     3

 * $Id$

     4

 *

     5

 ****************************************************************************/

     6

     7

#include <getopt.h>

     8

#include <libgen.h> // basename()

     9

    10

#include <iostream>

    11

#include <iomanip>

    12

using namespace std;

    13

    14

#include "CommandAlias.h"

    15

#include "CommandConfig.h"

    16

#include "CommandData.h"

    17

#include "CommandDebug.h"

    18

#include "CommandDomains.h"

    19

#include "CommandDownload.h"

    20

#include "CommandMaster.h"

    21

#include "CommandPdos.h"

    22

#include "CommandPhyRead.h"

    23

#include "CommandPhyWrite.h"

    24

#include "CommandSdos.h"

    25

#include "CommandSiiRead.h"

    26

#include "CommandSiiWrite.h"

    27

#include "CommandSlaves.h"

    28

#include "CommandStates.h"

    29

#include "CommandUpload.h"

    30

#include "CommandVersion.h"

    31

#include "CommandXml.h"

    32

    33

/*****************************************************************************/

    34

    35

typedef list<Command *> CommandList;

    36

CommandList commandList;

    37

    38

MasterDevice masterDev;

    39

    40

string binaryBaseName;

    41

string commandName;

    42

Command::StringVector commandArgs;

    43

    44

// option variables

    45

unsigned int masterIndex = 0;

    46

int slavePosition = -1;

    47

int slaveAlias = -1;

    48

int domainIndex = -1;

    49

string dataTypeStr;

    50

Command::Verbosity verbosity = Command::Normal;

    51

bool force = false;

    52

bool helpRequested = false;

    53

    54

/*****************************************************************************/

    55

    56

string usage()

    57

{

    58

    stringstream str;

    59

    CommandList::const_iterator ci;

    60

    size_t maxWidth = 0;

    61

    62

    for (ci = commandList.begin(); ci != commandList.end(); ci++) {

    63

        if ((*ci)->getName().length() > maxWidth) {

    64

            maxWidth = (*ci)->getName().length();

    65

        }

    66

    }

    67

    68

    str << "Usage: " << binaryBaseName << " <COMMAND> [OPTIONS] [ARGUMENTS]"

    69

        << endl << endl

    70

		<< "Commands (can be abbreviated):" << endl;

    71

    72

    str << left;

    73

    for (ci = commandList.begin(); ci != commandList.end(); ci++) {

    74

        str << "  " << setw(maxWidth) << (*ci)->getName()

    75

            << "  " << (*ci)->getBriefDescription() << endl;

    76

    }

    77

    78

    str << endl

    79

		<< "Global options:" << endl

    80

        << "  --master  -m <master>  Index of the master to use. Default: 0."

    81

		<< endl

    82

        << "  --force   -f           Force a command." << endl

    83

        << "  --quiet   -q           Output less information." << endl

    84

        << "  --verbose -v           Output more information." << endl

    85

        << "  --help    -h           Show this help." << endl

    86

        << endl

    87

        << Command::numericInfo()

    88

        << endl

    89

        << "Call '" << binaryBaseName

    90

        << " <COMMAND> --help' for command-specific help." << endl

    91

        << endl

    92

        << "Send bug reports to " << PACKAGE_BUGREPORT << "." << endl;

    93

    94

    return str.str();

    95

}

    96

    97

/*****************************************************************************/

    98

    99

void getOptions(int argc, char **argv)

   100

{

   101

    int c, argCount;

   102

    stringstream str;

   103

   104

    static struct option longOptions[] = {

   105

        //name,      has_arg,           flag, val

   106

        {"master",   required_argument, NULL, 'm'},

   107

        {"alias",    required_argument, NULL, 'a'},

   108

        {"position", required_argument, NULL, 'p'},

   109

        {"domain",   required_argument, NULL, 'd'},

   110

        {"type",     required_argument, NULL, 't'},

   111

        {"force",    no_argument,       NULL, 'f'},

   112

        {"quiet",    no_argument,       NULL, 'q'},

   113

        {"verbose",  no_argument,       NULL, 'v'},

   114

        {"help",     no_argument,       NULL, 'h'},

   115

        {}

   116

    };

   117

   118

    do {

   119

        c = getopt_long(argc, argv, "m:a:p:d:t:fqvh", longOptions, NULL);

   120

   121

        switch (c) {

   122

            case 'm':

   123

                str.clear();

   124

                str.str("");

   125

                str << optarg;

   126

                str >> resetiosflags(ios::basefield) // guess base from prefix

   127

                    >> masterIndex;

   128

                if (str.fail() || masterIndex < 0) {

   129

                    cerr << "Invalid master number " << optarg << "!" << endl

   130

                        << endl << usage();

   131

                    exit(1);

   132

                }

   133

                break;

   134

   135

            case 'a':

   136

                str.clear();

   137

                str.str("");

   138

                str << optarg;

   139

                str >> resetiosflags(ios::basefield) // guess base from prefix

   140

                    >> slaveAlias;

   141

                if (str.fail() || slaveAlias < 0 || slaveAlias > 0xFFFF) {

   142

                    cerr << "Invalid slave alias " << optarg << "!" << endl

   143

                        << endl << usage();

   144

                    exit(1);

   145

                }

   146

                break;

   147

   148

            case 'p':

   149

                str.clear();

   150

                str.str("");

   151

                str << optarg;

   152

                str >> resetiosflags(ios::basefield) // guess base from prefix

   153

                    >> slavePosition;

   154

                if (str.fail()

   155

                        || slavePosition < 0 || slavePosition > 0xFFFF) {

   156

                    cerr << "Invalid slave position " << optarg << "!" << endl

   157

                        << endl << usage();

   158

                    exit(1);

   159

                }

   160

                break;

   161

   162

            case 'd':

   163

                str.clear();

   164

                str.str("");

   165

                str << optarg;

   166

                str >> resetiosflags(ios::basefield) // guess base from prefix

   167

                    >> domainIndex;

   168

                if (str.fail() || domainIndex < 0) {

   169

                    cerr << "Invalid domain index " << optarg << "!" << endl

   170

                        << endl << usage();

   171

                    exit(1);

   172

                }

   173

                break;

   174

   175

            case 't':

   176

                dataTypeStr = optarg;

   177

                break;

   178

   179

            case 'f':

   180

                force = true;

   181

                break;

   182

   183

            case 'q':

   184

                verbosity = Command::Quiet;

   185

                break;

   186

   187

            case 'v':

   188

                verbosity = Command::Verbose;

   189

                break;

   190

   191

            case 'h':

   192

                helpRequested = true;

   193

                break;

   194

   195

            case '?':

   196

                cerr << endl << usage();

   197

                exit(1);

   198

   199

            default:

   200

                break;

   201

        }

   202

    }

   203

    while (c != -1);

   204

   205

	argCount = argc - optind;

   206

   207

    if (!argCount) {

   208

        if (helpRequested) {

   209

            cout << usage();

   210

            exit(0);

   211

        } else {

   212

            cerr << "Please specify a command!" << endl

   213

                << endl << usage();

   214

            exit(1);

   215

        }

   216

	}

   217

   218

    commandName = argv[optind];

   219

    while (++optind < argc)

   220

        commandArgs.push_back(string(argv[optind]));

   221

}

   222

   223

/****************************************************************************/

   224

   225

list<Command *> getMatchingCommands(const string &cmdStr)

   226

{

   227

    CommandList::iterator ci;

   228

    list<Command *> res;

   229

   230

    // find matching commands from beginning of the string

   231

    for (ci = commandList.begin(); ci != commandList.end(); ci++) {

   232

        if ((*ci)->matchesSubstr(cmdStr)) {

   233

            res.push_back(*ci);

   234

        }

   235

    }

   236

   237

    if (!res.size()) { // nothing found

   238

        // find /any/ matching commands

   239

        for (ci = commandList.begin(); ci != commandList.end(); ci++) {

   240

            if ((*ci)->matchesAbbrev(cmdStr)) {

   241

                res.push_back(*ci);

   242

            }

   243

        }

   244

    }

   245

   246

    return res;

   247

}

   248

   249

/****************************************************************************/

   250

   251

int main(int argc, char **argv)

   252

{

   253

    int retval = 0;

   254

    list<Command *> matchingCommands;

   255

    list<Command *>::const_iterator ci;

   256

    Command *cmd;

   257

   258

    binaryBaseName = basename(argv[0]);

   259

   260

    commandList.push_back(new CommandAlias());

   261

    commandList.push_back(new CommandConfig());

   262

    commandList.push_back(new CommandData());

   263

    commandList.push_back(new CommandDebug());

   264

    commandList.push_back(new CommandDomains());

   265

    commandList.push_back(new CommandDownload());

   266

    commandList.push_back(new CommandMaster());

   267

    commandList.push_back(new CommandPdos());

   268

    commandList.push_back(new CommandPhyRead());

   269

    commandList.push_back(new CommandPhyWrite());

   270

    commandList.push_back(new CommandSdos());

   271

    commandList.push_back(new CommandSiiRead());

   272

    commandList.push_back(new CommandSiiWrite());

   273

    commandList.push_back(new CommandSlaves());

   274

    commandList.push_back(new CommandStates());

   275

    commandList.push_back(new CommandUpload());

   276

    commandList.push_back(new CommandVersion());

   277

    commandList.push_back(new CommandXml());

   278

   279

	getOptions(argc, argv);

   280

   281

    matchingCommands = getMatchingCommands(commandName);

   282

    masterDev.setIndex(masterIndex);

   283

   284

    if (matchingCommands.size()) {

   285

        if (matchingCommands.size() == 1) {

   286

            cmd = matchingCommands.front();

   287

            if (!helpRequested) {

   288

                try {

   289

                    cmd->setVerbosity(verbosity);

   290

                    cmd->setAlias(slaveAlias);

   291

                    cmd->setPosition(slavePosition);

   292

                    cmd->setDomain(domainIndex);

   293

                    cmd->setDataType(dataTypeStr);

   294

                    cmd->setForce(force);

   295

                    cmd->execute(masterDev, commandArgs);

   296

                } catch (InvalidUsageException &e) {

   297

                    cerr << e.what() << endl << endl;

   298

                    cerr << binaryBaseName << " " << cmd->helpString();

   299

                    retval = 1;

   300

                } catch (CommandException &e) {

   301

                    cerr << e.what() << endl;

   302

                    retval = 1;

   303

                } catch (MasterDeviceException &e) {

   304

                    cerr << e.what() << endl;

   305

                    retval = 1;

   306

                }

   307

            } else {

   308

                cout << binaryBaseName << " " << cmd->helpString();

   309

            }

   310

        } else {

   311

            cerr << "Ambiguous command abbreviation! Matching:" << endl;

   312

            for (ci = matchingCommands.begin();

   313

                    ci != matchingCommands.end();

   314

                    ci++) {

   315

                cerr << (*ci)->getName() << endl;

   316

            }

   317

            cerr << endl << usage();

   318

            retval = 1;

   319

        }

   320

    } else {

   321

        cerr << "Unknown command " << commandName << "!" << endl

   322

            << endl << usage();

   323

        retval = 1;

   324

    }

   325

   326

	return retval;

   327

}

   328

   329

/****************************************************************************/