Clear unused ports; use arrows for next slaves.
/*****************************************************************************
*
* $Id$
*
* Copyright (C) 2006-2009 Florian Pose, Ingenieurgemeinschaft IgH
*
* This file is part of the IgH EtherCAT Master.
*
* The IgH EtherCAT Master is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version 2, as
* published by the Free Software Foundation.
*
* The IgH EtherCAT Master is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with the IgH EtherCAT Master; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* ---
*
* The license mentioned above concerns the source code only. Using the
* EtherCAT technology and brand is only permitted in compliance with the
* industrial property and similar rights of Beckhoff Automation GmbH.
*
****************************************************************************/
#include <cstring>
#include <sstream>
#include <stdexcept>
using namespace std;
#include "NumberListParser.h"
/*****************************************************************************/
NumberListParser::NumberListParser():
max(0U),
hasMax(false)
{
}
/*****************************************************************************/
NumberListParser::~NumberListParser()
{
}
/*****************************************************************************/
NumberListParser::List NumberListParser::parse(const char *data)
{
List ret;
unsigned int i = 0, size = strlen(data), firstNum = 0U, secondNum = 0U;
typedef enum {
SectionStart,
FirstNumber,
Range,
SecondNumber,
Finished
} State;
State state = SectionStart;
while (state != Finished) {
switch (state) {
case SectionStart:
if (i >= size) {
state = Finished;
} else if (isNumeric(data[i])) {
firstNum = parseNumber(data, &i, size);
state = FirstNumber;
} else if (data[i] == '-') {
firstNum = 0U;
i++;
state = Range;
} else if (data[i] == ',') {
i++;
} else {
stringstream err;
err << "Invalid character " << data[i]
<< " at position " << i << "in state "
<< state << "." << endl;
throw runtime_error(err.str());
}
break;
case FirstNumber:
if (i >= size) {
ret.push_back(firstNum);
state = Finished;
} else if (data[i] == '-') {
i++;
state = Range;
} else if (data[i] == ',') {
i++;
ret.push_back(firstNum);
state = SectionStart;
} else {
stringstream err;
err << "Invalid character " << data[i]
<< " at position " << i << "in state "
<< state << "." << endl;
throw runtime_error(err.str());
}
break;
case Range:
if (i >= size) {
int max = maximum();
// only increasing ranges if second number omitted
if (max >= 0 && firstNum <= (unsigned int) max) {
List r = range(firstNum, max);
ret.splice(ret.end(), r);
}
state = Finished;
} else if (isNumeric(data[i])) {
secondNum = parseNumber(data, &i, size);
state = SecondNumber;
} else if (data[i] == ',') {
int max = maximum();
i++;
if (max >= 0) {
List r = range(firstNum, max);
ret.splice(ret.end(), r);
}
state = SectionStart;
} else {
stringstream err;
err << "Invalid character " << data[i]
<< " at position " << i << "in state "
<< state << "." << endl;
throw runtime_error(err.str());
}
break;
case SecondNumber:
if (i >= size) {
List r = range(firstNum, secondNum);
ret.splice(ret.end(), r);
state = Finished;
} else if (data[i] == ',') {
i++;
List r = range(firstNum, secondNum);
ret.splice(ret.end(), r);
state = SectionStart;
} else {
stringstream err;
err << "Invalid character " << data[i]
<< " at position " << i << "in state "
<< state << "." << endl;
throw runtime_error(err.str());
}
break;
default:
{
stringstream err;
err << "Invalid state " << state << ".";
throw runtime_error(err.str());
}
}
}
return ret;
}
/*****************************************************************************/
int NumberListParser::maximum()
{
if (!hasMax) {
max = getMax();
}
return max;
}
/*****************************************************************************/
bool NumberListParser::isNumeric(char c)
{
return c >= '0' && c <= '9';
}
/*****************************************************************************/
unsigned int NumberListParser::parseNumber(
const char *data,
unsigned int *i,
unsigned int size
)
{
unsigned int numSize = 0U, ret;
while (*i + numSize < size && isNumeric(data[*i + numSize])) {
numSize++;
}
if (numSize) {
stringstream str;
str << string(data + *i, numSize);
str >> ret;
} else {
throw runtime_error("EOF");
}
*i = *i + numSize;
return ret;
}
/****************************************************************************/
NumberListParser::List NumberListParser::range(
unsigned int i,
unsigned int j
)
{
List ret;
if (i <= j) {
for (; i <= j; i++) {
ret.push_back(i);
}
} else {
for (; j <= i; j++) {
ret.push_front(j);
}
}
return ret;
}
/****************************************************************************/