1

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

     2

 *

     3

 * $Id$

     4

 *

     5

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

     6

     7

#include <getopt.h>

     8

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

     9

#include <stdlib.h>

    10

    11

#include <iostream>

    12

#include <iomanip>

    13

using namespace std;

    14

    15

#include "CommandAlias.h"

    16

#include "CommandConfig.h"

    17

#include "CommandData.h"

    18

#include "CommandDebug.h"

    19

#include "CommandDomains.h"

    20

#include "CommandDownload.h"

    21

#include "CommandFoeRead.h"

    22

#include "CommandFoeWrite.h"

    23

#include "CommandMaster.h"

    24

#include "CommandPdos.h"

    25

#include "CommandPhyRead.h"

    26

#include "CommandPhyWrite.h"

    27

#include "CommandSdos.h"

    28

#include "CommandSiiRead.h"

    29

#include "CommandSiiWrite.h"

    30

#include "CommandSlaves.h"

    31

#include "CommandStates.h"

    32

#include "CommandUpload.h"

    33

#include "CommandVersion.h"

    34

#include "CommandXml.h"

    35

    36

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

    37

    38

typedef list<Command *> CommandList;

    39

CommandList commandList;

    40

    41

MasterDevice masterDev;

    42

    43

string binaryBaseName;

    44

string commandName;

    45

Command::StringVector commandArgs;

    46

    47

// option variables

    48

unsigned int masterIndex = 0;

    49

int slavePosition = -1;

    50

int slaveAlias = -1;

    51

int domainIndex = -1;

    52

string dataTypeStr;

    53

Command::Verbosity verbosity = Command::Normal;

    54

bool force = false;

    55

bool helpRequested = false;

    56

string outputFile;

    57

    58

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

    59

    60

string usage()

    61

{

    62

    stringstream str;

    63

    CommandList::const_iterator ci;

    64

    size_t maxWidth = 0;

    65

    66

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

    67

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

    68

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

    69

        }

    70

    }

    71

    72

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

    73

        << endl << endl

    74

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

    75

    76

    str << left;

    77

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

    78

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

    79

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

    80

    }

    81

    82

    str << endl

    83

		<< "Global options:" << endl

    84

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

    85

		<< endl

    86

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

    87

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

    88

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

    89

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

    90

        << endl

    91

        << Command::numericInfo()

    92

        << endl

    93

        << "Call '" << binaryBaseName

    94

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

    95

        << endl

    96

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

    97

    98

    return str.str();

    99

}

   100

   101

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

   102

   103

void getOptions(int argc, char **argv)

   104

{

   105

    int c, argCount;

   106

    stringstream str;

   107

   108

    static struct option longOptions[] = {

   109

        //name,         has_arg,           flag, val

   110

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

   111

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

   112

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

   113

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

   114

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

   115

        {"output-file", required_argument, NULL, 'o'},

   116

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

   117

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

   118

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

   119

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

   120

        {}

   121

    };

   122

   123

    do {

   124

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

   125

   126

        switch (c) {

   127

            case 'm':

   128

                str.clear();

   129

                str.str("");

   130

                str << optarg;

   131

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

   132

                    >> masterIndex;

   133

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

   134

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

   135

                        << endl << usage();

   136

                    exit(1);

   137

                }

   138

                break;

   139

   140

            case 'a':

   141

                str.clear();

   142

                str.str("");

   143

                str << optarg;

   144

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

   145

                    >> slaveAlias;

   146

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

   147

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

   148

                        << endl << usage();

   149

                    exit(1);

   150

                }

   151

                break;

   152

   153

            case 'p':

   154

                str.clear();

   155

                str.str("");

   156

                str << optarg;

   157

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

   158

                    >> slavePosition;

   159

                if (str.fail()

   160

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

   161

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

   162

                        << endl << usage();

   163

                    exit(1);

   164

                }

   165

                break;

   166

   167

            case 'd':

   168

                str.clear();

   169

                str.str("");

   170

                str << optarg;

   171

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

   172

                    >> domainIndex;

   173

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

   174

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

   175

                        << endl << usage();

   176

                    exit(1);

   177

                }

   178

                break;

   179

   180

            case 't':

   181

                dataTypeStr = optarg;

   182

                break;

   183

   184

            case 'o':

   185

                outputFile = optarg;

   186

                break;

   187

   188

            case 'f':

   189

                force = true;

   190

                break;

   191

   192

            case 'q':

   193

                verbosity = Command::Quiet;

   194

                break;

   195

   196

            case 'v':

   197

                verbosity = Command::Verbose;

   198

                break;

   199

   200

            case 'h':

   201

                helpRequested = true;

   202

                break;

   203

   204

            case '?':

   205

                cerr << endl << usage();

   206

                exit(1);

   207

   208

            default:

   209

                break;

   210

        }

   211

    }

   212

    while (c != -1);

   213

   214

	argCount = argc - optind;

   215

   216

    if (!argCount) {

   217

        if (helpRequested) {

   218

            cout << usage();

   219

            exit(0);

   220

        } else {

   221

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

   222

                << endl << usage();

   223

            exit(1);

   224

        }

   225

	}

   226

   227

    commandName = argv[optind];

   228

    while (++optind < argc)

   229

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

   230

}

   231

   232

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

   233

   234

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

   235

{

   236

    CommandList::iterator ci;

   237

    list<Command *> res;

   238

   239

    // find matching commands from beginning of the string

   240

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

   241

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

   242

            res.push_back(*ci);

   243

        }

   244

    }

   245

   246

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

   247

        // find /any/ matching commands

   248

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

   249

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

   250

                res.push_back(*ci);

   251

            }

   252

        }

   253

    }

   254

   255

    return res;

   256

}

   257

   258

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

   259

   260

int main(int argc, char **argv)

   261

{

   262

    int retval = 0;

   263

    list<Command *> matchingCommands;

   264

    list<Command *>::const_iterator ci;

   265

    Command *cmd;

   266

   267

    binaryBaseName = basename(argv[0]);

   268

   269

    commandList.push_back(new CommandAlias());

   270

    commandList.push_back(new CommandConfig());

   271

    commandList.push_back(new CommandData());

   272

    commandList.push_back(new CommandDebug());

   273

    commandList.push_back(new CommandDomains());

   274

    commandList.push_back(new CommandDownload());

   275

    commandList.push_back(new CommandFoeRead());

   276

    commandList.push_back(new CommandFoeWrite());

   277

    commandList.push_back(new CommandMaster());

   278

    commandList.push_back(new CommandPdos());

   279

    commandList.push_back(new CommandPhyRead());

   280

    commandList.push_back(new CommandPhyWrite());

   281

    commandList.push_back(new CommandSdos());

   282

    commandList.push_back(new CommandSiiRead());

   283

    commandList.push_back(new CommandSiiWrite());

   284

    commandList.push_back(new CommandSlaves());

   285

    commandList.push_back(new CommandStates());

   286

    commandList.push_back(new CommandUpload());

   287

    commandList.push_back(new CommandVersion());

   288

    commandList.push_back(new CommandXml());

   289

   290

	getOptions(argc, argv);

   291

   292

    matchingCommands = getMatchingCommands(commandName);

   293

    masterDev.setIndex(masterIndex);

   294

   295

    if (matchingCommands.size()) {

   296

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

   297

            cmd = matchingCommands.front();

   298

            if (!helpRequested) {

   299

                try {

   300

                    cmd->setVerbosity(verbosity);

   301

                    cmd->setAlias(slaveAlias);

   302

                    cmd->setPosition(slavePosition);

   303

                    cmd->setDomain(domainIndex);

   304

                    cmd->setDataType(dataTypeStr);

   305

                    cmd->setOutputFile(outputFile);

   306

                    cmd->setForce(force);

   307

                    cmd->execute(masterDev, commandArgs);

   308

                } catch (InvalidUsageException &e) {

   309

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

   310

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

   311

                    retval = 1;

   312

                } catch (CommandException &e) {

   313

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

   314

                    retval = 1;

   315

                } catch (MasterDeviceException &e) {

   316

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

   317

                    retval = 1;

   318

                }

   319

            } else {

   320

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

   321

            }

   322

        } else {

   323

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

   324

            for (ci = matchingCommands.begin();

   325

                    ci != matchingCommands.end();

   326

                    ci++) {

   327

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

   328

            }

   329

            cerr << endl << usage();

   330

            retval = 1;

   331

        }

   332

    } else {

   333

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

   334

            << endl << usage();

   335

        retval = 1;

   336

    }

   337

   338

	return retval;

   339

}

   340

   341

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