//---------------------------------------------------------------
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;
}
