Lexbor

https://lexbor.com/documentation/
Admin
Lexbor is a fast and lightweight HTML parser library written in pure C with support for HTML...
Tokens:3,375
Snippets:35
Trust Score:7.7
Update:8 months ago
Show doc for...
Tokens:
Raw
### Build Lexbor Examples

Source: https://lexbor.com/documentation/index

Instructions to build the example programs provided with the lexbor library using CMake and Make. This enables the `LEXBOR_BUILD_EXAMPLES` flag during the CMake configuration step.

```bash
mkdir build
cd build
cmake .. -DLEXBOR_BUILD_EXAMPLES=ON
make
./examples/lexbor/html/element_create
./examples/lexbor/html/document_title

```

--------------------------------

### Build Lexbor with Tests and Custom Install Prefix

Source: https://lexbor.com/documentation/index

This command shows how to configure lexbor to build with tests and specify a custom installation directory using CMake. It then proceeds with building and installing the library.

```bash
mkdir build
cd build
cmake .. -DLEXBOR_BUILD_TESTS=ON
make
make test
sudo make install

```

--------------------------------

### Lexbor Header Inclusion Example (C)

Source: https://lexbor.com/documentation/index

Shows how to include header files from different modules within the Lexbor project, using paths relative to the `/source/` directory.

```c
#include "lexbor/html/tree.h"

```

--------------------------------

### Build Lexbor from Source on Linux/BSD/macOS

Source: https://lexbor.com/documentation/index

Instructions for building and installing the lexbor library from its source code on Linux, *BSD, and macOS systems using CMake and Make. This process involves configuring the build, compiling the library, and installing it.

```bash
cmake .
make
sudo make install

```

--------------------------------

### Lexbor AVL Tree Creation and Initialization Example (C)

Source: https://lexbor.com/documentation/index

Demonstrates the typical usage of Lexbor's AVL tree API, including creation, initialization, error handling, and destruction for heap-allocated objects.

```c
lexbor_avl_t *avl = lexbor_avl_create();
lxb_status_t status = lexbor_avl_init(avl, 1024);

if (status != LXB_STATUS_OK) {
    lexbor_avl_node_destroy(avl, true);

    exit(EXIT_FAILURE);
}

/* Do something super useful */

lexbor_avl_node_destroy(avl, true);

```

--------------------------------

### Install Lexbor Shared Library Only

Source: https://lexbor.com/documentation/index

This command configures and builds lexbor to install only the shared library, excluding static libraries and headers. It uses CMake to set build options before compiling and installing.

```bash
mkdir build
cd build
cmake .. -DLEXBOR_BUILD_STATIC=OFF -DLEXBOR_INSTALL_HEADERS=OFF
make
sudo make install

```

--------------------------------

### Lexbor Module Version Definition Example (C)

Source: https://lexbor.com/documentation/index

Shows the standard way Lexbor modules define their version numbers using preprocessor macros, facilitating version tracking and compatibility checks.

```c
#define <MODULE-NAME>_VERSION_MAJOR 1
#define <MODULE-NAME>_VERSION_MINOR 0
#define <MODULE-NAME>_VERSION_PATCH 3

#define <MODULE-NAME>_VERSION_STRING LXB_STR(<MODULE-NAME>_VERSION_MAJOR) LXB_STR(.) \
                                     LXB_STR(<MODULE-NAME>_VERSION_MINOR) LXB_STR(.) \
                                     LXB_STR(<MODULE-NAME>_VERSION_PATCH)

```

--------------------------------

### Lexbor AVL Tree Initialization Example with Stack Object (C)

Source: https://lexbor.com/documentation/index

Illustrates initializing an AVL tree using a stack-allocated object, including proper cleanup and error handling.

```c
lexbor_avl_t avl = {0};
lxb_status_t status = lexbor_avl_init(&avl, 1024);

if (status != LXB_STATUS_OK) {
    lexbor_avl_node_destroy(&avl, false);

    exit(EXIT_FAILURE);
}

/* Do something even more useful */

lexbor_avl_node_destroy(&avl, false);

```

--------------------------------

### Lexbor Free Function Usage Example (C)

Source: https://lexbor.com/documentation/index

Demonstrates the simplified usage of `lexbor_free` to nullify pointers after freeing memory, preventing dangling pointers and simplifying code.

```c
if (object->table != NULL) {
    object->table = lexbor_free(object->table);
}

```

--------------------------------

### Standard Free Function Usage Example (C)

Source: https://lexbor.com/documentation/index

Illustrates the traditional method of freeing memory and explicitly nullifying the pointer, which is more verbose than using `lexbor_free`.

```c
if (object->table != NULL) {
    lexbor_free(object->table);
    object->table = NULL;
}

```

--------------------------------

### Compile and Run C Code with Lexbor

Source: https://lexbor.com/documentation/index

This command sequence shows how to compile a C file (`myhtml.c`) that uses the lexbor library and then run the resulting executable. It assumes the lexbor library is installed on the system and available for linking.

```bash
gcc myhtml.c -llexbor -o myhtml
./myhtml

```

--------------------------------

### Build Lexbor from Source on Windows with MSYS2

Source: https://lexbor.com/documentation/index

This command sequence outlines the process for building and installing the lexbor library from source on Windows using MSYS2 and CMake. It specifies the 'Unix Makefiles' generator for CMake.

```bash
cmake . -G "Unix Makefiles"
make
make install

```

--------------------------------

### Build Lexbor with Debug and Address Sanitizer

Source: https://lexbor.com/documentation/index

This command demonstrates how to configure and build the lexbor library with debugging symbols and the Address Sanitizer enabled, along with tests and examples. It uses CMake with specific flags for C flags, optimization level, and build targets.

```bash
mkdir build
cd build
cmake .. -DCMAKE_C_FLAGS="-fsanitize=address -g" -DLEXBOR_OPTIMIZATION_LEVEL="-O0" -DLEXBOR_BUILD_TESTS=ON -DLEXBOR_BUILD_EXAMPLES=ON
make
make test

```

--------------------------------

### Parse HTML Markup with Lexbor C

Source: https://lexbor.com/documentation/index

This C code snippet demonstrates how to parse a simple HTML string using the lexbor library. It includes creating an HTML document, parsing the content, retrieving the body tag name, and cleaning up resources. Ensure the lexbor library is installed and linked during compilation.

```c
#include <lexbor/html/parser.h>
#include <lexbor/dom/interfaces/element.h>

int
main(int argc, const char *argv[])
{
    lxb_status_t status;
    const lxb_char_t *tag_name;
    lxb_html_document_t *document;

    static const lxb_char_t html[] = "<div>Works fine!</div>";
    size_t html_len = sizeof(html) - 1;

    document = lxb_html_document_create();
    if (document == NULL) {
        exit(EXIT_FAILURE);
    }

    status = lxb_html_document_parse(document, html, html_len);
    if (status != LXB_STATUS_OK) {
        exit(EXIT_FAILURE);
    }

    tag_name = lxb_dom_element_qualified_name(lxb_dom_interface_element(document->body),
                                              NULL);

    printf("Element tag name: %s\n", tag_name);

    lxb_html_document_destroy(document);

    return EXIT_SUCCESS;
}

```

--------------------------------

### Lexbor Data Structure Lifecycle API (C)

Source: https://lexbor.com/documentation/index

Defines the common API pattern for creating, initializing, cleaning, and destroying data structures in Lexbor, ensuring proper resource management.

```c
<structure-name> *
<function-prefix>_create(void);

lxb_status_t
<function-name>_init(<structure-name> *obj);

void
<function-name>_clean(<structure-name> *obj);

void
<function-name>_erase(<structure-name> *obj);

<structure-name> *
<function-name>_destroy(<structure-name> *obj, bool self_destroy);

```

--------------------------------

### Lexbor Memory Management Functions (C)

Source: https://lexbor.com/documentation/index

Provides C functions for dynamic memory allocation and deallocation, serving as replacements for standard library functions. The `lexbor_free` function nullifies the pointer after freeing memory.

```c
void *lexbor_malloc(size_t size);

void *lexbor_calloc(size_t num, size_t size);

void *lexbor_realloc(void *dst, size_t size);

void *lexbor_free(void *dst);

```
Tokens:
Raw