tool/NumberListParser.cpp
changeset 2010 87de63b19e4c
parent 1828 651e9cfb244b
child 2012 ee4782738e30
equal deleted inserted replaced
1964:9327c261056f 2010:87de63b19e4c
    48 {
    48 {
    49 }
    49 }
    50 
    50 
    51 /*****************************************************************************/
    51 /*****************************************************************************/
    52 
    52 
    53 NumberListParser::NumberList NumberListParser::parse(const char *data)
    53 NumberListParser::List NumberListParser::parse(const char *data)
    54 {
    54 {
    55     NumberList ret;
    55     List ret;
    56     unsigned int i = 0, size = strlen(data), firstNum = 0U, secondNum = 0U;
    56     unsigned int i = 0, size = strlen(data), firstNum = 0U, secondNum = 0U;
    57     typedef enum {
    57     typedef enum {
    58         SectionStart,
    58         SectionStart,
    59         FirstNumber,
    59         FirstNumber,
    60         Range,
    60         Range,
   106                 }
   106                 }
   107                 break;
   107                 break;
   108 
   108 
   109             case Range:
   109             case Range:
   110                 if (i >= size) {
   110                 if (i >= size) {
   111                     secondNum = maximum();
   111                     int max = maximum();
   112                     NumberList r = range(firstNum, secondNum);
   112                     if (max >= 0) {
   113                     ret.splice(ret.end(), r);
   113                         List r = range(firstNum, max);
       
   114                         ret.splice(ret.end(), r);
       
   115                     }
   114                     state = Finished;
   116                     state = Finished;
   115                 } else if (isNumeric(data[i])) {
   117                 } else if (isNumeric(data[i])) {
   116                     secondNum = parseNumber(data, &i, size);
   118                     secondNum = parseNumber(data, &i, size);
   117                     state = SecondNumber;
   119                     state = SecondNumber;
   118                 } else if (data[i] == ',') {
   120                 } else if (data[i] == ',') {
   119                     i++;
   121                     int max = maximum();
   120                     secondNum = maximum();
   122                     i++;
   121                     NumberList r = range(firstNum, secondNum);
   123                     if (max >= 0) {
       
   124                         List r = range(firstNum, max);
       
   125                         ret.splice(ret.end(), r);
       
   126                     }
       
   127                     state = SectionStart;
       
   128                 } else {
       
   129                     stringstream err;
       
   130                     err << "Invalid character " << data[i]
       
   131                         << " at position " << i << "in state "
       
   132                         << state << "." << endl;
       
   133                     throw runtime_error(err.str());
       
   134                 }
       
   135                 break;
       
   136 
       
   137             case SecondNumber:
       
   138                 if (i >= size) {
       
   139                     List r = range(firstNum, secondNum);
       
   140                     ret.splice(ret.end(), r);
       
   141                     state = Finished;
       
   142                 } else if (data[i] == ',') {
       
   143                     i++;
       
   144                     List r = range(firstNum, secondNum);
   122                     ret.splice(ret.end(), r);
   145                     ret.splice(ret.end(), r);
   123                     state = SectionStart;
   146                     state = SectionStart;
   124                 } else {
   147                 } else {
   125                     stringstream err;
   148                     stringstream err;
   126                     err << "Invalid character " << data[i]
   149                     err << "Invalid character " << data[i]
   128                         << state << "." << endl;
   151                         << state << "." << endl;
   129                     throw runtime_error(err.str());
   152                     throw runtime_error(err.str());
   130                 }
   153                 }
   131                 break;
   154                 break;
   132 
   155 
   133             case SecondNumber:
       
   134                 if (i >= size) {
       
   135                     NumberList r = range(firstNum, secondNum);
       
   136                     ret.splice(ret.end(), r);
       
   137                     state = Finished;
       
   138                 } else if (data[i] == ',') {
       
   139                     i++;
       
   140                     NumberList r = range(firstNum, secondNum);
       
   141                     ret.splice(ret.end(), r);
       
   142                     state = SectionStart;
       
   143                 } else {
       
   144                     stringstream err;
       
   145                     err << "Invalid character " << data[i]
       
   146                         << " at position " << i << "in state "
       
   147                         << state << "." << endl;
       
   148                     throw runtime_error(err.str());
       
   149                 }
       
   150                 break;
       
   151 
       
   152             default:
   156             default:
   153                 {
   157                 {
   154                     stringstream err;
   158                     stringstream err;
   155                     err << "Invalid state " << state << ".";
   159                     err << "Invalid state " << state << ".";
   156                     throw runtime_error(err.str());
   160                     throw runtime_error(err.str());
   161     return ret;
   165     return ret;
   162 }
   166 }
   163 
   167 
   164 /*****************************************************************************/
   168 /*****************************************************************************/
   165 
   169 
   166 unsigned int NumberListParser::maximum()
   170 int NumberListParser::maximum()
   167 {
   171 {
   168     if (!hasMax) {
   172     if (!hasMax) {
   169         max = getMax();
   173         max = getMax();
   170     }
   174     }
   171 
   175 
   205     return ret;
   209     return ret;
   206 }
   210 }
   207 
   211 
   208 /****************************************************************************/
   212 /****************************************************************************/
   209 
   213 
   210 NumberListParser::NumberList NumberListParser::range(
   214 NumberListParser::List NumberListParser::range(
   211         unsigned int i,
   215         unsigned int i,
   212         unsigned int j
   216         unsigned int j
   213         )
   217         )
   214 {
   218 {
   215     NumberList ret;
   219     List ret;
   216 
   220 
   217     if (i <= j) {
   221     if (i <= j) {
   218         for (; i <= j; i++) {
   222         for (; i <= j; i++) {
   219             ret.push_back(i);
   223             ret.push_back(i);
   220         }
   224         }