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 "CommandMaster.h"

    20

#include "CommandPdos.h"

    21

#include "CommandSdos.h"

    22

#include "CommandDownload.h"

    23

#include "CommandUpload.h"

    24

#include "CommandSlaves.h"

    25

#include "CommandSiiRead.h"

    26

#include "CommandSiiWrite.h"

    27

#include "CommandStates.h"

    28

#include "CommandXml.h"

    29

    30

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

    31

    32

typedef list<Command *> CommandList;

    33

CommandList commandList;

    34

    35

MasterDevice masterDev;

    36

    37

string binaryBaseName;

    38

string commandName;

    39

Command::StringVector commandArgs;

    40

    41

// option variables

    42

unsigned int masterIndex = 0;

    43

int slavePosition = -1;

    44

int domainIndex = -1;

    45

string dataTypeStr;

    46

Command::Verbosity verbosity = Command::Normal;

    47

bool force = false;

    48

bool helpRequested = false;

    49

    50

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

    51

    52

string usage()

    53

{

    54

    stringstream str;

    55

    CommandList::const_iterator ci;

    56

    size_t maxWidth = 0;

    57

    58

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

    59

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

    60

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

    61

        }

    62

    }

    63

    64

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

    65

        << endl << endl

    66

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

    67

    68

    str << left;

    69

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

    70

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

    71

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

    72

    }

    73

    74

    str << endl

    75

		<< "Global options:" << endl

    76

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

    77

		<< endl

    78

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

    79

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

    80

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

    81

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

    82

        << endl

    83

        << Command::numericInfo()

    84

        << endl

    85

        << "Call '" << binaryBaseName

    86

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

    87

        << endl

    88

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

    89

    90

    return str.str();

    91

}

    92

    93

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

    94

    95

void getOptions(int argc, char **argv)

    96

{

    97

    int c, argCount, optionIndex, number;

    98

	char *remainder;

    99

   100

    static struct option longOptions[] = {

   101

        //name,     has_arg,           flag, val

   102

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

   103

        {"slave",   required_argument, NULL, 's'},

   104

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

   105

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

   106

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

   107

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

   108

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

   109

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

   110

        {}

   111

    };

   112

   113

    do {

   114

        c = getopt_long(argc, argv, "m:s:d:t:fqvh", longOptions, &optionIndex);

   115

   116

        switch (c) {

   117

            case 'm':

   118

                number = strtoul(optarg, &remainder, 0);

   119

                if (remainder == optarg || *remainder || number < 0) {

   120

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

   121

                        << endl << usage();

   122

                    exit(1);

   123

                }

   124

				masterIndex = number;

   125

                break;

   126

   127

            case 's':

   128

                if (!strcmp(optarg, "all")) {

   129

                    slavePosition = -1;

   130

                } else {

   131

                    number = strtoul(optarg, &remainder, 0);

   132

                    if (remainder == optarg || *remainder

   133

                            || number < 0 || number > 0xFFFF) {

   134

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

   135

                            << endl << endl << usage();

   136

                        exit(1);

   137

                    }

   138

                    slavePosition = number;

   139

                }

   140

                break;

   141

   142

            case 'd':

   143

                if (!strcmp(optarg, "all")) {

   144

                    domainIndex = -1;

   145

                } else {

   146

                    number = strtoul(optarg, &remainder, 0);

   147

                    if (remainder == optarg || *remainder || number < 0) {

   148

                        cerr << "Invalid domain index "

   149

							<< optarg << "!" << endl << endl << usage();

   150

                        exit(1);

   151

                    }

   152

                    domainIndex = number;

   153

                }

   154

                break;

   155

   156

            case 't':

   157

                dataTypeStr = optarg;

   158

                break;

   159

   160

            case 'f':

   161

                force = true;

   162

                break;

   163

   164

            case 'q':

   165

                verbosity = Command::Quiet;

   166

                break;

   167

   168

            case 'v':

   169

                verbosity = Command::Verbose;

   170

                break;

   171

   172

            case 'h':

   173

                helpRequested = true;

   174

                break;

   175

   176

            case '?':

   177

                cerr << endl << usage();

   178

                exit(1);

   179

   180

            default:

   181

                break;

   182

        }

   183

    }

   184

    while (c != -1);

   185

   186

	argCount = argc - optind;

   187

   188

    if (!argCount) {

   189

        if (helpRequested) {

   190

            cout << usage();

   191

            exit(0);

   192

        } else {

   193

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

   194

                << endl << usage();

   195

            exit(1);

   196

        }

   197

	}

   198

   199

    commandName = argv[optind];

   200

    while (++optind < argc)

   201

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

   202

}

   203

   204

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

   205

   206

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

   207

{

   208

    CommandList::iterator ci;

   209

    list<Command *> res;

   210

   211

    // find matching commands from beginning of the string

   212

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

   213

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

   214

            res.push_back(*ci);

   215

        }

   216

    }

   217

   218

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

   219

        // find /any/ matching commands

   220

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

   221

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

   222

                res.push_back(*ci);

   223

            }

   224

        }

   225

    }

   226

   227

    return res;

   228

}

   229

   230

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

   231

   232

int main(int argc, char **argv)

   233

{

   234

    int retval = 0;

   235

    list<Command *> matchingCommands;

   236

    list<Command *>::const_iterator ci;

   237

    Command *cmd;

   238

   239

    binaryBaseName = basename(argv[0]);

   240

   241

    commandList.push_back(new CommandAlias());

   242

    commandList.push_back(new CommandConfig());

   243

    commandList.push_back(new CommandData());

   244

    commandList.push_back(new CommandDebug());

   245

    commandList.push_back(new CommandDomains());

   246

    commandList.push_back(new CommandDownload());

   247

    commandList.push_back(new CommandMaster());

   248

    commandList.push_back(new CommandPdos());

   249

    commandList.push_back(new CommandSdos());

   250

    commandList.push_back(new CommandSiiRead());

   251

    commandList.push_back(new CommandSiiWrite());

   252

    commandList.push_back(new CommandSlaves());

   253

    commandList.push_back(new CommandStates());

   254

    commandList.push_back(new CommandUpload());

   255

    commandList.push_back(new CommandXml());

   256

   257

	getOptions(argc, argv);

   258

   259

    matchingCommands = getMatchingCommands(commandName);

   260

    masterDev.setIndex(masterIndex);

   261

   262

    if (matchingCommands.size()) {

   263

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

   264

            cmd = matchingCommands.front();

   265

            if (!helpRequested) {

   266

                try {

   267

                    cmd->setVerbosity(verbosity);

   268

                    cmd->execute(masterDev, commandArgs);

   269

                } catch (InvalidUsageException &e) {

   270

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

   271

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

   272

                    retval = 1;

   273

                } catch (CommandException &e) {

   274

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

   275

                    retval = 1;

   276

                } catch (MasterDeviceException &e) {

   277

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

   278

                    retval = 1;

   279

                }

   280

            } else {

   281

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

   282

            }

   283

        } else {

   284

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

   285

            for (ci = matchingCommands.begin();

   286

                    ci != matchingCommands.end();

   287

                    ci++) {

   288

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

   289

            }

   290

            cerr << endl << usage();

   291

            retval = 1;

   292

        }

   293

    } else {

   294

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

   295

            << endl << usage();

   296

        retval = 1;

   297

    }

   298

   299

	return retval;

   300

}

   301

   302

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