//--------------------------------------------------------------- void StreamWriter::appendValues ( unsigned int number, unsigned int number2 ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); appendNumber ( number ); appendChar ( ' ' ); appendNumber ( number2 ); mOpenTags.back().mHasText = true; }
String LocaleWin::formatDate(const Vector<DateFormatToken>& tokens, int baseYear, int year, int month, int day) { ensureShortMonthLabels(); ensureMonthLabels(); StringBuilder buffer; for (unsigned i = 0; i < tokens.size(); ++i) { switch (tokens[i].type) { case DateFormatToken::Literal: buffer.append(tokens[i].data); break; case DateFormatToken::Day1: appendNumber(day, buffer); break; case DateFormatToken::Day2: appendTwoDigitsNumber(day, buffer); break; case DateFormatToken::Month1: appendNumber(month + 1, buffer); break; case DateFormatToken::Month2: appendTwoDigitsNumber(month + 1, buffer); break; case DateFormatToken::Month3: if (0 <= month && month < static_cast<int>(m_shortMonthLabels.size())) buffer.append(m_shortMonthLabels[month]); else appendNumber(month + 1, buffer); break; case DateFormatToken::Month4: if (0 <= month && month < static_cast<int>(m_monthLabels.size())) buffer.append(m_monthLabels[month]); else appendNumber(month + 1, buffer); break; case DateFormatToken::Year1: { if (baseYear - 4 <= year && year <= baseYear + 5) appendNumber(year % 10, buffer); else appendFourDigitsNumber(year, buffer); break; } case DateFormatToken::Year2: { if (baseYear - 49 <= year && year <= baseYear + 50) appendTwoDigitsNumber(year % 100, buffer); else appendFourDigitsNumber(year, buffer); break; } case DateFormatToken::Year4: appendFourDigitsNumber(year, buffer); break; } } return buffer.toString(); }
//--------------------------------------------------------------- void StreamWriter::appendValues ( long long number1, long long number2 ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); appendNumber ( number1 ); appendChar ( ' ' ); appendNumber ( number2 ); mOpenTags.back().mHasText = true; }
//--------------------------------------------------------------- void StreamWriter::appendValues ( const float number1, const float number2, const float number3 ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); appendNumber ( number1 ); appendChar ( ' ' ); appendNumber ( number2 ); appendChar ( ' ' ); appendNumber ( number3 ); mOpenTags.back().mHasText = true; }
//--------------------------------------------------------------- void StreamWriter::appendValues( const Color& val ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); appendNumber ( val.getRed() ); appendChar ( ' ' ); appendNumber ( val.getGreen() ); appendChar ( ' ' ); appendNumber ( val.getBlue() ); appendChar ( ' ' ); appendNumber ( val.getAlpha() ); mOpenTags.back().mHasText = true; }
//--------------------------------------------------------------- void StreamWriter::appendValues ( const double number ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); appendNumber ( number ); mOpenTags.back().mHasText = true; }
//--------------------------------------------------------------- void StreamWriter::appendAttribute ( const String &name, const int val ) { COLLADABU_ASSERT ( !mOpenTags.back().mHasContents ); appendChar ( ' ' ); appendNCNameString ( name ); appendChar ( '=' ); appendChar ( '\"' ); appendNumber ( val ); appendChar ( '\"' ); }
//--------------------------------------------------------------- void StreamWriter::appendValues ( const double values[], const size_t length ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); for ( size_t i=0; i<length; ++i ) { appendNumber ( values[i] ); appendChar ( ' ' ); } mOpenTags.back().mHasText = true; }
//--------------------------------------------------------------- void StreamWriter::appendValues ( const std::vector<unsigned long> &values ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); std::vector<unsigned long>::const_iterator it = values.begin(); for ( ; it!=values.end(); ++it ) { appendNumber ( *it ); appendChar ( ' ' ); } mOpenTags.back().mHasText = true; }
String Color::serialized() const { if (!hasAlpha()) { StringBuilder builder; builder.reserveCapacity(7); builder.append('#'); appendByteAsHex(red(), builder, Lowercase); appendByteAsHex(green(), builder, Lowercase); appendByteAsHex(blue(), builder, Lowercase); return builder.toString(); } Vector<LChar> result; result.reserveInitialCapacity(28); const char commaSpace[] = ", "; const char rgbaParen[] = "rgba("; result.append(rgbaParen, 5); appendNumber(result, red()); result.append(commaSpace, 2); appendNumber(result, green()); result.append(commaSpace, 2); appendNumber(result, blue()); result.append(commaSpace, 2); if (!alpha()) result.append('0'); else { NumberToLStringBuffer buffer; unsigned length = DecimalNumber(alpha() / 255.0).toStringDecimal(buffer, WTF::NumberToStringBufferLength); result.append(buffer, length); } result.append(')'); return String::adopt(result); }
bool SizesCalcParser::calcToReversePolishNotation(CSSParserTokenIterator start, CSSParserTokenIterator end) { // This method implements the shunting yard algorithm, to turn the calc syntax into a reverse polish notation. // http://en.wikipedia.org/wiki/Shunting-yard_algorithm Vector<CSSParserToken> stack; for (CSSParserTokenIterator it = start; it != end; ++it) { CSSParserTokenType type = it->type(); switch (type) { case NumberToken: appendNumber(*it); break; case DimensionToken: if (!CSSPrimitiveValue::isLength(it->unitType()) || !appendLength(*it)) return false; break; case DelimiterToken: if (!handleOperator(stack, *it)) return false; break; case FunctionToken: if (it->value() != "calc") return false; // "calc(" is the same as "(" case LeftParenthesisToken: // If the token is a left parenthesis, then push it onto the stack. stack.append(*it); break; case RightParenthesisToken: // If the token is a right parenthesis: // Until the token at the top of the stack is a left parenthesis, pop operators off the stack onto the output queue. while (!stack.isEmpty() && stack.last().type() != LeftParenthesisToken && stack.last().type() != FunctionToken) { appendOperator(stack.last()); stack.removeLast(); } // If the stack runs out without finding a left parenthesis, then there are mismatched parentheses. if (stack.isEmpty()) return false; // Pop the left parenthesis from the stack, but not onto the output queue. stack.removeLast(); break; case CommentToken: case WhitespaceToken: case EOFToken: break; case HashToken: case UrlToken: case BadUrlToken: case PercentageToken: case UnicodeRangeToken: case IdentToken: case CommaToken: case ColonToken: case SemicolonToken: case LeftBraceToken: case LeftBracketToken: case RightBraceToken: case RightBracketToken: case StringToken: case BadStringToken: return false; } } // When there are no more tokens to read: // While there are still operator tokens in the stack: while (!stack.isEmpty()) { // If the operator token on the top of the stack is a parenthesis, then there are mismatched parentheses. CSSParserTokenType type = stack.last().type(); if (type == LeftParenthesisToken || type == FunctionToken) return false; // Pop the operator onto the output queue. appendOperator(stack.last()); stack.removeLast(); } return true; }
void DateTimeStringBuilder::visitField(DateTimeFormat::FieldType fieldType, int numberOfPatternCharacters) { switch (fieldType) { case DateTimeFormat::FieldTypeYear: // Always use padding width of 4 so it matches DateTimeEditElement. appendNumber(m_date.fullYear(), 4); return; case DateTimeFormat::FieldTypeMonth: if (numberOfPatternCharacters == 3) { m_builder.append(m_localizer.shortMonthLabels()[m_date.month()]); } else if (numberOfPatternCharacters == 4) { m_builder.append(m_localizer.monthLabels()[m_date.month()]); } else { // Always use padding width of 2 so it matches DateTimeEditElement. appendNumber(m_date.month() + 1, 2); } return; case DateTimeFormat::FieldTypeMonthStandAlone: if (numberOfPatternCharacters == 3) { m_builder.append(m_localizer.shortStandAloneMonthLabels()[m_date.month()]); } else if (numberOfPatternCharacters == 4) { m_builder.append(m_localizer.standAloneMonthLabels()[m_date.month()]); } else { // Always use padding width of 2 so it matches DateTimeEditElement. appendNumber(m_date.month() + 1, 2); } return; case DateTimeFormat::FieldTypeDayOfMonth: // Always use padding width of 2 so it matches DateTimeEditElement. appendNumber(m_date.monthDay(), 2); return; case DateTimeFormat::FieldTypeWeekOfYear: // Always use padding width of 2 so it matches DateTimeEditElement. appendNumber(m_date.week(), 2); return; case DateTimeFormat::FieldTypePeriod: m_builder.append(m_localizer.timeAMPMLabels()[(m_date.hour() >= 12 ? 1 : 0)]); return; case DateTimeFormat::FieldTypeHour12: { int hour12 = m_date.hour() % 12; if (!hour12) hour12 = 12; appendNumber(hour12, numberOfPatternCharacters); return; } case DateTimeFormat::FieldTypeHour23: appendNumber(m_date.hour(), numberOfPatternCharacters); return; case DateTimeFormat::FieldTypeHour11: appendNumber(m_date.hour() % 12, numberOfPatternCharacters); return; case DateTimeFormat::FieldTypeHour24: { int hour24 = m_date.hour(); if (!hour24) hour24 = 24; appendNumber(hour24, numberOfPatternCharacters); return; } case DateTimeFormat::FieldTypeMinute: appendNumber(m_date.minute(), numberOfPatternCharacters); return; case DateTimeFormat::FieldTypeSecond: if (!m_date.millisecond()) { appendNumber(m_date.second(), numberOfPatternCharacters); } else { double second = m_date.second() + m_date.millisecond() / 1000.0; String zeroPaddedSecondString = zeroPadString(String::format("%.03f", second), numberOfPatternCharacters + 4); m_builder.append(m_localizer.convertToLocalizedNumber(zeroPaddedSecondString)); } return; default: return; } }
//--------------------------------------------------------------- void StreamWriter::appendValues ( const double matrix[4][4] ) { prepareToAddContents(); if ( mOpenTags.back().mHasText ) appendChar ( ' ' ); appendNumber ( matrix[0][0] ); appendChar ( ' ' ); appendNumber ( matrix[0][1] ); appendChar ( ' ' ); appendNumber ( matrix[0][2] ); appendChar ( ' ' ); appendNumber ( matrix[0][3] ); appendChar ( ' ' ); appendNumber ( matrix[1][0] ); appendChar ( ' ' ); appendNumber ( matrix[1][1] ); appendChar ( ' ' ); appendNumber ( matrix[1][2] ); appendChar ( ' ' ); appendNumber ( matrix[1][3] ); appendChar ( ' ' ); appendNumber ( matrix[2][0] ); appendChar ( ' ' ); appendNumber ( matrix[2][1] ); appendChar ( ' ' ); appendNumber ( matrix[2][2] ); appendChar ( ' ' ); appendNumber ( matrix[2][3] ); appendChar ( ' ' ); appendNumber ( matrix[3][0] ); appendChar ( ' ' ); appendNumber ( matrix[3][1] ); appendChar ( ' ' ); appendNumber ( matrix[3][2] ); appendChar ( ' ' ); appendNumber ( matrix[3][3] ); mOpenTags.back().mHasText = true; }
ALWAYS_INLINE String CSSPrimitiveValue::formatNumberForcustomCSSText() const { switch (m_primitiveUnitType) { case CSS_UNKNOWN: return String(); case CSS_NUMBER: case CSS_PARSER_INTEGER: return formatNumberValue(""); case CSS_PERCENTAGE: return formatNumberValue("%"); case CSS_EMS: return formatNumberValue("em"); case CSS_EXS: return formatNumberValue("ex"); case CSS_REMS: return formatNumberValue("rem"); case CSS_CHS: return formatNumberValue("ch"); case CSS_PX: return formatNumberValue("px"); case CSS_CM: return formatNumberValue("cm"); #if ENABLE(CSS_IMAGE_RESOLUTION) || ENABLE(RESOLUTION_MEDIA_QUERY) case CSS_DPPX: return formatNumberValue("dppx"); case CSS_DPI: return formatNumberValue("dpi"); case CSS_DPCM: return formatNumberValue("dpcm"); #endif case CSS_MM: return formatNumberValue("mm"); case CSS_IN: return formatNumberValue("in"); case CSS_PT: return formatNumberValue("pt"); case CSS_PC: return formatNumberValue("pc"); case CSS_DEG: return formatNumberValue("deg"); case CSS_RAD: return formatNumberValue("rad"); case CSS_GRAD: return formatNumberValue("grad"); case CSS_MS: return formatNumberValue("ms"); case CSS_S: return formatNumberValue("s"); case CSS_HZ: return formatNumberValue("hz"); case CSS_KHZ: return formatNumberValue("khz"); case CSS_TURN: return formatNumberValue("turn"); case CSS_FR: return formatNumberValue("fr"); case CSS_DIMENSION: // FIXME: We currently don't handle CSS_DIMENSION properly as we don't store // the actual dimension, just the numeric value as a string. case CSS_STRING: return quoteCSSStringIfNeeded(m_value.string); case CSS_URI: return "url(" + quoteCSSURLIfNeeded(m_value.string) + ')'; case CSS_VALUE_ID: return valueName(m_value.valueID); case CSS_PROPERTY_ID: return propertyName(m_value.propertyID); case CSS_ATTR: { StringBuilder result; result.reserveCapacity(6 + m_value.string->length()); result.appendLiteral("attr("); result.append(m_value.string); result.append(')'); return result.toString(); } case CSS_COUNTER_NAME: return "counter(" + String(m_value.string) + ')'; case CSS_COUNTER: { StringBuilder result; String separator = m_value.counter->separator(); if (separator.isEmpty()) result.appendLiteral("counter("); else result.appendLiteral("counters("); result.append(m_value.counter->identifier()); if (!separator.isEmpty()) { result.appendLiteral(", "); result.append(quoteCSSStringIfNeeded(separator)); } String listStyle = m_value.counter->listStyle(); if (!listStyle.isEmpty()) { result.appendLiteral(", "); result.append(listStyle); } result.append(')'); return result.toString(); } case CSS_RECT: return getRectValue()->cssText(); case CSS_QUAD: return getQuadValue()->cssText(); case CSS_RGBCOLOR: case CSS_PARSER_HEXCOLOR: { RGBA32 rgbColor = m_value.rgbcolor; if (m_primitiveUnitType == CSS_PARSER_HEXCOLOR) Color::parseHexColor(m_value.string, rgbColor); Color color(rgbColor); Vector<LChar> result; result.reserveInitialCapacity(32); bool colorHasAlpha = color.hasAlpha(); if (colorHasAlpha) result.append("rgba(", 5); else result.append("rgb(", 4); appendNumber(result, static_cast<unsigned char>(color.red())); result.append(", ", 2); appendNumber(result, static_cast<unsigned char>(color.green())); result.append(", ", 2); appendNumber(result, static_cast<unsigned char>(color.blue())); if (colorHasAlpha) { result.append(", ", 2); NumberToStringBuffer buffer; const char* alphaString = numberToFixedPrecisionString(color.alpha() / 255.0f, 6, buffer, true); result.append(alphaString, strlen(alphaString)); } result.append(')'); return String::adopt(result); } case CSS_PAIR: return getPairValue()->cssText(); #if ENABLE(DASHBOARD_SUPPORT) case CSS_DASHBOARD_REGION: { StringBuilder result; for (DashboardRegion* region = getDashboardRegionValue(); region; region = region->m_next.get()) { if (!result.isEmpty()) result.append(' '); result.appendLiteral("dashboard-region("); result.append(region->m_label); if (region->m_isCircle) result.appendLiteral(" circle"); else if (region->m_isRectangle) result.appendLiteral(" rectangle"); else break; if (region->top()->m_primitiveUnitType == CSS_VALUE_ID && region->top()->getValueID() == CSSValueInvalid) { ASSERT(region->right()->m_primitiveUnitType == CSS_VALUE_ID); ASSERT(region->bottom()->m_primitiveUnitType == CSS_VALUE_ID); ASSERT(region->left()->m_primitiveUnitType == CSS_VALUE_ID); ASSERT(region->right()->getValueID() == CSSValueInvalid); ASSERT(region->bottom()->getValueID() == CSSValueInvalid); ASSERT(region->left()->getValueID() == CSSValueInvalid); } else { result.append(' '); result.append(region->top()->cssText()); result.append(' '); result.append(region->right()->cssText()); result.append(' '); result.append(region->bottom()->cssText()); result.append(' '); result.append(region->left()->cssText()); } result.append(')'); } return result.toString(); } #endif case CSS_PARSER_OPERATOR: { char c = static_cast<char>(m_value.parserOperator); return String(&c, 1U); } case CSS_PARSER_IDENTIFIER: return quoteCSSStringIfNeeded(m_value.string); case CSS_CALC: return m_value.calc->cssText(); case CSS_SHAPE: return m_value.shape->cssText(); case CSS_VW: return formatNumberValue("vw"); case CSS_VH: return formatNumberValue("vh"); case CSS_VMIN: return formatNumberValue("vmin"); case CSS_VMAX: return formatNumberValue("vmax"); } return String(); }
std::string ZLStringUtil::numberToString(unsigned int n) { std::string str; appendNumber(str, n); return str; }
bool SizesCalcParser::calcToReversePolishNotation(CSSParserTokenRange range) { // This method implements the shunting yard algorithm, to turn the calc syntax into a reverse polish notation. // http://en.wikipedia.org/wiki/Shunting-yard_algorithm Vector<CSSParserToken> stack; while (!range.atEnd()) { const CSSParserToken& token = range.consume(); switch (token.type()) { case NumberToken: appendNumber(token); break; case DimensionToken: if (!CSSPrimitiveValue::isLength(token.unitType()) || !appendLength(token)) return false; break; case DelimiterToken: if (!handleOperator(stack, token)) return false; break; case FunctionToken: if (!token.valueEqualsIgnoringCase("calc")) return false; // "calc(" is the same as "(" case LeftParenthesisToken: // If the token is a left parenthesis, then push it onto the stack. stack.append(token); break; case RightParenthesisToken: // If the token is a right parenthesis: // Until the token at the top of the stack is a left parenthesis, pop operators off the stack onto the output queue. while (!stack.isEmpty() && stack.last().type() != LeftParenthesisToken && stack.last().type() != FunctionToken) { appendOperator(stack.last()); stack.removeLast(); } // If the stack runs out without finding a left parenthesis, then there are mismatched parentheses. if (stack.isEmpty()) return false; // Pop the left parenthesis from the stack, but not onto the output queue. stack.removeLast(); break; case WhitespaceToken: case EOFToken: break; case CommentToken: ASSERT_NOT_REACHED(); case CDOToken: case CDCToken: case AtKeywordToken: case HashToken: case UrlToken: case BadUrlToken: case PercentageToken: case IncludeMatchToken: case DashMatchToken: case PrefixMatchToken: case SuffixMatchToken: case SubstringMatchToken: case ColumnToken: case UnicodeRangeToken: case IdentToken: case CommaToken: case ColonToken: case SemicolonToken: case LeftBraceToken: case LeftBracketToken: case RightBraceToken: case RightBracketToken: case StringToken: case BadStringToken: return false; } } // When there are no more tokens to read: // While there are still operator tokens in the stack: while (!stack.isEmpty()) { // If the operator token on the top of the stack is a parenthesis, then there are mismatched parentheses. CSSParserTokenType type = stack.last().type(); if (type == LeftParenthesisToken || type == FunctionToken) return false; // Pop the operator onto the output queue. appendOperator(stack.last()); stack.removeLast(); } return true; }