Variant f_range(CVarRef low, CVarRef high, CVarRef step /* = 1 */) { bool is_step_double = false; double dstep = 1.0; if (step.isDouble()) { dstep = step.toDouble(); is_step_double = true; } else if (step.isString()) { int64_t sn; double sd; DataType stype = step.toString()->isNumericWithVal(sn, sd, 0); if (stype == KindOfDouble) { is_step_double = true; dstep = sd; } else if (stype == KindOfInt64) { dstep = (double)sn; } else { dstep = step.toDouble(); } } else { dstep = step.toDouble(); } /* We only want positive step values. */ if (dstep < 0.0) dstep *= -1; if (low.isString() && high.isString()) { String slow = low.toString(); String shigh = high.toString(); if (slow.size() >= 1 && shigh.size() >=1) { int64_t n1, n2; double d1, d2; DataType type1 = slow->isNumericWithVal(n1, d1, 0); DataType type2 = shigh->isNumericWithVal(n2, d2, 0); if (type1 == KindOfDouble || type2 == KindOfDouble || is_step_double) { if (type1 != KindOfDouble) d1 = slow.toDouble(); if (type2 != KindOfDouble) d2 = shigh.toDouble(); return ArrayUtil::Range(d1, d2, dstep); } int64_t lstep = (int64_t) dstep; if (type1 == KindOfInt64 || type2 == KindOfInt64) { if (type1 != KindOfInt64) n1 = slow.toInt64(); if (type2 != KindOfInt64) n2 = shigh.toInt64(); return ArrayUtil::Range((double)n1, (double)n2, lstep); } return ArrayUtil::Range((unsigned char)slow.charAt(0), (unsigned char)shigh.charAt(0), lstep); } } if (low.is(KindOfDouble) || high.is(KindOfDouble) || is_step_double) { return ArrayUtil::Range(low.toDouble(), high.toDouble(), dstep); } int64_t lstep = (int64_t) dstep; return ArrayUtil::Range(low.toDouble(), high.toDouble(), lstep); }
double parseToDoubleForNumberType(const String& string, double fallbackValue) { // See HTML5 2.5.4.3 `Real numbers.' // String::toDouble() accepts leading + and whitespace characters, which are not valid here. UChar firstCharacter = string[0]; if (firstCharacter != '-' && firstCharacter != '.' && !isASCIIDigit(firstCharacter)) return fallbackValue; bool valid = false; double value = string.toDouble(&valid); if (!valid) return fallbackValue; // NaN and infinity are considered valid by String::toDouble, but not valid here. if (!std::isfinite(value)) return fallbackValue; // Numbers are considered finite IEEE 754 single-precision floating point values. // See HTML5 2.5.4.3 `Real numbers.' if (-std::numeric_limits<float>::max() > value || value > std::numeric_limits<float>::max()) return fallbackValue; // The following expression converts -0 to +0. return value ? value : 0; }
TextureMapperFPSCounter::TextureMapperFPSCounter() : m_isShowingFPS(false) , m_fpsInterval(0) , m_fpsTimestamp(0) , m_lastFPS(0) , m_frameCount(0) { String showFPSEnvironment = getenv("WEBKIT_SHOW_FPS"); bool ok = false; m_fpsInterval = showFPSEnvironment.toDouble(&ok); if (ok && m_fpsInterval) { m_isShowingFPS = true; m_fpsTimestamp = WTF::currentTime(); } }
SMILTime SVGSMILElement::parseOffsetValue(const String& data) { bool ok; double result = 0; String parse = data.stripWhiteSpace(); if (parse.endsWith('h')) result = parse.left(parse.length() - 1).toDouble(&ok) * 60 * 60; else if (parse.endsWith("min")) result = parse.left(parse.length() - 3).toDouble(&ok) * 60; else if (parse.endsWith("ms")) result = parse.left(parse.length() - 2).toDouble(&ok) / 1000; else if (parse.endsWith('s')) result = parse.left(parse.length() - 1).toDouble(&ok); else result = parse.toDouble(&ok); if (!ok || !SMILTime(result).isFinite()) return SMILTime::unresolved(); return result; }
bool MediaFragmentURIParser::parseNPTTime(const LChar* timeString, unsigned length, unsigned& offset, MediaTime& time) { enum Mode { minutes, hours }; Mode mode = minutes; if (offset >= length || !isASCIIDigit(timeString[offset])) return false; // http://www.w3.org/2008/WebVideo/Fragments/WD-media-fragments-spec/#npttimedef // Normal Play Time can either be specified as seconds, with an optional // fractional part to indicate miliseconds, or as colon-separated hours, // minutes and seconds (again with an optional fraction). Minutes and // seconds must be specified as exactly two digits, hours and fractional // seconds can be any number of digits. The hours, minutes and seconds // specification for NPT is a convenience only, it does not signal frame // accuracy. The specification of the "npt:" identifier is optional since // NPT is the default time scheme. This specification builds on the RTSP // specification of NPT RFC 2326. // // ; defined in RFC 2326 // npt-sec = 1*DIGIT [ "." *DIGIT ] ; definitions taken // npt-hhmmss = npt-hh ":" npt-mm ":" npt-ss [ "." *DIGIT] ; from RFC 2326 // npt-mmss = npt-mm ":" npt-ss [ "." *DIGIT] // npt-hh = 1*DIGIT ; any positive number // npt-mm = 2DIGIT ; 0-59 // npt-ss = 2DIGIT ; 0-59 String digits1 = collectDigits(timeString, length, offset); int value1 = digits1.toInt(); if (offset >= length || timeString[offset] == ',') { time = MediaTime::createWithDouble(value1); return true; } MediaTime fraction; if (timeString[offset] == '.') { if (offset == length) return true; String digits = collectFraction(timeString, length, offset); fraction = MediaTime::createWithDouble(digits.toDouble()); time = MediaTime::createWithDouble(value1) + fraction; return true; } if (digits1.length() < 2) return false; if (digits1.length() > 2) mode = hours; // Collect the next sequence of 0-9 after ':' if (offset >= length || timeString[offset++] != ':') return false; if (offset >= length || !isASCIIDigit(timeString[(offset)])) return false; String digits2 = collectDigits(timeString, length, offset); int value2 = digits2.toInt(); if (digits2.length() != 2) return false; // Detect whether this timestamp includes hours. int value3; if (mode == hours || (offset < length && timeString[offset] == ':')) { if (offset >= length || timeString[offset++] != ':') return false; if (offset >= length || !isASCIIDigit(timeString[offset])) return false; String digits3 = collectDigits(timeString, length, offset); if (digits3.length() != 2) return false; value3 = digits3.toInt(); } else { value3 = value2; value2 = value1; value1 = 0; } if (offset < length && timeString[offset] == '.') fraction = MediaTime::createWithDouble(collectFraction(timeString, length, offset).toDouble()); time = MediaTime::createWithDouble((value1 * secondsPerHour) + (value2 * secondsPerMinute) + value3) + fraction; return true; }