1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2009  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

#include <cstring>

    31

#include <sstream>

    32

#include <stdexcept>

    33

using namespace std;

    34

    35

#include "NumberListParser.h"

    36

    37

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

    38

    39

NumberListParser::NumberListParser():

    40

    max(0U),

    41

    hasMax(false)

    42

{

    43

}

    44

    45

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

    46

    47

NumberListParser::~NumberListParser()

    48

{

    49

}

    50

    51

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

    52

    53

NumberListParser::List NumberListParser::parse(const char *data)

    54

{

    55

    List ret;

    56

    unsigned int i = 0, size = strlen(data), firstNum = 0U, secondNum = 0U;

    57

    typedef enum {

    58

        SectionStart,

    59

        FirstNumber,

    60

        Range,

    61

        SecondNumber,

    62

        Finished

    63

    } State;

    64

    State state = SectionStart;

    65

    66

    while (state != Finished) {

    67

        switch (state) {

    68

            case SectionStart:

    69

                if (i >= size) {

    70

                    state = Finished;

    71

                } else if (isNumeric(data[i])) {

    72

                    firstNum = parseNumber(data, &i, size);

    73

                    state = FirstNumber;

    74

                } else if (data[i] == '-') {

    75

                    firstNum = 0U;

    76

                    i++;

    77

                    state = Range;

    78

                } else if (data[i] == ',') {

    79

                    i++;

    80

                } else {

    81

                    stringstream err;

    82

                    err << "Invalid character " << data[i]

    83

                        << " at position " << i << "in state "

    84

                        << state << "." << endl;

    85

                    throw runtime_error(err.str());

    86

                }

    87

                break;

    88

    89

            case FirstNumber:

    90

                if (i >= size) {

    91

                    ret.push_back(firstNum);

    92

                    state = Finished;

    93

                } else if (data[i] == '-') {

    94

                    i++;

    95

                    state = Range;

    96

                } else if (data[i] == ',') {

    97

                    i++;

    98

                    ret.push_back(firstNum);

    99

                    state = SectionStart;

   100

                } else {

   101

                    stringstream err;

   102

                    err << "Invalid character " << data[i]

   103

                        << " at position " << i << "in state "

   104

                        << state << "." << endl;

   105

                    throw runtime_error(err.str());

   106

                }

   107

                break;

   108

   109

            case Range:

   110

                if (i >= size) {

   111

                    int max = maximum();

   112

                    // only increasing ranges if second number omitted

   113

                    if (max >= 0 && firstNum <= (unsigned int) max) {

   114

                        List r = range(firstNum, max);

   115

                        ret.splice(ret.end(), r);

   116

                    }

   117

                    state = Finished;

   118

                } else if (isNumeric(data[i])) {

   119

                    secondNum = parseNumber(data, &i, size);

   120

                    state = SecondNumber;

   121

                } else if (data[i] == ',') {

   122

                    int max = maximum();

   123

                    i++;

   124

                    if (max >= 0) {

   125

                        List r = range(firstNum, max);

   126

                        ret.splice(ret.end(), r);

   127

                    }

   128

                    state = SectionStart;

   129

                } else {

   130

                    stringstream err;

   131

                    err << "Invalid character " << data[i]

   132

                        << " at position " << i << "in state "

   133

                        << state << "." << endl;

   134

                    throw runtime_error(err.str());

   135

                }

   136

                break;

   137

   138

            case SecondNumber:

   139

                if (i >= size) {

   140

                    List r = range(firstNum, secondNum);

   141

                    ret.splice(ret.end(), r);

   142

                    state = Finished;

   143

                } else if (data[i] == ',') {

   144

                    i++;

   145

                    List r = range(firstNum, secondNum);

   146

                    ret.splice(ret.end(), r);

   147

                    state = SectionStart;

   148

                } else {

   149

                    stringstream err;

   150

                    err << "Invalid character " << data[i]

   151

                        << " at position " << i << "in state "

   152

                        << state << "." << endl;

   153

                    throw runtime_error(err.str());

   154

                }

   155

                break;

   156

   157

            default:

   158

                {

   159

                    stringstream err;

   160

                    err << "Invalid state " << state << ".";

   161

                    throw runtime_error(err.str());

   162

                }

   163

        }

   164

    }

   165

   166

    return ret;

   167

}

   168

   169

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

   170

   171

int NumberListParser::maximum()

   172

{

   173

    if (!hasMax) {

   174

        max = getMax();

   175

    }

   176

   177

    return max;

   178

}

   179

   180

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

   181

   182

bool NumberListParser::isNumeric(char c)

   183

{

   184

    return c >= '0' && c <= '9';

   185

}

   186

   187

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

   188

   189

unsigned int NumberListParser::parseNumber(

   190

        const char *data,

   191

        unsigned int *i,

   192

        unsigned int size

   193

        )

   194

{

   195

    unsigned int numSize = 0U, ret;

   196

   197

    while (*i + numSize < size && isNumeric(data[*i + numSize])) {

   198

        numSize++;

   199

    }

   200

   201

    if (numSize) {

   202

        stringstream str;

   203

        str << string(data + *i, numSize);

   204

        str >> ret;

   205

    } else {

   206

        throw runtime_error("EOF");

   207

    }

   208

   209

    *i = *i + numSize;

   210

    return ret;

   211

}

   212

   213

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

   214

   215

NumberListParser::List NumberListParser::range(

   216

        unsigned int i,

   217

        unsigned int j

   218

        )

   219

{

   220

    List ret;

   221

   222

    if (i <= j) {

   223

        for (; i <= j; i++) {

   224

            ret.push_back(i);

   225

        }

   226

    } else {

   227

        for (; j <= i; j++) {

   228

            ret.push_front(j);

   229

        }

   230

    }

   231

   232

    return ret;

   233

}

   234

   235

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