| /* |
| * Copyright (C) 2019 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer. |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, |
| * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR |
| * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF |
| * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "CSSUnparsedValue.h" |
| |
| #if ENABLE(CSS_TYPED_OM) |
| |
| #include "CSSOMVariableReferenceValue.h" |
| #include "CSSParserToken.h" |
| #include "CSSParserTokenRange.h" |
| #include "ExceptionOr.h" |
| #include <variant> |
| #include <wtf/IsoMallocInlines.h> |
| #include <wtf/text/StringBuilder.h> |
| #include <wtf/text/StringView.h> |
| #include <wtf/text/WTFString.h> |
| |
| namespace WebCore { |
| |
| WTF_MAKE_ISO_ALLOCATED_IMPL(CSSUnparsedValue); |
| |
| Ref<CSSUnparsedValue> CSSUnparsedValue::create(Vector<CSSUnparsedSegment>&& segments) |
| { |
| return adoptRef(*new CSSUnparsedValue(WTFMove(segments))); |
| } |
| |
| Ref<CSSUnparsedValue> CSSUnparsedValue::create(CSSParserTokenRange tokens) |
| { |
| // This function assumes that tokens have the correct syntax. Otherwise asserts would be triggered. |
| StringBuilder builder; |
| Vector<Vector<CSSUnparsedSegment>> segmentStack; |
| segmentStack.append({ }); |
| |
| Vector<std::optional<StringView>> identifiers; |
| |
| while (!tokens.atEnd()) { |
| auto currentToken = tokens.consume(); |
| |
| if (currentToken.type() == FunctionToken || currentToken.type() == LeftParenthesisToken) { |
| if (currentToken.functionId() == CSSValueVar) { |
| if (!builder.isEmpty()) { |
| segmentStack.last().append(builder.toString()); |
| builder.clear(); |
| } |
| tokens.consumeWhitespace(); |
| auto identToken = tokens.consumeIncludingWhitespace(); |
| // Token after whitespace consumption must be variable reference identifier |
| ASSERT(identToken.type() == IdentToken); |
| if (tokens.peek().type() == CommaToken) { |
| // Fallback present |
| identifiers.append(StringView(identToken.value())); |
| segmentStack.append({ }); |
| tokens.consume(); |
| } else if (tokens.peek().type() == RightParenthesisToken) { |
| // No fallback |
| auto variableReference = CSSOMVariableReferenceValue::create(identToken.value().toString()); |
| ASSERT(!variableReference.hasException()); |
| segmentStack.last().append(CSSUnparsedSegment { RefPtr<CSSOMVariableReferenceValue> { variableReference.releaseReturnValue() } }); |
| tokens.consume(); |
| } else |
| ASSERT_NOT_REACHED(); |
| |
| } else { |
| currentToken.serialize(builder); |
| identifiers.append(std::nullopt); |
| } |
| } else if (currentToken.type() == RightParenthesisToken) { |
| ASSERT(segmentStack.size()); |
| if (!builder.isEmpty()) |
| segmentStack.last().append(builder.toString()); |
| builder.clear(); |
| ASSERT(!identifiers.isEmpty()); |
| |
| if (auto topIdentifier = identifiers.takeLast()) { |
| auto variableReference = CSSOMVariableReferenceValue::create(topIdentifier->toString(), CSSUnparsedValue::create(segmentStack.takeLast())); |
| ASSERT(!variableReference.hasException()); |
| segmentStack.last().append(variableReference.releaseReturnValue()); |
| } else |
| currentToken.serialize(builder); |
| } else |
| currentToken.serialize(builder); |
| } |
| ASSERT(segmentStack.size() == 1); |
| if (!builder.isEmpty()) |
| segmentStack.last().append(builder.toString()); |
| |
| return CSSUnparsedValue::create(WTFMove(segmentStack.last())); |
| } |
| |
| CSSUnparsedValue::CSSUnparsedValue(Vector<CSSUnparsedSegment>&& segments) |
| : m_segments(WTFMove(segments)) |
| { |
| } |
| |
| String CSSUnparsedValue::toString() const |
| { |
| StringBuilder builder; |
| serialize(builder); |
| |
| return builder.toString(); |
| } |
| |
| void CSSUnparsedValue::serialize(StringBuilder& builder) const |
| { |
| for (auto& segment : m_segments) { |
| std::visit(WTF::makeVisitor([&] (const String& value) { |
| builder.append(value); |
| }, [&] (const RefPtr<CSSOMVariableReferenceValue>& value) { |
| value->serialize(builder); |
| }), segment); |
| } |
| } |
| |
| ExceptionOr<CSSUnparsedSegment> CSSUnparsedValue::item(size_t index) |
| { |
| if (index >= m_segments.size()) |
| return Exception { RangeError, makeString("Index ", index, " exceeds index range for unparsed segments.") }; |
| return CSSUnparsedSegment { m_segments[index] }; |
| } |
| |
| ExceptionOr<CSSUnparsedSegment> CSSUnparsedValue::setItem(size_t index, CSSUnparsedSegment&& val) |
| { |
| if (index >= m_segments.size()) |
| return Exception { RangeError, makeString("Index ", index, " exceeds index range for unparsed segments.") }; |
| m_segments[index] = WTFMove(val); |
| return CSSUnparsedSegment { m_segments[index] }; |
| } |
| |
| } // namespace WebCore |
| |
| #endif |