LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-10 13:00:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
9d5e538247
ladybird/Userland/Libraries/CMakeLists.txt

75 lines
2.0 KiB
CMake
Raw Normal View History

LibAccelGfx+Meta: Introduce OpenGL painting library This change introduces a new 2D graphics library that uses OpenGL to perform painting operations. For now, it has extremely limited functionality and supports only rectangle painting, but we have to start somewhere. Since this library is intended to be used by LibWeb, where the WebContent process does not have an associated window, painting occurs in an offscreen buffer created using EGL. For now it is only possible to compile this library on linux. Offscreen context creation on SerenityOS and MacOS will have to be implemented separately in the future. Co-Authored-By: Andreas Kling <awesomekling@gmail.com>
2023-10-27 18:03:17 +03:00
add_subdirectory(LibAccelGfx)
Libraries: Rename LibTar to LibArchive This is in preparation for a new implementation of zip archive extraction and creation.
2021-03-18 17:22:05 +03:00
add_subdirectory(LibArchive)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibAudio)
add_subdirectory(LibC)
Solitaire: Move cards functionality into LibCards
2021-05-20 14:01:14 +03:00
add_subdirectory(LibCards)
Chess: Refactor game logic into LibChess for use in engines In the future UCI protocol stuff will also go into LibChess.
2020-08-19 00:02:53 +03:00
add_subdirectory(LibChess)
LibCMake: Introduce a CMake lexer
2023-03-03 15:12:56 +03:00
add_subdirectory(LibCMake)
LibCodeComprehension: Re-organize code comprehension related code This moves all code comprehension-related code to a new library, LibCodeComprehension. This also moves some types related to code comprehension tasks (such as autocomplete, find declaration) out of LibGUI and into LibCodeComprehension.
2022-05-14 17:09:24 +03:00
add_subdirectory(LibCodeComprehension)
LibRegex: Add a regular expression library This commit is a mix of several commits, squashed into one because the commits before 'Move regex to own Library and fix all the broken stuff' were not fixable in any elegant way. The commits are listed below for "historical" purposes: - AK: Add options/flags and Errors for regular expressions Flags can be provided for any possible flavour by adding a new scoped enum. Handling of flags is done by templated Options class and the overloaded '|' and '&' operators. - AK: Add Lexer for regular expressions The lexer parses the input and extracts tokens needed to parse a regular expression. - AK: Add regex Parser and PosixExtendedParser This patchset adds a abstract parser class that can be derived to implement different parsers. A parser produces bytecode to be executed within the regex matcher. - AK: Add regex matcher This patchset adds an regex matcher based on the principles of the T-REX VM. The bytecode pruduced by the respective Parser is put into the matcher and the VM will recursively execute the bytecode according to the available OpCodes. Possible improvement: the recursion could be replaced by multi threading capabilities. To match a Regular expression, e.g. for the Posix standard regular expression matcher use the following API: ``` Pattern<PosixExtendedParser> pattern("^.*$"); auto result = pattern.match("Well, hello friends!\nHello World!"); // Match whole needle EXPECT(result.count == 1); EXPECT(result.matches.at(0).view.starts_with("Well")); EXPECT(result.matches.at(0).view.end() == "!"); result = pattern.match("Well, hello friends!\nHello World!", PosixFlags::Multiline); // Match line by line EXPECT(result.count == 2); EXPECT(result.matches.at(0).view == "Well, hello friends!"); EXPECT(result.matches.at(1).view == "Hello World!"); EXPECT(pattern.has_match("Well,....")); // Just check if match without a result, which saves some resources. ``` - AK: Rework regex to work with opcodes objects This patchsets reworks the matcher to work on a more structured base. For that an abstract OpCode class and derived classes for the specific OpCodes have been added. The respective opcode logic is contained in each respective execute() method. - AK: Add benchmark for regex - AK: Some optimization in regex for runtime and memory - LibRegex: Move regex to own Library and fix all the broken stuff Now regex works again and grep utility is also in place for testing. This commit also fixes the use of regex.h in C by making `regex_t` an opaque (-ish) type, which makes its behaviour consistent between C and C++ compilers. Previously, <regex.h> would've blown C compilers up, and even if it didn't, would've caused a leak in C code, and not in C++ code (due to the existence of `OwnPtr` inside the struct). To make this whole ordeal easier to deal with (for now), this pulls the definitions of `reg*()` into LibRegex. pros: - The circular dependency between LibC and LibRegex is broken - Eaiser to test (without accidentally pulling in the host's libc!) cons: - Using any of the regex.h functions will require the user to link -lregex - The symbols will be missing from libc, which will be a big surprise down the line (especially with shared libs). Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2020-04-26 15:45:10 +03:00
add_subdirectory(LibCompress)
Userland: Introduce ConfigServer and LibConfig ConfigServer is an IPC service that provides access to application configuration and settings. The idea is to replace all uses of Core::ConfigFile with IPC requests to ConfigServer. This first cut of the API is pretty similar to Core::ConfigFile. The old: auto config = Core::ConfigFile::open_for_app("App"); auto value = config->read_entry("Group", "Key"); The new: auto value = Config::read_string("App", "Group", "Key"); ConfigServer uses the ~/.config directory as its backing store and all the files remain human-editable. :^)
2021-08-25 20:35:19 +03:00
add_subdirectory(LibConfig)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibCore)
Everywhere: Core dump => Coredump We all know what a coredump is, and it feels more natural to refer to it as a coredump (most code already does), so let's be consistent.
2021-08-22 15:51:04 +03:00
add_subdirectory(LibCoredump)
LibRegex: Add a regular expression library This commit is a mix of several commits, squashed into one because the commits before 'Move regex to own Library and fix all the broken stuff' were not fixable in any elegant way. The commits are listed below for "historical" purposes: - AK: Add options/flags and Errors for regular expressions Flags can be provided for any possible flavour by adding a new scoped enum. Handling of flags is done by templated Options class and the overloaded '|' and '&' operators. - AK: Add Lexer for regular expressions The lexer parses the input and extracts tokens needed to parse a regular expression. - AK: Add regex Parser and PosixExtendedParser This patchset adds a abstract parser class that can be derived to implement different parsers. A parser produces bytecode to be executed within the regex matcher. - AK: Add regex matcher This patchset adds an regex matcher based on the principles of the T-REX VM. The bytecode pruduced by the respective Parser is put into the matcher and the VM will recursively execute the bytecode according to the available OpCodes. Possible improvement: the recursion could be replaced by multi threading capabilities. To match a Regular expression, e.g. for the Posix standard regular expression matcher use the following API: ``` Pattern<PosixExtendedParser> pattern("^.*$"); auto result = pattern.match("Well, hello friends!\nHello World!"); // Match whole needle EXPECT(result.count == 1); EXPECT(result.matches.at(0).view.starts_with("Well")); EXPECT(result.matches.at(0).view.end() == "!"); result = pattern.match("Well, hello friends!\nHello World!", PosixFlags::Multiline); // Match line by line EXPECT(result.count == 2); EXPECT(result.matches.at(0).view == "Well, hello friends!"); EXPECT(result.matches.at(1).view == "Hello World!"); EXPECT(pattern.has_match("Well,....")); // Just check if match without a result, which saves some resources. ``` - AK: Rework regex to work with opcodes objects This patchsets reworks the matcher to work on a more structured base. For that an abstract OpCode class and derived classes for the specific OpCodes have been added. The respective opcode logic is contained in each respective execute() method. - AK: Add benchmark for regex - AK: Some optimization in regex for runtime and memory - LibRegex: Move regex to own Library and fix all the broken stuff Now regex works again and grep utility is also in place for testing. This commit also fixes the use of regex.h in C by making `regex_t` an opaque (-ish) type, which makes its behaviour consistent between C and C++ compilers. Previously, <regex.h> would've blown C compilers up, and even if it didn't, would've caused a leak in C code, and not in C++ code (due to the existence of `OwnPtr` inside the struct). To make this whole ordeal easier to deal with (for now), this pulls the definitions of `reg*()` into LibRegex. pros: - The circular dependency between LibC and LibRegex is broken - Eaiser to test (without accidentally pulling in the host's libc!) cons: - Using any of the regex.h functions will require the user to link -lregex - The symbols will be missing from libc, which will be a big surprise down the line (especially with shared libs). Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2020-04-26 15:45:10 +03:00
add_subdirectory(LibCpp)
LibCrypt: Add LibCrypt, crypt, and crypt_r
2020-07-25 06:08:48 +03:00
add_subdirectory(LibCrypt)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibCrypto)
add_subdirectory(LibDebug)
add_subdirectory(LibDesktop)
Libraries: Add LibDeviceTree for manipulating OpenFirmware Device Trees Starting with header validation and a dump() method that can be used to debug future parsing work.
2021-10-18 04:09:18 +03:00
add_subdirectory(LibDeviceTree)
LibRegex: Add a regular expression library This commit is a mix of several commits, squashed into one because the commits before 'Move regex to own Library and fix all the broken stuff' were not fixable in any elegant way. The commits are listed below for "historical" purposes: - AK: Add options/flags and Errors for regular expressions Flags can be provided for any possible flavour by adding a new scoped enum. Handling of flags is done by templated Options class and the overloaded '|' and '&' operators. - AK: Add Lexer for regular expressions The lexer parses the input and extracts tokens needed to parse a regular expression. - AK: Add regex Parser and PosixExtendedParser This patchset adds a abstract parser class that can be derived to implement different parsers. A parser produces bytecode to be executed within the regex matcher. - AK: Add regex matcher This patchset adds an regex matcher based on the principles of the T-REX VM. The bytecode pruduced by the respective Parser is put into the matcher and the VM will recursively execute the bytecode according to the available OpCodes. Possible improvement: the recursion could be replaced by multi threading capabilities. To match a Regular expression, e.g. for the Posix standard regular expression matcher use the following API: ``` Pattern<PosixExtendedParser> pattern("^.*$"); auto result = pattern.match("Well, hello friends!\nHello World!"); // Match whole needle EXPECT(result.count == 1); EXPECT(result.matches.at(0).view.starts_with("Well")); EXPECT(result.matches.at(0).view.end() == "!"); result = pattern.match("Well, hello friends!\nHello World!", PosixFlags::Multiline); // Match line by line EXPECT(result.count == 2); EXPECT(result.matches.at(0).view == "Well, hello friends!"); EXPECT(result.matches.at(1).view == "Hello World!"); EXPECT(pattern.has_match("Well,....")); // Just check if match without a result, which saves some resources. ``` - AK: Rework regex to work with opcodes objects This patchsets reworks the matcher to work on a more structured base. For that an abstract OpCode class and derived classes for the specific OpCodes have been added. The respective opcode logic is contained in each respective execute() method. - AK: Add benchmark for regex - AK: Some optimization in regex for runtime and memory - LibRegex: Move regex to own Library and fix all the broken stuff Now regex works again and grep utility is also in place for testing. This commit also fixes the use of regex.h in C by making `regex_t` an opaque (-ish) type, which makes its behaviour consistent between C and C++ compilers. Previously, <regex.h> would've blown C compilers up, and even if it didn't, would've caused a leak in C code, and not in C++ code (due to the existence of `OwnPtr` inside the struct). To make this whole ordeal easier to deal with (for now), this pulls the definitions of `reg*()` into LibRegex. pros: - The circular dependency between LibC and LibRegex is broken - Eaiser to test (without accidentally pulling in the host's libc!) cons: - Using any of the regex.h functions will require the user to link -lregex - The symbols will be missing from libc, which will be a big surprise down the line (especially with shared libs). Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2020-04-26 15:45:10 +03:00
add_subdirectory(LibDiff)
LookupServer: Move DNS related code into new LibDNS library This allows other code to use the DNSPacket class, e.g. when sent over IPC.
2022-04-13 08:25:07 +03:00
add_subdirectory(LibDNS)
Libraries: Add LibDSP LibDSP is a library for digital signal processing, and is primarily intended to support the future DAW version of Piano.
2021-08-27 17:18:11 +03:00
add_subdirectory(LibDSP)
LibEDID: Add a library to parse EDID blobs This library can be used (for the most part) by kernel drivers as well as user mode. For this reason FixedPoint is used rather than floating point, but kept to a minimum.
2021-12-27 08:19:55 +03:00
add_subdirectory(LibEDID)
CMake: Install sources of LibELF
2021-01-06 22:43:34 +03:00
add_subdirectory(LibELF)
LibFileSystem: Create `LibFileSystem` Copy over updated `DeprecatedFile` functions
2023-03-21 16:32:08 +03:00
add_subdirectory(LibFileSystem)
FileSystemAccessServer+TextEditor: Implement cross-process modal prompts This transitions from synchronous IPC calls to asynchronous IPC calls provided through a synchronous interface in LibFileSystemAccessClient which allows the parent Application to stay responsive. It achieves this with Promise which is pumping the Application event loop while waiting for the Dialog to respond with the user's action. LibFileSystemAccessClient provides a lazy singleton which also ensures that FileSystemAccessServer is running in the event of a crash. This also transitions TextEditor into using LibFileSystemAccessClient.
2021-07-11 18:16:26 +03:00
add_subdirectory(LibFileSystemAccessClient)
LibGemini: Implement basic Gemini protocol support
2020-05-14 11:34:18 +03:00
add_subdirectory(LibGemini)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibGfx)
LibGL: Implement a basic OpenGL 1.x compatible library This currently (obviously) doesn't support any actual 3D hardware, hence all calls are done via software rendering. Note that any modern constructs such as shaders are unsupported, as this driver only implements Fixed Function Pipeline functionality. The library is split into a base GLContext interface and a software based renderer implementation of said interface. The global glXXX functions serve as an OpenGL compatible c-style interface to the currently bound context instance. Co-authored-by: Stephan Unverwerth <s.unverwerth@gmx.de>
2021-01-06 14:58:01 +03:00
add_subdirectory(LibGL)
LibGLSL: Add LibGLSL This adds a new library, LibGLSL for parsing and compiling GLSL programs to LibGPU IR. Currently the compiler consists only of stubs.
2022-08-28 20:23:30 +03:00
add_subdirectory(LibGLSL)
LibGL+LibGPU+LibSoftGPU: Load SoftGPU driver dynamically This loads libsoftgpu.so during GLContext creation and instantiates the device class which is then passed into the GLContext constructor.
2022-03-27 19:54:31 +03:00
add_subdirectory(LibGPU)
LibTTF: Reorganized TTF parsing code into LibTTF
2020-06-06 14:26:33 +03:00
add_subdirectory(LibGUI)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibHTTP)
LibIDL+WrapperGenerator: Move IDL code into a library IDL function overload resolution requires knowing each IDL function's parameters and their types at runtime. The simplest way to do that is just to make the types the generator uses available to the runtime. Parsing has moved to LibIDL, but code generation has not, since that is very specific to WrapperGenerator.
2022-08-22 16:50:06 +03:00
add_subdirectory(LibIDL)
LibIMAP: Add a new IMAP client and support NOOP A large commit, but sets up the framework for how the IMAP library will work. Right now only the NOOP command and response is supported.
2021-06-01 16:21:01 +03:00
add_subdirectory(LibIMAP)
ImageDecoder: Add a new service for out-of-process image decoding :^) The new ImageDecoder service (available for members of "image" via /tmp/portal/image) allows you to decode images in a separate process. This will allow programs to confidently load untrusted images, since the bulk of the security concerns are sandboxed to a separate process. The only API right now is a synchronous IPC DecodeImage() call that takes a shbuf with encoded image data and returns a shared buffer and metadata for the decoded image. It also comes with a very simple library for interfacing with the ImageDecoder service: LibImageDecoderClient. The name is a bit of a mouthful but I guess we can rename it later if we think of something nicer to call it. There's obviously a bit of overhead to spawning a separate process for every image decode, so this is mostly only appropriate for untrusted images (e.g stuff downloaded from the web) and not necessary for trusted local images (e.g stuff in /res)
2020-06-22 22:35:22 +03:00
add_subdirectory(LibImageDecoderClient)
LibTTF: Reorganized TTF parsing code into LibTTF
2020-06-06 14:26:33 +03:00
add_subdirectory(LibIPC)
LibJIT+LibJS: Move JIT::Assembler into a new LibJIT library This will allow other parts of the system to generate machine code at runtime. :^)
2023-10-26 16:18:28 +03:00
add_subdirectory(LibJIT)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibJS)
LibKeyboard: Add new library for keyboard applications Move shared code base from keymap and KeyboardMapper to this library.
2020-05-31 16:23:55 +03:00
add_subdirectory(LibKeyboard)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibLine)
LibLocale+LibUnicode: Move generated CLDR data files to LibLocale folder They are still included into LibUnicode, but this moves their generated location to be under LibLocale.
2022-09-02 18:04:53 +03:00
add_subdirectory(LibLocale)
LibMain: Add a new library for more ergonomic userspace entry functions By linking with LibMain, your program no longer needs to provide main(). Instead, execution begins in this function: ErrorOr<int> serenity_main(Main::Arguments); This allows programs that link with LibMain to use TRY() already in their entry function, without having to do manual ErrorOr unwrapping. This is very experimental, but it seems like a nice idea so let's try it out. :^)
2021-11-22 17:44:54 +03:00
add_subdirectory(LibMain)
Help+LibManual: Move non-UI-specific manual handling to LibManual This is a first step in deduplicating code within and across Help and man. Because LibManual also doesn't contain any DeprecatedString, some adjustments to Help's string handling is included, just to interoperate with LibManual better. Further work in this area mostly requires String APIs in LibGUI.
2022-07-13 01:20:27 +03:00
add_subdirectory(LibManual)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibMarkdown)
Kernel+LibPartition: Move DiskPartitionMetadata into LibPartition This commit creates a new library LibPartition which will contain partition related code sharable between Kernel and Userland and includes DiskPartitionMetadata as the first shared class.
2022-02-12 22:21:28 +03:00
add_subdirectory(LibPartition)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibPCIDB)
LibPDF: Create basic object structure This commit is the start of LibPDF, and introduces some basic structure objects. This emulates LibJS's Value structure, where Value is a simple class that can contain a pointer to a more complex Object class with more data. All of the basic PDF objects have a representation.
2021-05-01 04:23:17 +03:00
add_subdirectory(LibPDF)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibProtocol)
LibRegex: Add a regular expression library This commit is a mix of several commits, squashed into one because the commits before 'Move regex to own Library and fix all the broken stuff' were not fixable in any elegant way. The commits are listed below for "historical" purposes: - AK: Add options/flags and Errors for regular expressions Flags can be provided for any possible flavour by adding a new scoped enum. Handling of flags is done by templated Options class and the overloaded '|' and '&' operators. - AK: Add Lexer for regular expressions The lexer parses the input and extracts tokens needed to parse a regular expression. - AK: Add regex Parser and PosixExtendedParser This patchset adds a abstract parser class that can be derived to implement different parsers. A parser produces bytecode to be executed within the regex matcher. - AK: Add regex matcher This patchset adds an regex matcher based on the principles of the T-REX VM. The bytecode pruduced by the respective Parser is put into the matcher and the VM will recursively execute the bytecode according to the available OpCodes. Possible improvement: the recursion could be replaced by multi threading capabilities. To match a Regular expression, e.g. for the Posix standard regular expression matcher use the following API: ``` Pattern<PosixExtendedParser> pattern("^.*$"); auto result = pattern.match("Well, hello friends!\nHello World!"); // Match whole needle EXPECT(result.count == 1); EXPECT(result.matches.at(0).view.starts_with("Well")); EXPECT(result.matches.at(0).view.end() == "!"); result = pattern.match("Well, hello friends!\nHello World!", PosixFlags::Multiline); // Match line by line EXPECT(result.count == 2); EXPECT(result.matches.at(0).view == "Well, hello friends!"); EXPECT(result.matches.at(1).view == "Hello World!"); EXPECT(pattern.has_match("Well,....")); // Just check if match without a result, which saves some resources. ``` - AK: Rework regex to work with opcodes objects This patchsets reworks the matcher to work on a more structured base. For that an abstract OpCode class and derived classes for the specific OpCodes have been added. The respective opcode logic is contained in each respective execute() method. - AK: Add benchmark for regex - AK: Some optimization in regex for runtime and memory - LibRegex: Move regex to own Library and fix all the broken stuff Now regex works again and grep utility is also in place for testing. This commit also fixes the use of regex.h in C by making `regex_t` an opaque (-ish) type, which makes its behaviour consistent between C and C++ compilers. Previously, <regex.h> would've blown C compilers up, and even if it didn't, would've caused a leak in C code, and not in C++ code (due to the existence of `OwnPtr` inside the struct). To make this whole ordeal easier to deal with (for now), this pulls the definitions of `reg*()` into LibRegex. pros: - The circular dependency between LibC and LibRegex is broken - Eaiser to test (without accidentally pulling in the host's libc!) cons: - Using any of the regex.h functions will require the user to link -lregex - The symbols will be missing from libc, which will be a big surprise down the line (especially with shared libs). Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2020-04-26 15:45:10 +03:00
add_subdirectory(LibRegex)
LibAudio+LibRIFF: Move general RIFF handling to LibRIFF This splits the RIFFTypes header/TU into the WAV specific parts, which move to WavTypes.h, as well as the general RIFF parts which move to the new LibRIFF. Sidenote for the spec comments: even though they are linked from a site that explains the WAV format, the document is the (an) overall RIFF spec from Microsoft. A better source may be used later; the changes to the header are as minimal as possible.
2023-10-12 16:02:39 +03:00
add_subdirectory(LibRIFF)
Userland: Port UBSAN implementation to userspace Take Kernel/UBSanitizer.cpp and make a copy in LibSanitizer. We can use LibSanitizer to hold other sanitizers as people implement them :^). To enable UBSAN for LibC, DynamicLoader, and other low level system libraries, LibUBSanitizer is built as a serenity_libc, and has a static version for LibCStatic to use. The approach is the same as that taken in Note that this means now UBSAN is enabled for code generators, Lagom, Kernel, and Userspace with -DENABLE_UNDEFINED_SANTIZER=ON. In userspace however, UBSAN is not deadly (yet). Co-authored-by: ForLoveOfCats <ForLoveOfCats@vivaldi.net>
2021-05-24 04:40:22 +03:00
add_subdirectory(LibSanitizer)
Libraries: Implement SemVer for version parsing and comparisons Semantic Versioning (SemVer) is a versioning scheme for software that uses MAJOR.MINOR.PATCH format. MAJOR for significant, possibly breaking changes; MINOR for backward-compatible additions; PATCH for bug fixes. It aids communication, compatibility prediction, and dependency management. In apps dependent on specific library versions, SemVer guides parsing and validates compatibility, ensuring apps use appropriate dependencies. <valid semver> ::= <version core> | <version core> "-" <pre-release> | <version core> "+" <build> | <version core> "-" <pre-release> "+" <build>
2023-12-21 13:19:11 +03:00
add_subdirectory(LibSemVer)
LibGL+LibSoftGPU: Move rendering related code to LibSoftGPU library This introduces a new library, LibSoftGPU, that incorporates all rendering related features that formerly resided within LibGL itself. Going forward we will make both libraries completely independent from each other allowing LibGL to load different, possibly accelerated, rendering backends.
2021-12-16 22:32:38 +03:00
add_subdirectory(LibSoftGPU)
LibSQL: Introduce a SQL library with a tokenizer LibSQL aims to be a SQLite clone for SerenityOS. Step 1 is creating a tokenizer to lex SQL tokens. This lexer is heavily influenced by the LibJS lexer.
2021-04-19 00:35:40 +03:00
add_subdirectory(LibSQL)
Userland: Rename LibSymbolClient => LibSymbolication
2021-05-22 18:15:18 +03:00
add_subdirectory(LibSymbolication)
LibSyntax: Move GUI::Highlighter to Syntax::Highlighter in LibSyntax This is a move towards dropping more LibGUI dependencies.
2021-02-07 17:15:10 +03:00
add_subdirectory(LibSyntax)
Userland: Add LibSystem and funnel all syscalls through it This achieves two things: - Programs can now intentionally perform arbitrary syscalls by calling syscall(). This allows us to work on things like syscall fuzzing. - It restricts the ability of userspace to make syscalls to a single 4KB page of code. In order to call the kernel directly, an attacker must now locate this page and call through it.
2021-02-05 14:16:30 +03:00
add_subdirectory(LibSystem)
LibTest + test-js: Add initial skelaton of LibTest and migrate code there. The test-js reporter is arguably the nicest test runner / reporter that exists in the serenity code base. To the goal of leveling up all the other unit test environments, start a new LibTest library so that we can share code and reporting utilities to make all the test systems look and behave similarly.
2021-03-01 00:09:13 +03:00
add_subdirectory(LibTest)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibTextCodec)
Userland: Rename LibThread => LibThreading Also rename the "LibThread" namespace to "Threading"
2021-05-22 19:47:42 +03:00
add_subdirectory(LibThreading)
LibTimeZone+Meta: Add plumbing for an IANA Time Zone Database generator The IANA Time Zone Database contains data needed, at least, for various JavaScript objects. This adds plumbing for a parser and code generator for this data. The generated data will be made available by LibTimeZone, much like how UCD and CLDR data is available through LibUnicode.
2021-12-23 00:33:38 +03:00
add_subdirectory(LibTimeZone)
LibTTF: Reorganized TTF parsing code into LibTTF
2020-06-06 14:26:33 +03:00
add_subdirectory(LibTLS)
LibUnicode: Introduce a Unicode library for interacting with UCD files The Unicode standard publishes the Unicode Character Database (UCD) with information about every code point, such as each code point's upper case mapping. LibUnicode exists to download and parse UCD files at build time and to provide accessors to that data. As a start, LibUnicode includes upper- and lower-case code point converters.
2021-07-25 22:10:51 +03:00
add_subdirectory(LibUnicode)
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 06:22:27 +03:00
add_subdirectory(LibURL)
Userland/Libraries: Add LibUSBDB library Simple clone of LibPCIDB to support USB IDs instead of PCI ones. The format is basically identical, besides a few changes of the double tab fields.
2021-06-09 17:24:04 +03:00
add_subdirectory(LibUSBDB)
LibVideo: Scaffold LibVideo and implement simplistic Matroska parser This commit initializes the LibVideo library and implements parsing basic Matroska container files. Currently, it will only parse audio and video tracks.
2021-06-05 23:06:55 +03:00
add_subdirectory(LibVideo)
LibVirtGPU: Add a new GPU device that talks to our VirtIO-GPU driver At this moment this only contains function stubs.
2022-12-19 17:24:07 +03:00
add_subdirectory(LibVirtGPU)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibVT)
LibWasm: Start implementing a basic WebAssembly binary format parser This can currently parse a really simple module. Note that it cannot parse the DataCount section, and it's still missing almost all of the instructions. This commit also adds a 'wasm' test utility that tries to parse a given webassembly binary file. It currently does nothing but exit when the parse fails, but it's a start :^)
2021-04-26 11:18:13 +03:00
add_subdirectory(LibWasm)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibWeb)
LibWebSocket: Add a new websocket library This library currently contains a basic WebSocket client that can handle both standard TCP websockets and TLS websockets.
2021-04-17 18:20:24 +03:00
add_subdirectory(LibWebSocket)
LibWebView: Move OutOfProcessWebView to a new LibWebView library Also moves WebContentClient and the references to the generated IPC descriptions, since they are all components of OutOfProcessWebView. This patch has no functional changes.
2022-04-30 11:46:33 +03:00
add_subdirectory(LibWebView)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 18:40:06 +03:00
add_subdirectory(LibX86)
LibXML: Add a fairly basic XML parser Currently this can parse XML and resolve external resources/references, and read a DTD (but not apply or verify its rules). That's good enough for _most_ XHTML documents as the HTML 5 spec enforces its own rules about document well-formedness, and does not make use of XML DTDs (aside from a list of predefined entities). An accompanying `xml` utility is provided that can read and dump XML documents, and can also run the XML conformance test suite.
2022-03-26 20:02:57 +03:00
add_subdirectory(LibXML)
Reference in New Issue Copy Permalink