srctree

-clang-diagnostic-builtin-macro-redefined,

-google-build-using-namespace,

-misc-const-correctness,

-misc-no-recursion,

-modernize-make-unique,

-modernize-use-emplace,

 

 

#include "archive/zlib.h"

 

#include <zlib.h>

 

#include <utility>

 

namespace archive {

 

#include "etest/etest2.h"

 

#include <cstdint>

#include <type_traits>

#include <vector>

 

 

"//css",

"//dom",

"//engine",

"//gfx",

"//gfx:opengl",

"//gfx:sfml",

"//os:system_info",

"//protocol",

"//render",

"//type:sfml",

"//uri",

"//util:history",

 

 

#include "browser/gui/app.h"

 

#include "css/rule.h"

#include "dom/dom.h"

#include "gfx/color.h"

#include "gfx/opengl_canvas.h"

#include "gfx/sfml_canvas.h"

#include "protocol/handler_factory.h"

#include "render/render.h"

#include "type/sfml.h"

#include "uri/uri.h"

 

#include <SFML/Graphics/Image.hpp>

#include <SFML/Window/Event.hpp>

#include <fmt/format.h>

#include <imgui-SFML.h>

#include <imgui.h>

 

#include <algorithm>

#include <array>

#include <cmath>

#include <cstdlib>

#include <functional>

#include <memory>

#include <optional>

#include <span>

#include <sstream>

#include <string_view>

#include <utility>

#include <variant>

 

 

#ifndef BROWSER_GUI_APP_H_

#define BROWSER_GUI_APP_H_

 

#include "engine/engine.h"

#include "gfx/icanvas.h"

#include "layout/layout_box.h"

#include "uri/uri.h"

#include "util/history.h"

 

 

#include <memory>

#include <string>

 

namespace browser::gui {

 

 

#include "os/system_info.h"

 

#include <spdlog/cfg/env.h>

#include <spdlog/sinks/dup_filter_sink.h>

#include <spdlog/sinks/stdout_color_sinks.h>

#include <spdlog/spdlog.h>

 

#include "dom/dom.h"

#include "engine/engine.h"

#include "protocol/handler_factory.h"

 

#include <spdlog/cfg/env.h>

#include <spdlog/sinks/dup_filter_sink.h>

#include <spdlog/sinks/stdout_color_sinks.h>

#include <spdlog/spdlog.h>

 

#include "css/default.h"

 

#include "css/parser.h"

 

#include <string_view>

 

 

#include "util/string.h"

 

#include <charconv>

#include <limits>

#include <optional>

#include <string>

#include <string_view>

#include <variant>

 

namespace css {

 

 

#include "etest/etest.h"

 

using etest::expect;

using etest::expect_eq;

 

 

#include "css/media_query.h"

#include "css/property_id.h"

#include "css/rule.h"

 

#include "util/string.h"

 

#include <spdlog/spdlog.h>

 

#include <algorithm>

#include <cstdlib>

#include <cstring>

#include <optional>

#include <string_view>

#include <tuple>

#include <utility>

#include <vector>

 

#include "css/rule.h"

#include "css/style_sheet.h"

 

#include <cstddef>

#include <optional>

#include <string_view>

#include <utility>

 

 

 

#include "css/parser.h"

 

#include "css/property_id.h"

 

#include "etest/etest.h"

 

#include <algorithm>

#include <array>

#include <tuple>

 

using namespace std::literals;

using etest::expect;

 

 

#include "etest/etest.h"

 

 

#include <string_view>

 

 

#include "css/property_id.h"

 

#include <sstream>

#include <utility>

 

namespace css {

 

 

 

#include "css/rule.h"

 

#include "css/property_id.h"

 

#include "etest/etest.h"

 

 

#include "css/style_sheet.h"

 

#include "etest/etest2.h"

 

#include <utility>

 

 

#include "css2/token.h"

 

#include <sstream>

#include <variant>

 

namespace css2 {

 

 

#include "css2/tokenizer.h"

 

#include "util/string.h"

 

#include <exception>

 

namespace css2 {

 

 

 

#include "css2/token.h"

 

#include <functional>

#include <optional>

#include <string_view>

#include <utility>

#include <variant>

 

 

#include "css2/tokenizer.h"

 

#include "etest/etest.h"

 

#include <vector>

 

using etest::expect;

 

#include <cstdint>

#include <ostream>

#include <sstream>

#include <utility>

#include <variant>

 

 

 

#include <algorithm>

#include <cstddef>

#include <iterator>

#include <map>

#include <string>

 

 

#include "etest/etest.h"

 

#include <string_view>

#include <utility>

 

using namespace std::literals;

 

 

copts = HASTUR_COPTS,

deps = [

":engine",

"//dom",

"//etest",

"//protocol",

"//type",

"//type:naive",

"//uri",

 

#include "archive/zlib.h"

#include "css/default.h"

#include "css/parser.h"

#include "html/parser.h"

#include "style/style.h"

 

#include <spdlog/spdlog.h>

 

#include <future>

#include <utility>

 

using namespace std::literals;

 

 

 

#include "css/style_sheet.h"

#include "dom/dom.h"

#include "protocol/iprotocol_handler.h"

#include "protocol/response.h"

#include "style/styled_node.h"

#include <memory>

#include <optional>

#include <utility>

 

namespace engine {

 

 

 

#include "engine/engine.h"

 

#include "dom/dom.h"

#include "etest/etest.h"

#include "protocol/iprotocol_handler.h"

#include "protocol/response.h"

#include "type/naive.h"

#include "type/type.h"

#include "uri/uri.h"

 

#include <map>

#include <string>

#include <utility>

 

using namespace std::literals;

using etest::expect;

 

 

#include "etest/etest.h"

 

#include <functional>

#include <utility>

 

namespace etest {

 

 

#include "etest/etest2.h"

 

#include <algorithm>

#include <iomanip>

#include <iostream>

#include <iterator>

#include <sstream>

#include <utility>

 

#if defined(_MSC_VER)

// MSVC doesn't seem to have a way of disabling exceptions.

 

 

#include "etest/cxx_compat.h"

 

#include <functional>

#include <iosfwd>

#include <optional>

 

 

#include "etest/etest2.h"

 

int main() {

auto s = etest::Suite{};

s.add_test("uncaught exception", []([[maybe_unused]] auto &a) {

 

visibility = ["//visibility:public"],

deps = [

":gfx",

"@glad",

],

)

visibility = ["//visibility:public"],

deps = [

":gfx",

"//os:xdg",

"//type:sfml",

"@sfml//:graphics",

"@spdlog",

],

)

 

#ifndef GFX_CANVAS_COMMAND_SAVER_H_

#define GFX_CANVAS_COMMAND_SAVER_H_

 

#include "gfx/icanvas.h"

 

#include <algorithm>

#include <iterator>

#include <string>

#include <utility>

#include <variant>

#include <vector>

 

 

#include "gfx/canvas_command_saver.h"

 

#include "etest/etest.h"

 

#include <string>

#include <string_view>

 

using namespace gfx;

using namespace std::literals;

 

 

#include <algorithm>

#include <map>

 

namespace gfx {

namespace {

 

// SPDX-License-Identifier: BSD-2-Clause

 

#include "gfx/color.h"

#include "gfx/opengl_canvas.h"

#include "gfx/sfml_canvas.h"

#include "type/sfml.h"

 

#include <SFML/Graphics/RenderWindow.hpp>

#include <SFML/Window/Event.hpp>

 

#include <array>

#include <memory>

#include <string_view>

 

 

#include "gfx/color.h"

#include "gfx/font.h"

 

#include <span>

#include <string_view>

 

 

 

#include "gfx/opengl_canvas.h"

 

#include <glad/gl.h>

 

#include <array>

 

namespace gfx {

namespace {

 

 

#include "gfx/opengl_shader.h"

 

#include "gfx/icanvas.h"

 

namespace gfx {

 

class OpenGLCanvas final : public ICanvas {

 

 

#include <cassert>

#include <cstdlib>

 

// NOLINTBEGIN(readability-make-member-function-const): The drawing code

// shouldn't be thought of as const, even if it technically doesn't modify any

 

 

#include "gfx/sfml_canvas.h"

 

#include "os/xdg.h"

 

#include <SFML/Graphics/RectangleShape.hpp>

#include <SFML/Graphics/RenderTarget.hpp>

#include <SFML/Graphics/Sprite.hpp>

#include <SFML/Graphics/Text.hpp>

#include <SFML/Graphics/View.hpp>

#include <spdlog/spdlog.h>

 

#include <cassert>

#include <exception>

#include <filesystem>

#include <string>

#include <string_view>

#include <system_error>

 

using namespace std::literals;

 

 

 

#include "gfx/icanvas.h"

 

#include "type/sfml.h"

 

#include <SFML/Graphics/Shader.hpp>

#include <SFML/Graphics/Texture.hpp>

 

#include <vector>

 

namespace sf {

 

copts = HASTUR_COPTS,

deps = [

":html",

"//etest",

"//html2",

],

 

 

#include "html/parser.h"

 

#include "util/string.h"

 

#include <spdlog/spdlog.h>

#include <cassert>

#include <string>

#include <string_view>

#include <variant>

 

using namespace std::literals;

 

 

 

#include "dom/dom.h"

#include "html2/parser_states.h"

#include "html2/tokenizer.h"

 

#include <functional>

 

#include "dom/dom.h"

#include "html2/iparser_actions.h"

#include "html2/parser_states.h"

#include "html2/tokenizer.h"

 

#include <algorithm>

#include <cassert>

#include <span>

#include <utility>

#include <variant>

#include <vector>

 

 

#include "html/parser.h"

 

#include "etest/etest.h"

 

#include <cstddef>

 

using namespace std::literals;

using etest::expect;

 

#include "html2/character_reference.h"

 

#include <array>

#include <string_view>

 

using namespace std::literals;

 

 

#include "etest/etest.h"

 

using namespace std::literals;

 

using etest::expect;

 

#define HTML2_IPARSER_ACTIONS_H_

 

#include "html2/parser_states.h"

#include "html2/tokenizer.h"

 

#include <span>

 

#include "html2/parser_states.h"

 

#include "html2/iparser_actions.h"

#include "html2/tokenizer.h"

 

#include "util/string.h"

#include <array>

#include <cassert>

#include <optional>

#include <string_view>

#include <variant>

#include <vector>

 

 

#ifndef HTML2_PARSER_STATES_H_

#define HTML2_PARSER_STATES_H_

 

 

#include <variant>

 

namespace html2 {

 

 

#include "html2/parser_states.h"

 

#include "html2/tokenizer.h"

 

#include "etest/etest.h"

#include "html/parser_actions.h"

 

#include <vector>

 

using etest::expect_eq;

 

 

#include "html2/token.h"

 

 

#include <string>

#include <variant>

 

#include "html2/tokenizer.h"

 

#include "html2/character_reference.h"

#include "util/string.h"

#include "util/unicode.h"

 

#include <cstdint>

#include <cstring>

#include <map>

 

using namespace std::literals;

 

 

 

#include "html2/token.h"

 

#include <cstdint>

#include <functional>

#include <optional>

#include <string>

#include <string_view>

#include <utility>

 

namespace html2 {

 

 

 

#include "html2/tokenizer.h"

 

#include "etest/etest.h"

 

#include <array>

#include <iterator>

#include <string>

#include <utility>

#include <variant>

#include <vector>

 

 

using namespace std::literals;

 

 

#include "util/unicode.h"

 

#include <algorithm>

#include <functional>

#include <optional>

#include <string>

 

#include "etest/etest2.h"

#include "util/unicode.h"

 

namespace {

std::string unicode_as_utf8_string(std::vector<int> const &code_points) {

std::string result{};

 

#include "js/ast.h"

 

#include <cassert>

#include <functional>

#include <map>

#include <string>

#include <utility>

#include <variant>

 

 

#include "etest/etest.h"

 

#include <tuple>

 

using namespace js::ast;

using etest::expect;

 

 

#include "etest/etest.h"

 

using namespace js::ast;

using etest::expect_eq;

 

 

 

#include "js/tokenizer.h"

 

#include "etest/etest.h"

 

#include <vector>

 

using namespace js::parse;

 

"//type:naive",

"//util:from_chars",

"//util:string",

"@spdlog",

],

)

srcs = [src],

deps = [

":layout",

"//dom",

"//etest",

"//type",

],

) for src in glob(["*_test.cpp"])]

 

#include "layout/box_model.h"

 

#include "etest/etest.h"

 

using etest::expect;

 

 

 

#include "layout/layout.h"

 

#include "type/naive.h"

#include "util/string.h"

 

#include <spdlog/spdlog.h>

 

#include <algorithm>

#include <cassert>

#include <cstdlib>

#include <list>

#include <map>

#include <optional>

#include <string>

#include <string_view>

#include <utility>

#include <variant>

 

using namespace std::literals;

 

 

 

#include "layout/layout_box.h"

 

#include "util/from_chars.h"

 

#include <spdlog/spdlog.h>

 

#include <cstdint>

#include <cstdlib>

#include <optional>

#include <sstream>

#include <string_view>

#include <utility>

#include <variant>

 

 

 

#include "layout/layout.h"

 

#include "dom/dom.h"

#include "etest/etest.h"

 

#include <string_view>

#include <utility>

#include <vector>

 

 

#include "layout/layout.h"

 

#include "etest/cxx_compat.h"

#include "etest/etest.h"

 

#include <optional>

#include <string>

 

 

#include "layout/layout.h"

 

 

#include <memory>

#include <optional>

#include <string_view>

#include <utility>

 

using namespace std::literals;

using etest::expect;

 

 

#include "layout/layout_box.h"

 

namespace layout {

// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)

int UnresolvedValue::resolve(int font_size, int root_font_size, std::optional<int> percent_relative_to) const {

 

 

#include "net/socket.h"

 

#include <openssl/ssl.h>

 

#include <string>

#include <utility>

 

namespace net {

 

 

#include "etest/etest.h"

 

 

#include <cstdint>

#include <future>

#include <string>

#include <thread>

#include <utility>

 

 

#include <sys/mman.h>

 

#include <cstdlib>

#include <cstring>

 

namespace os {

 

 

#include "etest/etest2.h"

 

#include <cstdint>

 

// __amd64 => GNU C, _M_AMD64 => MSVC.

#if defined(__amd64) || defined(_M_AMD64)

 

#include <charconv>

#include <cstdlib>

#include <cstring>

 

namespace os {

 

 

 

#include "etest/etest2.h"

 

#include <stdlib.h>

 

// NOLINTBEGIN(concurrency-mt-unsafe): No threads here.

 

#include "os/xdg.h"

 

#include <cstdlib>

 

using namespace std::literals;

 

 

 

#include "etest/etest2.h"

 

#include <stdlib.h>

 

#include <algorithm>

 

 

#include "protocol/file_handler.h"

 

#include <filesystem>

#include <fstream>

#include <string>

#include <utility>

 

 

 

#include "protocol/iprotocol_handler.h"

 

namespace protocol {

 

class FileHandler final : public IProtocolHandler {

 

 

#include "protocol/file_handler.h"

 

#include "etest/etest.h"

#include "uri/uri.h"

 

 

#include <cerrno>

#include <filesystem>

 

#include "protocol/http_handler.h"

#include "protocol/https_handler.h"

 

#include <utility>

 

namespace protocol {

 

 

#include "protocol/http.h"

 

#include "util/string.h"

 

 

#include <charconv>

#include <sstream>

#include <string_view>

#include <utility>

 

 

#include "util/string.h"

 

#include <charconv>

#include <optional>

#include <string>

#include <string_view>

#include <utility>

 

namespace protocol {

 

 

#include "net/socket.h"

#include "protocol/http.h"

 

namespace protocol {

 

 

#define PROTOCOL_HTTP_HANDLER_H_

 

#include "protocol/iprotocol_handler.h"

 

#include <optional>

#include <string>

 

#include "protocol/http.h"

 

#include "etest/etest.h"

 

#include <utility>

 

using namespace std::string_view_literals;

 

 

#include "net/socket.h"

#include "protocol/http.h"

 

namespace protocol {

 

 

#define PROTOCOL_HTTPS_HANDLER_H_

 

#include "protocol/iprotocol_handler.h"

 

#include <optional>

#include <string>

 

 

#include "protocol/iprotocol_handler.h"

 

#include <functional>

#include <map>

#include <memory>

 

 

#include "protocol/multi_protocol_handler.h"

 

#include "etest/etest.h"

 

#include <memory>

 

using etest::expect_eq;

using protocol::MultiProtocolHandler;

 

#include "util/string.h"

 

#include <algorithm>

#include <sstream>

#include <utility>

 

namespace protocol {

 

//

// SPDX-License-Identifier: BSD-2-Clause

 

 

#include "etest/etest.h"

 

 

visibility = ["//visibility:public"],

deps = [

"//css",

"//gfx",

"//layout",

"@spdlog",

],

)

copts = HASTUR_COPTS,

deps = [

":render",

"//dom",

"//etest",

"//gfx",

"//layout",

"//style",

 

#include "render/render.h"

 

#include "css/property_id.h"

#include "gfx/color.h"

 

#include <spdlog/spdlog.h>

 

#include <algorithm>

#include <string_view>

 

namespace render {

namespace {

 

 

#include "render/render.h"

 

#include "dom/dom.h"

#include "etest/etest.h"

#include "gfx/canvas_command_saver.h"

#include "gfx/color.h"

#include "gfx/icanvas.h"

#include "layout/layout_box.h"

#include "style/styled_node.h"

 

#include <string_view>

 

using etest::expect_eq;

 

 

deps = [

":style",

"//css",

"//etest",

"@fmt",

],

copts = HASTUR_COPTS,

deps = [

":style",

"//etest",

],

)

 

 

#include "style/style.h"

 

#include "css/media_query.h"

#include "css/parser.h"

#include "util/string.h"

 

#include <algorithm>

#include <iterator>

#include <string>

#include <utility>

 

using namespace std::literals;

 

 

#include "style/style.h"

#include "style/styled_node.h"

 

#include "css/rule.h"

#include "css/style_sheet.h"

#include "etest/etest.h"

 

 

#include <algorithm>

#include <array>

 

using namespace std::literals;

using etest::expect;

 

 

#include "style/styled_node.h"

 

#include "gfx/color.h"

#include "util/string.h"

 

#include <spdlog/spdlog.h>

#include <cmath>

#include <cstdint>

#include <cstring>

#include <map>

#include <optional>

#include <sstream>

#include <string_view>

#include <utility>

 

using namespace std::literals;

 

 

#include "util/string.h"

 

#include <algorithm>

#include <string>

#include <string_view>

#include <utility>

 

 

#include "style/styled_node.h"

 

#include "etest/etest.h"

 

#include <string>

#include <tuple>

#include <utility>

 

using namespace std::literals;

using etest::expect;

 

copts = HASTUR_COPTS,

deps = [

":tui",

"//dom",

"//etest",

"//layout",

 

 

#include "tui/tui.h"

 

#include <ftxui/dom/elements.hpp>

#include <ftxui/screen/screen.hpp>

 

#include <cstdlib>

#include <string>

 

namespace tui {

namespace {

 

#ifndef TUI_TUI_H_

#define TUI_TUI_H_

 

 

#include <string>

 

 

 

#include "tui/tui.h"

 

#include "dom/dom.h"

#include "etest/etest2.h"

#include "layout/layout.h"

 

copts = HASTUR_COPTS,

deps = [

":naive",

"//etest",

],

)

"//os:xdg",

"//util:string",

"@sfml//:graphics",

],

)

 

 

#include "type/naive.h"

 

#include "etest/etest2.h"

 

int main() {

 

 

#include "type/sfml.h"

 

#include "os/xdg.h"

#include "util/string.h"

 

#include <SFML/Graphics/Text.hpp>

 

#include <algorithm>

#include <filesystem>

#include <optional>

#include <string>

#include <string_view>

#include <system_error>

 

namespace type {

namespace {

 

 

#include <SFML/Graphics/Font.hpp>

 

#include <map>

#include <memory>

#include <optional>

#include <string_view>

#include <utility>

 

 

 

#include "util/string.h"

 

 

#include <exception>

#include <regex>

#include <utility>

 

namespace uri {

 

//

// SPDX-License-Identifier: BSD-2-Clause

 

 

template class icu::StringByteSink<std::string>;

 

 

#include "url/url.h"

 

 

#include "util/string.h"

#include "util/unicode.h"

#include "util/uuid.h"

 

#include <unicode/bytestream.h>

#include <unicode/idna.h>

 

#include <array>

#include <cassert>

#include <charconv>

#include <cmath>

#include <cstdint>

#include <cstdlib>

#include <iostream>

#include <optional>

#include <string>

#include <string_view>

#include <tuple>

#include <utility>

#include <variant>

 

#include <array>

#include <cstdint>

#include <functional>

#include <optional>

#include <string>

#include <string_view>

#include <utility>

#include <variant>

 

namespace url {

 

 

 

#include <array>

#include <cstdint>

#include <iostream>

#include <optional>

#include <regex>

#include <utility>

#include <variant>

#include <vector>

 

#define UTIL_CRC32_H_

 

#include <array>

#include <cstdint>

#include <span>

 

 

#ifndef UTIL_FROM_CHARS_H_

#define UTIL_FROM_CHARS_H_

 

 

// Workaround for libc++ not supporting std::from_chars for floating point numbers.

// TODO(robinlinden): Nuke once libc++ supports std::from_chars w/ floats.

#if defined(_LIBCPP_VERSION)

 

#include <cerrno>

#include <charconv>

#include <cstdlib>

 

#include "etest/etest.h"

 

#include <string_view>

 

using namespace std::literals;

using etest::expect_eq;

 

#ifndef UTIL_HISTORY_H_

#define UTIL_HISTORY_H_

 

#include <optional>

#include <utility>

#include <vector>

 

#include <array>

#include <cassert>

#include <charconv>

#include <cstdint>

#include <iomanip>

#include <ios>

#include <iterator>

#include <span>

#include <sstream>

#include <string>

#include <string_view>

#include <utility>

#include <vector>

 

 

 

#include <array>

#include <climits>

#include <iostream>

#include <limits>

 

using namespace std::literals;

using namespace util;

 

#ifndef UTIL_UNICODE_H_

#define UTIL_UNICODE_H_

 

#include <cstdint>

#include <optional>

#include <string>

#include <utility>

 

namespace util {

 

#include "etest/etest.h"

 

#include <cstdint>

#include <string_view>

 

using namespace std::literals;

using namespace util;

 

#define UTIL_UUID_H_

 

#include <array>

#include <iomanip>

#include <ios>

#include <random>

#include <sstream>

#include <utility>

 

namespace util {

data[8] &= 0x3f;

data[8] |= 0x80;

 

if (i == 4 || i == 6 || i == 8 || i == 10) {

uuid_string << '-';

}

 

 

#include <cassert>

#include <cmath>

#include <cstdint>

#include <istream>

 

namespace wasm {

 

 

#include "etest/cxx_compat.h"

#include "etest/etest.h"

 

#include <cstdint>

#include <limits>

#include <optional>