ATDD Scripting: StringParsing (New)

///////////////////////////////
//Begin String Parsing
///////////////////////////////
/* String Parsing functions V3.0 *\
 *
 * float[] parseStringToFloatArray(string &in asString)- parses all floats out of a string. Signs, exponent & decimals supported
 * int[] parseStringToIntArray(string &in asString)    - Parses all integers out of a string. Signs & exponent supported.
 * uint parseStringUInt(string &in asString)           - Fast UINT parser over entire string (Extracts digits)
 *
\* Written by: Apjjm             */

///////////////////////////////
//+ Float Parsing
///////////////////////////////
float[] parseStringToFloatArray(string &in asString)
 {
   float[] output = {};
   int integer = 0;      //Integer part of the number
   float decimal = 0;      //Decimal part of the number
   int exponent = 0;      //Exponent of the number
   bool negativeInteger = false; //Is the integer part negative
   bool negativeExponent = false; //Is the exponent part negative
   double dMul = 1;             //Multiplier for the decimal
   bool readNumber = false;      //Read a number yet or not (stops +. etc returning 0's).

   //Parsing loop
   int state = 0;
   string temp = asString + "!"; //Add an invalid character to end of string
   for(uint i=0; i<temp.length(); i++)
    {
      //Determine properties about this character
      uint8 chr = temp[i];
      int  digit = _parseDigit(chr);
      int sign     = _parseSign(chr);
      bool isExponent = _parseHasExponent(chr);
      bool isDecimalP = _parseHasDecimalPoint(chr);
      bool isWhitesp  = _parseHasWhitespace(chr);
      bool isDigit    = digit != -1;

      switch(state)
      {
         case 0: //Initial state
            {
               if(sign != 0)      { negativeInteger=(sign<0); integer =0; state=1; } //Read +/-XX
               else if(isDigit)   { integer = digit; state = 1; readNumber=true; } //Read N
               else if(isDecimalP){ state = 2; } //Read .XX -> Assume 0.XX
               break;
            }
         case 1: //Read the number part of the float
            {
               if(isDigit)         { integer = (integer * 10) + digit; readNumber=true; } //Read NNXX
               else if(isDecimalP) { state = 2; }            //Read NN.XX
               else if(isExponent && readNumber) { state = 3; } //Read NNeXX -> assume NN.0eXX
               else if(readNumber) { state = -1; }            //Finished reading the number.
               else                { state = 0;  }
               break;
            }
         case 2: //Read the decimal part of the float
            {
               if(isDigit)         { decimal += float(digit) * dMul; dMul *= 0.1; readNumber=true; }
               else if(isExponent && readNumber) { state = 3; }
               else if(readNumber) { state = -1; }
               else                { state = 0;  }
               break;
            }
         case 3: //Ignore a single whitespace char after the exponent.
            {
               if(isDigit)         { exponent = digit; state = 5; } //Read NNeXX
               else if(isWhitesp)  { state = 4; } //Read NNe XX
               else if(sign != 0)  { negativeExponent=(sign<0); state = 5; }
               else                { state = -1; }
               break;
            }
         case 4: //Read a +/- Sign or a digit for the exponent
            {
               if(isDigit)         { exponent = digit; state = 5; } //Read NNe NX
               else if(sign != 0)  { negativeExponent=(sign<0); state = 5; } //Read NNe +/-XX
               else                { state = -1; }
               break;
            }
         case 5: //Reading the exponent
            {
               if(isDigit) { exponent = (exponent * 10) + digit; } //Read NNe NX
               else        { state = -1; }
               break;
            }
      }
      //At the end of a number?
      if(state < 0)
       {
          //Construct the number & add it to the output array
         int index = output.length(); output.resize(index+1);
         output[index] = _parseFloatHelper(integer,decimal,exponent,negativeInteger,negativeExponent);
         //Reset parsing state
         state = 0; integer=0; decimal=0; exponent=0; dMul =1;
         negativeInteger=false; negativeExponent=false; readNumber=false;
         //This terminating char was possibly the start of next number. Start from this character
         if(isDecimalP || sign!=0) i-=1;
       }
   }

   return output;
 }

float _parseFloatHelper(int integer, float decimal, int exponent, bool negI, bool negE)
 {
   //Calculate the number with no exponent applied
   float x = float(integer) + decimal * 0.1f;
   //Apply 10^E
   float mul = negE?0.1f:10.0f;
   for(int i=0; i<exponent; i++)
      x = x*mul;
   //Apply sign of the number
   return negI?-x:x;
 }
///////////////////////////////
//- Float Parsing
///////////////////////////////
///////////////////////////////
//+ Integer Parsing
///////////////////////////////
int[] parseStringToIntArray(string &in asString)
 {
   int[] output = {};
   int integer = 0;      //Integer part of the number
   int exponent = 0;      //Exponent of the number
   bool negativeInteger = false; //Is the integer part negative
   bool negativeExponent = false; //Is the exponent part negative
   bool readNumber = false;      //Read a number yet or not (stops +e etc returning 0's).

   //Parsing loop
   int state = 0;
   string temp = asString + "!"; //Add an invalid character to end of string
   for(uint i=0; i<temp.length(); i++)
    {
      //Determine properties about this character
      uint8 chr = temp[i];
      int  digit = _parseDigit(chr);
      int sign     = _parseSign(chr);
      bool isExponent = _parseHasExponent(chr);
      bool isWhitesp  = _parseHasWhitespace(chr);
      bool isDigit    = digit!=-1;

      switch(state)
      {
         case 0: //Initial state
            {
               if(sign != 0)      { negativeInteger=(sign<0); integer =0; state=1; } //Read +/-XX
               else if(isDigit)   { integer = digit; state = 1; readNumber=true; } //Read N
               break;
            }
         case 1: //Read the number part
            {
               if(isDigit)           { integer = (integer * 10) + digit; readNumber=true; } //Read NNXX
               else if(isExponent && readNumber) { state = 3; } //Read NNeXX -> assume NN.0eXX
               else if(readNumber)   { state = -1; }            //Finished reading the number.
               else                  { state = 0;  }
               break;
            }
         case 3: //Ignore a single whitespace char after the exponent.
            {
               if(isDigit)         { exponent = digit; state = 5; } //Read NNeXX
               else if(isWhitesp)  { state = 4; } //Read NNe XX
               else if(sign != 0)  { negativeExponent=(sign<0); state = 5; }
               else                { state = -1; }
               break;
            }
         case 4: //Read a +/- Sign or a digit for the exponent
            {
               if(isDigit)         { exponent = digit; state = 5; } //Read NNe NX
               else if(sign != 0)  { negativeExponent=(sign<0); state = 5; } //Read NNe +/-XX
               else                { state = -1; }
               break;
            }
         case 5: //Reading the exponent
            {
               if(isDigit)  { exponent = (exponent * 10) + digit; } //Read NNe NX
               else         { state = -1; }
               break;
            }
      }
      //At the end of a number?
      if(state < 0)
       {
          //Construct the number & add it to the output array
         int index = output.length(); output.resize(index+1);
         output[index] = _parseIntHelper(integer,exponent,negativeInteger,negativeExponent);
         //Reset parsing state
         state = 0; integer=0; exponent=0; readNumber=false;
         negativeInteger=false; negativeExponent=false;
         //This terminating char was possibly the start of next number. Start from this character
         if(sign!=0) i-=1;
       }
   }

   return output;
 }

int _parseIntHelper(int integer, int exponent, bool negI, bool negE)
 {
   //Calculate the number with no exponent applied
   int x = integer;
   //Apply 10^E
   for(int i=0; i<exponent; i++)
      x = negE?(x/10):(x*10);
   //Apply sign of the number
   return negI?-x:x;
 }
///////////////////////////////
//- Integer Parsing
///////////////////////////////
///////////////////////////////
//+ Fast UINT Parse
///////////////////////////////
uint parseStringUInt(string &in asString) {
    uint output = 0;
    for(uint i=0; i<asString.length(); i++) {
      int digit = _parseDigit(asString[i]);
      output = (digit != -1)?(10*output+digit):(output); }
    return output;
}
///////////////////////////////
//-
///////////////////////////////

//+ Parsing Helper Functions
int _parseDigit(uint8 digit) {
    int d = digit-48; //48 is ASCII code for 0
    return ((d >= 0)&&(d<=9)) ? d : -1;
}
int _parseSign(uint8 chr) {
 if (chr == 45) return -1;
 else if(chr == 43) return 1;
 else return 0;
}
bool _parseHasExponent(uint8 chr) { return (chr == 69) || (chr == 101); }
bool _parseHasDecimalPoint(uint8 chr) { return (chr==46); }
bool _parseHasWhitespace(uint8 chr) { return (chr == 43)||(chr == 32); }
//-

///////////////////////////////
//End String Parsing
///////////////////////////////