public static double ParseDouble()

in FixAntenna/NetCore/Message/Format/DoubleFormatter.cs [65:230]
123 lines of code
29 McCabe index (conditional complexity)

		public static double ParseDouble(byte[] str, int offset, int length)
		{
			double number;
			int exponent;
			bool negative;
			double p10;
			int n;
			int numDigits;
			int numDecimals;
			var limit = offset + length;

			//// Skip leading whitespace
			//while (isspace(*p)) p++;

			// Handle optional sign
			negative = false;
			switch (str[offset])
			{
				case (byte)'-':
					negative = true; // Fall through to increment position
					goto case (byte)'+';
				case (byte)'+':
					offset++;
					break;
			}

			number = 0.0;
			exponent = 0;
			numDigits = 0;
			numDecimals = 0;

			byte ch = 0;

			// Process string of digits
			while (offset < limit)
			{
				ch = str[offset];
				if (!(ch >= (byte)'0' && ch <= (byte)'9'))
				{
					break;
				}

				number = number * 10.0 + (ch - '0');
				offset++;
				numDigits++;
			}

			// Process decimal part
			if (offset < limit && ch == (byte)'.')
			{
				offset++;

				while (offset < limit)
				{
					ch = str[offset];
					if (!(ch >= (byte)'0' && ch <= (byte)'9'))
					{
						break;
					}

					number = number * 10.0 + (ch - '0');
					offset++;
					numDigits++;
					numDecimals++;
				}

				exponent -= numDecimals;
			}

			if (numDigits == 0)
			{
				throw new ArgumentException("Not a number");
			}

			// Correct for sign
			if (negative)
			{
				number = -number;
			}

			// Process an exponent string

			if (offset + 1 < limit && (ch == (byte)'e' || ch == (byte)'E'))
			{
				// Handle optional sign
				negative = false;
				ch = str[++offset];
				switch (ch)
				{
					case (byte)'-':
						negative = true; // Fall through to increment pos
						goto case (byte)'+';
					case (byte)'+':
						offset++;
						break;
				}

				// Process string of digits
				n = 0;
				while (offset < limit)
				{
					ch = str[offset];
					if (!(ch >= (byte)'0' && ch <= (byte)'9'))
					{
						break;
					}

					n = n * 10 + (ch - '0');
					offset++;
				}

				if (negative)
				{
					exponent -= n;
				}
				else
				{
					exponent += n;
				}
			}

			if (exponent < DblMinExp || exponent > DblMaxExp)
			{
				throw new ArgumentException("Not a number");
			}

			// Scale the result
			//p10 = 10.;
			p10 = 1;
			n = exponent;
			if (n < 0)
			{
				n = -n;
			}

			while (n > 0)
			{
				//if ((n & 1) != 0) {
				//    if (exponent < 0) {
				//        number /= p10;
				//    } else {
				//        number *= p10;
				//    }
				//}
				//n >>= 1;
				//p10 *= p10;
				n--;
				p10 *= 10.0;
			}

			if (exponent < 0)
			{
				number /= p10;
			}
			else
			{
				number *= p10;
			}

			if (number == HugeVal)
			{
				throw new ArgumentException("Not a number");
			}

			return number;
		}