/* * Copyright (c) 2018-2020, Andreas Kling * 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 HOLDERS AND CONTRIBUTORS "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 OR CONTRIBUTORS 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 #include #include #include #include #include #include #include #define PARSE_ASSERT(x) \ if (!(x)) { \ dbg() << "CSS PARSER ASSERTION FAILED: " << #x; \ dbg() << "At character# " << index << " in CSS: _" << css << "_"; \ ASSERT_NOT_REACHED(); \ } #define PARSE_ERROR() \ do { \ dbg() << "CSS parse error"; \ } while (0) namespace Web { namespace CSS { ParsingContext::ParsingContext() { } ParsingContext::ParsingContext(const Document& document) : m_document(&document) { } bool ParsingContext::in_quirks_mode() const { return m_document ? m_document->in_quirks_mode() : false; } } static CSS::ValueID value_id_for_palette_string(const StringView& string) { if (string == "desktop-background") return CSS::ValueID::VendorSpecificPaletteDesktopBackground; else if (string == "active-window-border1") return CSS::ValueID::VendorSpecificPaletteActiveWindowBorder1; else if (string == "active-window-border2") return CSS::ValueID::VendorSpecificPaletteActiveWindowBorder2; else if (string == "active-window-title") return CSS::ValueID::VendorSpecificPaletteActiveWindowTitle; else if (string == "inactive-window-border1") return CSS::ValueID::VendorSpecificPaletteInactiveWindowBorder1; else if (string == "inactive-window-border2") return CSS::ValueID::VendorSpecificPaletteInactiveWindowBorder2; else if (string == "inactive-window-title") return CSS::ValueID::VendorSpecificPaletteInactiveWindowTitle; else if (string == "moving-window-border1") return CSS::ValueID::VendorSpecificPaletteMovingWindowBorder1; else if (string == "moving-window-border2") return CSS::ValueID::VendorSpecificPaletteMovingWindowBorder2; else if (string == "moving-window-title") return CSS::ValueID::VendorSpecificPaletteMovingWindowTitle; else if (string == "highlight-window-border1") return CSS::ValueID::VendorSpecificPaletteHighlightWindowBorder1; else if (string == "highlight-window-border2") return CSS::ValueID::VendorSpecificPaletteHighlightWindowBorder2; else if (string == "highlight-window-title") return CSS::ValueID::VendorSpecificPaletteHighlightWindowTitle; else if (string == "menu-stripe") return CSS::ValueID::VendorSpecificPaletteMenuStripe; else if (string == "menu-base") return CSS::ValueID::VendorSpecificPaletteMenuBase; else if (string == "menu-base-text") return CSS::ValueID::VendorSpecificPaletteMenuBaseText; else if (string == "menu-selection") return CSS::ValueID::VendorSpecificPaletteMenuSelection; else if (string == "menu-selection-text") return CSS::ValueID::VendorSpecificPaletteMenuSelectionText; else if (string == "window") return CSS::ValueID::VendorSpecificPaletteWindow; else if (string == "window-text") return CSS::ValueID::VendorSpecificPaletteWindowText; else if (string == "button") return CSS::ValueID::VendorSpecificPaletteButton; else if (string == "button-text") return CSS::ValueID::VendorSpecificPaletteButtonText; else if (string == "base") return CSS::ValueID::VendorSpecificPaletteBase; else if (string == "base-text") return CSS::ValueID::VendorSpecificPaletteBaseText; else if (string == "threed-highlight") return CSS::ValueID::VendorSpecificPaletteThreedHighlight; else if (string == "threed-shadow1") return CSS::ValueID::VendorSpecificPaletteThreedShadow1; else if (string == "threed-shadow2") return CSS::ValueID::VendorSpecificPaletteThreedShadow2; else if (string == "hover-highlight") return CSS::ValueID::VendorSpecificPaletteHoverHighlight; else if (string == "selection") return CSS::ValueID::VendorSpecificPaletteSelection; else if (string == "selection-text") return CSS::ValueID::VendorSpecificPaletteSelectionText; else if (string == "inactive-selection") return CSS::ValueID::VendorSpecificPaletteInactiveSelection; else if (string == "inactive-selection-text") return CSS::ValueID::VendorSpecificPaletteInactiveSelectionText; else if (string == "rubber-band-fill") return CSS::ValueID::VendorSpecificPaletteRubberBandFill; else if (string == "rubber-band-border") return CSS::ValueID::VendorSpecificPaletteRubberBandBorder; else if (string == "link") return CSS::ValueID::VendorSpecificPaletteLink; else if (string == "active-link") return CSS::ValueID::VendorSpecificPaletteActiveLink; else if (string == "visited-link") return CSS::ValueID::VendorSpecificPaletteVisitedLink; else if (string == "ruler") return CSS::ValueID::VendorSpecificPaletteRuler; else if (string == "ruler-border") return CSS::ValueID::VendorSpecificPaletteRulerBorder; else if (string == "ruler-active-text") return CSS::ValueID::VendorSpecificPaletteRulerActiveText; else if (string == "ruler-inactive-text") return CSS::ValueID::VendorSpecificPaletteRulerInactiveText; else if (string == "text-cursor") return CSS::ValueID::VendorSpecificPaletteTextCursor; else if (string == "focus-outline") return CSS::ValueID::VendorSpecificPaletteFocusOutline; else if (string == "syntax-comment") return CSS::ValueID::VendorSpecificPaletteSyntaxComment; else if (string == "syntax-number") return CSS::ValueID::VendorSpecificPaletteSyntaxNumber; else if (string == "syntax-string") return CSS::ValueID::VendorSpecificPaletteSyntaxString; else if (string == "syntax-type") return CSS::ValueID::VendorSpecificPaletteSyntaxType; else if (string == "syntax-punctuation") return CSS::ValueID::VendorSpecificPaletteSyntaxPunctuation; else if (string == "syntax-operator") return CSS::ValueID::VendorSpecificPaletteSyntaxOperator; else if (string == "syntax-keyword") return CSS::ValueID::VendorSpecificPaletteSyntaxKeyword; else if (string == "syntax-control-keyword") return CSS::ValueID::VendorSpecificPaletteSyntaxControlKeyword; else if (string == "syntax-identifier") return CSS::ValueID::VendorSpecificPaletteSyntaxIdentifier; else if (string == "syntax-preprocessor-statement") return CSS::ValueID::VendorSpecificPaletteSyntaxPreprocessorStatement; else if (string == "syntax-preprocessor-value") return CSS::ValueID::VendorSpecificPaletteSyntaxPreprocessorValue; else return CSS::ValueID::Invalid; } static Optional parse_css_color(const CSS::ParsingContext&, const StringView& view) { if (view.equals_ignoring_case("transparent")) return Color::from_rgba(0x00000000); auto color = Color::from_string(view.to_string().to_lowercase()); if (color.has_value()) return color; return {}; } static Optional try_parse_float(const StringView& string) { const char* str = string.characters_without_null_termination(); size_t len = string.length(); size_t weight = 1; int exp_val = 0; float value = 0.0f; float fraction = 0.0f; bool has_sign = false; bool is_negative = false; bool is_fractional = false; bool is_scientific = false; if (str[0] == '-') { is_negative = true; has_sign = true; } if (str[0] == '+') { has_sign = true; } for (size_t i = has_sign; i < len; i++) { // Looks like we're about to start working on the fractional part if (str[i] == '.') { is_fractional = true; continue; } if (str[i] == 'e' || str[i] == 'E') { if (str[i + 1] == '-' || str[i + 1] == '+') exp_val = atoi(str + i + 2); else exp_val = atoi(str + i + 1); is_scientific = true; continue; } if (str[i] < '0' || str[i] > '9' || exp_val != 0) { return {}; continue; } if (is_fractional) { fraction *= 10; fraction += str[i] - '0'; weight *= 10; } else { value = value * 10; value += str[i] - '0'; } } fraction /= weight; value += fraction; if (is_scientific) { bool divide = exp_val < 0; if (divide) exp_val *= -1; for (int i = 0; i < exp_val; i++) { if (divide) value /= 10; else value *= 10; } } return is_negative ? -value : value; } static Length parse_length(const CSS::ParsingContext& context, const StringView& view, bool& is_bad_length) { Length::Type type = Length::Type::Undefined; Optional value; if (view.ends_with('%')) { type = Length::Type::Percentage; value = try_parse_float(view.substring_view(0, view.length() - 1)); } else if (view.to_string().to_lowercase().ends_with("px")) { type = Length::Type::Px; value = try_parse_float(view.substring_view(0, view.length() - 2)); } else if (view.to_string().to_lowercase().ends_with("pt")) { type = Length::Type::Pt; value = try_parse_float(view.substring_view(0, view.length() - 2)); } else if (view.to_string().to_lowercase().ends_with("rem")) { type = Length::Type::Rem; value = try_parse_float(view.substring_view(0, view.length() - 3)); } else if (view.to_string().to_lowercase().ends_with("em")) { type = Length::Type::Em; value = try_parse_float(view.substring_view(0, view.length() - 2)); } else if (view == "0") { type = Length::Type::Px; value = 0; } else if (context.in_quirks_mode()) { type = Length::Type::Px; value = try_parse_float(view); } else { value = try_parse_float(view); if (value.has_value()) is_bad_length = true; } if (!value.has_value()) return {}; return Length(value.value(), type); } RefPtr parse_css_value(const CSS::ParsingContext& context, const StringView& string) { bool is_bad_length = false; auto length = parse_length(context, string, is_bad_length); if (is_bad_length) return nullptr; if (!length.is_undefined()) return LengthStyleValue::create(length); if (string.equals_ignoring_case("inherit")) return InheritStyleValue::create(); if (string.equals_ignoring_case("initial")) return InitialStyleValue::create(); if (string.equals_ignoring_case("auto")) return LengthStyleValue::create(Length::make_auto()); auto color = parse_css_color(context, string); if (color.has_value()) return ColorStyleValue::create(color.value()); if (string == "-libweb-link") return IdentifierStyleValue::create(CSS::ValueID::VendorSpecificLink); else if (string.starts_with("-libweb-palette-")) { auto value_id = value_id_for_palette_string(string.substring_view(16, string.length() - 16)); return IdentifierStyleValue::create(value_id); } return StringStyleValue::create(string); } RefPtr parse_line_width(const CSS::ParsingContext& context, const StringView& part) { auto value = parse_css_value(context, part); if (value && value->is_length()) return static_ptr_cast(value); return nullptr; } RefPtr parse_color(const CSS::ParsingContext& context, const StringView& part) { auto value = parse_css_value(context, part); if (value && value->is_color()) return static_ptr_cast(value); return nullptr; } RefPtr parse_line_style(const CSS::ParsingContext& context, const StringView& part) { auto parsed_value = parse_css_value(context, part); if (!parsed_value || !parsed_value->is_string()) return nullptr; auto value = static_ptr_cast(parsed_value); if (value->to_string() == "dotted") return value; if (value->to_string() == "dashed") return value; if (value->to_string() == "solid") return value; if (value->to_string() == "double") return value; if (value->to_string() == "groove") return value; if (value->to_string() == "ridge") return value; return nullptr; } class CSSParser { public: CSSParser(const CSS::ParsingContext& context, const StringView& input) : m_context(context) , css(input) { } bool next_is(const char* str) const { size_t len = strlen(str); for (size_t i = 0; i < len; ++i) { if (peek(i) != str[i]) return false; } return true; } char peek(size_t offset = 0) const { if ((index + offset) < css.length()) return css[index + offset]; return 0; } char consume_specific(char ch) { if (peek() != ch) { dbg() << "peek() != '" << ch << "'"; } if (peek() != ch) { PARSE_ERROR(); } PARSE_ASSERT(index < css.length()); ++index; return ch; } char consume_one() { PARSE_ASSERT(index < css.length()); return css[index++]; }; bool consume_whitespace_or_comments() { size_t original_index = index; bool in_comment = false; for (; index < css.length(); ++index) { char ch = peek(); if (isspace(ch)) continue; if (!in_comment && ch == '/' && peek(1) == '*') { in_comment = true; ++index; continue; } if (in_comment && ch == '*' && peek(1) == '/') { in_comment = false; ++index; continue; } if (in_comment) continue; break; } return original_index != index; } bool is_valid_selector_char(char ch) const { return isalnum(ch) || ch == '-' || ch == '_' || ch == '(' || ch == ')' || ch == '@'; } bool is_combinator(char ch) const { return ch == '~' || ch == '>' || ch == '+'; } Optional parse_simple_selector() { auto index_at_start = index; if (consume_whitespace_or_comments()) return {}; if (!peek() || peek() == '{' || peek() == ',' || is_combinator(peek())) return {}; Selector::SimpleSelector::Type type; if (peek() == '*') { type = Selector::SimpleSelector::Type::Universal; consume_one(); return Selector::SimpleSelector { type, Selector::SimpleSelector::PseudoClass::None, String(), Selector::SimpleSelector::AttributeMatchType::None, String(), String() }; } if (peek() == '.') { type = Selector::SimpleSelector::Type::Class; consume_one(); } else if (peek() == '#') { type = Selector::SimpleSelector::Type::Id; consume_one(); } else if (isalpha(peek())) { type = Selector::SimpleSelector::Type::TagName; } else { type = Selector::SimpleSelector::Type::Universal; } if (type != Selector::SimpleSelector::Type::Universal) { while (is_valid_selector_char(peek())) buffer.append(consume_one()); PARSE_ASSERT(!buffer.is_null()); } auto value = String::copy(buffer); if (type == Selector::SimpleSelector::Type::TagName) { // Some stylesheets use uppercase tag names, so here's a hack to just lowercase them internally. value = value.to_lowercase(); } Selector::SimpleSelector simple_selector { type, Selector::SimpleSelector::PseudoClass::None, value, Selector::SimpleSelector::AttributeMatchType::None, String(), String() }; buffer.clear(); if (peek() == '[') { Selector::SimpleSelector::AttributeMatchType attribute_match_type = Selector::SimpleSelector::AttributeMatchType::HasAttribute; String attribute_name; String attribute_value; bool in_value = false; consume_specific('['); char expected_end_of_attribute_selector = ']'; while (peek() != expected_end_of_attribute_selector) { char ch = consume_one(); if (ch == '=' || (ch == '~' && peek() == '=')) { if (ch == '=') { attribute_match_type = Selector::SimpleSelector::AttributeMatchType::ExactValueMatch; } else if (ch == '~') { consume_one(); attribute_match_type = Selector::SimpleSelector::AttributeMatchType::Contains; } attribute_name = String::copy(buffer); buffer.clear(); in_value = true; consume_whitespace_or_comments(); if (peek() == '\'') { expected_end_of_attribute_selector = '\''; consume_one(); } else if (peek() == '"') { expected_end_of_attribute_selector = '"'; consume_one(); } continue; } // FIXME: This is a hack that will go away when we replace this with a big boy CSS parser. if (ch == '\\') ch = consume_one(); buffer.append(ch); } if (in_value) attribute_value = String::copy(buffer); else attribute_name = String::copy(buffer); buffer.clear(); simple_selector.attribute_match_type = attribute_match_type; simple_selector.attribute_name = attribute_name; simple_selector.attribute_value = attribute_value; if (expected_end_of_attribute_selector != ']') consume_specific(expected_end_of_attribute_selector); consume_whitespace_or_comments(); consume_specific(']'); } if (peek() == ':') { // FIXME: Implement pseudo elements. [[maybe_unused]] bool is_pseudo_element = false; consume_one(); if (peek() == ':') { is_pseudo_element = true; consume_one(); } if (next_is("not")) { buffer.append(consume_one()); buffer.append(consume_one()); buffer.append(consume_one()); buffer.append(consume_specific('(')); while (peek() != ')') buffer.append(consume_one()); buffer.append(consume_specific(')')); } else { while (is_valid_selector_char(peek())) buffer.append(consume_one()); } auto pseudo_name = String::copy(buffer); buffer.clear(); // Ignore for now, otherwise we produce a "false positive" selector // and apply styles to the element itself, not its pseudo element if (is_pseudo_element) return {}; if (pseudo_name.equals_ignoring_case("link")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::Link; else if (pseudo_name.equals_ignoring_case("visited")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::Visited; else if (pseudo_name.equals_ignoring_case("hover")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::Hover; else if (pseudo_name.equals_ignoring_case("focus")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::Focus; else if (pseudo_name.equals_ignoring_case("first-child")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::FirstChild; else if (pseudo_name.equals_ignoring_case("last-child")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::LastChild; else if (pseudo_name.equals_ignoring_case("only-child")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::OnlyChild; else if (pseudo_name.equals_ignoring_case("empty")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::Empty; else if (pseudo_name.equals_ignoring_case("root")) simple_selector.pseudo_class = Selector::SimpleSelector::PseudoClass::Root; } if (index == index_at_start) { // We consumed nothing. return {}; } return simple_selector; } Optional parse_complex_selector() { auto relation = Selector::ComplexSelector::Relation::Descendant; if (peek() == '{' || peek() == ',') return {}; if (is_combinator(peek())) { switch (peek()) { case '>': relation = Selector::ComplexSelector::Relation::ImmediateChild; break; case '+': relation = Selector::ComplexSelector::Relation::AdjacentSibling; break; case '~': relation = Selector::ComplexSelector::Relation::GeneralSibling; break; } consume_one(); consume_whitespace_or_comments(); } consume_whitespace_or_comments(); Vector simple_selectors; for (;;) { auto component = parse_simple_selector(); if (!component.has_value()) break; simple_selectors.append(component.value()); // If this assert triggers, we're most likely up to no good. PARSE_ASSERT(simple_selectors.size() < 100); } if (simple_selectors.is_empty()) return {}; return Selector::ComplexSelector { relation, move(simple_selectors) }; } void parse_selector() { Vector complex_selectors; for (;;) { auto index_before = index; auto complex_selector = parse_complex_selector(); if (complex_selector.has_value()) complex_selectors.append(complex_selector.value()); consume_whitespace_or_comments(); if (!peek() || peek() == ',' || peek() == '{') break; // HACK: If we didn't move forward, just let go. if (index == index_before) break; } if (complex_selectors.is_empty()) return; complex_selectors.first().relation = Selector::ComplexSelector::Relation::None; current_rule.selectors.append(Selector(move(complex_selectors))); } Optional parse_individual_selector() { parse_selector(); if (current_rule.selectors.is_empty()) return {}; return current_rule.selectors.last(); } void parse_selector_list() { for (;;) { auto index_before = index; parse_selector(); consume_whitespace_or_comments(); if (peek() == ',') { consume_one(); continue; } if (peek() == '{') break; // HACK: If we didn't move forward, just let go. if (index_before == index) break; } } bool is_valid_property_name_char(char ch) const { return ch && !isspace(ch) && ch != ':'; } bool is_valid_property_value_char(char ch) const { return ch && ch != '!' && ch != ';' && ch != '}'; } struct ValueAndImportant { String value; bool important { false }; }; ValueAndImportant consume_css_value() { buffer.clear(); int paren_nesting_level = 0; bool important = false; for (;;) { char ch = peek(); if (ch == '(') { ++paren_nesting_level; buffer.append(consume_one()); continue; } if (ch == ')') { PARSE_ASSERT(paren_nesting_level > 0); --paren_nesting_level; buffer.append(consume_one()); continue; } if (paren_nesting_level > 0) { buffer.append(consume_one()); continue; } if (next_is("!important")) { consume_specific('!'); consume_specific('i'); consume_specific('m'); consume_specific('p'); consume_specific('o'); consume_specific('r'); consume_specific('t'); consume_specific('a'); consume_specific('n'); consume_specific('t'); important = true; continue; } if (next_is("/*")) { consume_whitespace_or_comments(); continue; } if (!ch) break; if (ch == '\\') { consume_one(); buffer.append(consume_one()); continue; } if (ch == '}') break; if (ch == ';') break; buffer.append(consume_one()); } // Remove trailing whitespace. while (!buffer.is_empty() && isspace(buffer.last())) buffer.take_last(); auto string = String::copy(buffer); buffer.clear(); return { string, important }; } Optional parse_property() { consume_whitespace_or_comments(); if (peek() == ';') { consume_one(); return {}; } if (peek() == '}') return {}; buffer.clear(); while (is_valid_property_name_char(peek())) buffer.append(consume_one()); auto property_name = String::copy(buffer); buffer.clear(); consume_whitespace_or_comments(); consume_specific(':'); consume_whitespace_or_comments(); auto [property_value, important] = consume_css_value(); consume_whitespace_or_comments(); if (peek() && peek() != '}') consume_specific(';'); auto property_id = CSS::property_id_from_string(property_name); if (property_id == CSS::PropertyID::Invalid) { dbg() << "CSSParser: Unrecognized property '" << property_name << "'"; } auto value = parse_css_value(m_context, property_value); if (!value) return {}; return StyleProperty { property_id, value.release_nonnull(), important }; } void parse_declaration() { for (;;) { auto property = parse_property(); if (property.has_value()) current_rule.properties.append(property.value()); consume_whitespace_or_comments(); if (peek() == '}') break; } } void parse_rule() { consume_whitespace_or_comments(); if (index >= css.length()) return; // FIXME: We ignore @-rules for now. if (peek() == '@') { while (peek() != '{') consume_one(); int level = 0; for (;;) { auto ch = consume_one(); if (ch == '{') { ++level; } else if (ch == '}') { --level; if (level == 0) break; } } consume_whitespace_or_comments(); return; } parse_selector_list(); consume_specific('{'); parse_declaration(); consume_specific('}'); rules.append(StyleRule::create(move(current_rule.selectors), StyleDeclaration::create(move(current_rule.properties)))); consume_whitespace_or_comments(); } RefPtr parse_sheet() { while (index < css.length()) { parse_rule(); } return StyleSheet::create(move(rules)); } RefPtr parse_standalone_declaration() { consume_whitespace_or_comments(); for (;;) { auto property = parse_property(); if (property.has_value()) current_rule.properties.append(property.value()); consume_whitespace_or_comments(); if (!peek()) break; } return StyleDeclaration::create(move(current_rule.properties)); } private: CSS::ParsingContext m_context; NonnullRefPtrVector rules; struct CurrentRule { Vector selectors; Vector properties; }; CurrentRule current_rule; Vector buffer; size_t index = 0; StringView css; }; Optional parse_selector(const CSS::ParsingContext& context, const StringView& selector_text) { CSSParser parser(context, selector_text); return parser.parse_individual_selector(); } RefPtr parse_css(const CSS::ParsingContext& context, const StringView& css) { if (css.is_empty()) return StyleSheet::create({}); CSSParser parser(context, css); return parser.parse_sheet(); } RefPtr parse_css_declaration(const CSS::ParsingContext& context, const StringView& css) { if (css.is_empty()) return StyleDeclaration::create({}); CSSParser parser(context, css); return parser.parse_standalone_declaration(); } }