selectolax 0.3.16__tar.gz → 0.3.18__tar.gz

{selectolax-0.3.16 → selectolax-0.3.18}/CHANGES.rst

@@ -1,6 +1,23 @@
 selectolax Changelog
 ====================
 
+Version 0.3.15
+-------------
+
+Released
+
+- Fix memory leak when using CSS selectors, `lexbor` backend
+
+
+Version 0.3.17
+-------------
+
+Released
+
+- Update lexbor
+- Add Python 3.12 wheels
+
+
 Version 0.3.16
 -------------
 

{selectolax-0.3.16/selectolax.egg-info → selectolax-0.3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: selectolax
-Version: 0.3.16
+Version: 0.3.18
 Summary: Fast HTML5 parser with CSS selectors.
 Home-page: https://github.com/rushter/selectolax
 Author: Artem Golubin
@@ -21,8 +21,9 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Provides-Extra: cython
 License-File: LICENSE
+Provides-Extra: cython
+Requires-Dist: Cython==0.29.36; extra == "cython"
 
 .. image:: docs/logo.png
   :alt: selectolax logo

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/CHANGELOG.md

@@ -2,6 +2,32 @@
    
 ## [Unreleased]
 
+## [2.3.0] - 2023-08-17
+### Added
+- Added new module Unicode.
+- Added new module Punycode.
+- Added new module URL.
+- Added Unicode IDNA processing.
+- Added new tests.
+- Core: new functions for data conversations.
+- CSS: added initial properties.
+- CSS: added more than 70 new properties for parsing.
+- Encoding: added decode function for valid UTF-8.
+- Grammar: added new grammars for testing CSS properties.
+- Test: added fuzzer for CSS StyleSheet.
+
+### Fixed
+- Core: fixed test failure in Hash on 32-bit architectures. Thanks @nmeum.
+- CSS: fixed a couple of crashes related to lack of variable validation.
+- CSS: fixed use-after-poison for declarations.
+- CSS: fixed offset for token End-Of-File.
+- CSS: fixed Qualified Rule prelude offset.
+- Various Cppcheck report fixes.
+
+### Changed
+- CSS: renamed LXB_CSS_SYNTAX_TOKEN__TERMINATED to LXB_CSS_SYNTAX_TOKEN__END.
+- Removed deprecated function 'sprintf' for macOS.
+
 ## [2.2.0] - 2023-04-06
 ### Added
 - Added clone functions for DOM/HTML nodes.

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 2.8.12...3.27)
 
 
 # Options:
@@ -12,7 +12,7 @@ cmake_minimum_required(VERSION 2.8.12)
 #                                         Each module will have its own shared library
 #    LEXBOR_BUILD_EXAMPLES               default: OFF; Build all examples
 #    LEXBOR_BUILD_TESTS                  default: OFF; Build tests
-#    LEXBOR_BUILD_TESTS_CPP              default: ON; Build C++ tests.
+#    LEXBOR_BUILD_TESTS_CPP              default: OFF; Build C++ tests.
 #                                         Used with LEXBOR_BUILD_TESTS
 #    LEXBOR_BUILD_UTILS                  default: OFF; Build utils/helpers for project.
 #    LEXBOR_BUILD_WITH_ASAN              default: OFF; Build with address sanitizer if possible
@@ -47,7 +47,7 @@ option(LEXBOR_BUILD_STATIC "Build static library" ON)
 option(LEXBOR_BUILD_SEPARATELY "Build modules separately" OFF)
 option(LEXBOR_BUILD_EXAMPLES "Build examples" OFF)
 option(LEXBOR_BUILD_TESTS "Build tests" OFF)
-option(LEXBOR_BUILD_TESTS_CPP "Build C++ tests" ON)
+option(LEXBOR_BUILD_TESTS_CPP "Build C++ tests" OFF)
 option(LEXBOR_BUILD_UTILS "Build utils" OFF)
 option(LEXBOR_BUILD_WITH_ASAN "Build with address sanitizer" OFF)
 option(LEXBOR_BUILD_WITH_FUZZER "Build with fuzzer" OFF)
@@ -60,7 +60,10 @@ IF(NOT LEXBOR_MAKE_DISTRO_NUM)
 ENDIF()
 
 enable_language(C)
-enable_language(CXX)
+
+IF(LEXBOR_BUILD_TESTS_CPP)
+    enable_language(CXX)
+ENDIF()
 
 ################
 ## Version and path
@@ -117,10 +120,19 @@ GET_LEXBOR_VERSION(LEXBOR_VERSION_MAJOR LEXBOR_VERSION_MINOR
 message(STATUS "Lexbor version: ${LEXBOR_VERSION_STRING}")
 
 IF(CMAKE_VERSION VERSION_LESS "3.0")
-    PROJECT("${PROJECT_NAME}")
+    IF(LEXBOR_BUILD_TESTS_CPP)
+        PROJECT("${PROJECT_NAME}")
+    ELSE()
+        PROJECT("${PROJECT_NAME}" "C")
+    ENDIF()
 ELSE()
     cmake_policy(SET CMP0048 NEW)
-    PROJECT("${PROJECT_NAME}" VERSION "${LEXBOR_VERSION_STRING}")
+
+    IF(LEXBOR_BUILD_TESTS_CPP)
+        PROJECT("${PROJECT_NAME}" VERSION "${LEXBOR_VERSION_STRING}")
+    ELSE()
+        PROJECT("${PROJECT_NAME}" VERSION "${LEXBOR_VERSION_STRING}" LANGUAGES "C")
+    ENDIF()
 ENDIF()
 
 ################
@@ -279,6 +291,14 @@ ENDIF()
 
 FEATURE_CHECK_FUZZER(LEXBOR_HAVE_FUZZER)
 IF(${LEXBOR_HAVE_FUZZER})
+    set(LEXBOR_BUILD_EXAMPLES OFF)
+    set(LEXBOR_BUILD_UTILS OFF)
+
+    message(STATUS "Build only fuzzing test.")
+    message(STATUS "Set LEXBOR_BUILD_TESTS to OFF.")
+    message(STATUS "Set LEXBOR_BUILD_EXAMPLES to OFF.")
+    message(STATUS "Set LEXBOR_BUILD_UTILS to OFF.")
+
     add_definitions(-DLEXBOR_HAVE_FUZZER)
 ENDIF()
 

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/README.md

@@ -76,6 +76,10 @@ Binaries are available for:
 Currently for `x86_64` architecture.
 If you need any other architecture, please, write to [support@lexbor.com](mailto:support@lexbor.com).
 
+### vcpkg
+
+For vcpkg users there is a `lexbor` [port](https://github.com/microsoft/vcpkg/tree/master/ports/lexbor) that can be installed via `vcpkg install lexbor` or by adding it to `dependencies` section of your `vcpkg.json` file.
+
 ### macOS
 
 #### Homebrew

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/feature.cmake

@@ -86,49 +86,60 @@ int main(void) {
 ENDMACRO()
 
 MACRO(FEATURE_CHECK_FUZZER out_result)
-    set(lexbor_fuzzer_flags "-O0 -g -fsanitize=fuzzer")
+    IF(NOT LEXBOR_BUILD_WITH_FUZZER)
+        message(STATUS "Feature Fuzzer: disable")
+    ELSE()
+        set(lexbor_old_c_flags "${CMAKE_C_FLAGS}")
+        set(lexbor_old_cxx_flags "${CMAKE_CXX_FLAGS}")
+        set(lexbor_fuzzer_flags "-O0 -g -fsanitize=fuzzer")
+        set(feature_filename "${CMAKE_BINARY_DIR}/feature_check.c")
+
+        STRING(REGEX REPLACE " ?-O[0-9]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        STRING(REGEX REPLACE " ?-O[0-9]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-    IF(LEXBOR_BUILD_WITH_FUZZER)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${lexbor_fuzzer_flags}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${lexbor_fuzzer_flags}")
-    ENDIF()
 
-    set(feature_filename "${CMAKE_BINARY_DIR}/feature_check.c")
-
-    set(FEATUTE_CHECK_STRING "
+        set(FEATUTE_CHECK_STRING "
 #include <sanitizer/asan_interface.h>
 
 int
 LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
     return 0;
-}")
+}
+")
 
-    file(WRITE ${feature_filename} "${FEATUTE_CHECK_STRING}")
-
-    try_compile(${out_result} "${CMAKE_BINARY_DIR}" "${feature_filename}"
-        CMAKE_FLAGS "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}"
-    )
-
-    IF(${${out_result}})
-        message(STATUS "Feature Fuzzer: enabled")
-    ELSE()
-        message(STATUS "Feature Fuzzer: disable")
-    ENDIF()
+        file(WRITE ${feature_filename} "${FEATUTE_CHECK_STRING}")
 
-    file(REMOVE ${feature_filename})
+        try_compile(${out_result} "${CMAKE_BINARY_DIR}" "${feature_filename}"
+            CMAKE_FLAGS "${lexbor_fuzzer_flags}"
+            OUTPUT_VARIABLE OUTPUT
+        )
 
-    IF(LEXBOR_BUILD_WITH_FUZZER)
-        IF(NOT ${${out_result}})
-            STRING(REGEX REPLACE " ${lexbor_fuzzer_flags}" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
-            STRING(REGEX REPLACE " ${lexbor_fuzzer_flags}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-        ELSE()
+        IF(${out_result})
+            message(STATUS "Feature Fuzzer: enabled")
             message(STATUS "Updated CFLAGS: ${CMAKE_C_FLAGS}")
             message(STATUS "Updated CXXFLAGS: ${CMAKE_CXX_FLAGS}")
+
+            set(${out_result} TRUE)
+        ELSE()
+            set(CMAKE_C_FLAGS ${lexbor_old_c_flags})
+            set(CMAKE_CXX_FLAGS ${lexbor_old_cxx_flags})
+
+            message(STATUS "Feature Fuzzer: аn error was received at compilation.")
+            message(STATUS "Feature Fuzzer OUTPUT:")
+            message(FATAL_ERROR ${OUTPUT})
+
+            set(${out_result} FALSE)
         ENDIF()
-    ENDIF()
 
-    unset(lexbor_fuzzer_flags)
-    unset(FEATUTE_CHECK_STRING)
-    unset(feature_filename)
+        file(REMOVE ${feature_filename})
+
+        unset(lexbor_old_c_flags)
+        unset(lexbor_old_cxx_flags)
+        unset(lexbor_fuzzer_flags)
+        unset(FEATUTE_CHECK_STRING)
+        unset(feature_filename)
+    ENDIF()
 ENDMACRO()

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/core/array_obj.h

@@ -67,7 +67,7 @@ lexbor_array_obj_erase(lexbor_array_obj_t *array)
 }
 
 lxb_inline void *
-lexbor_array_obj_get(lexbor_array_obj_t *array, size_t idx)
+lexbor_array_obj_get(const lexbor_array_obj_t *array, size_t idx)
 {
     if (idx >= array->length) {
         return NULL;

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/core/base.h

@@ -66,6 +66,7 @@ typedef enum {
     LXB_STATUS_STOPPED,
     LXB_STATUS_NEXT,
     LXB_STATUS_STOP,
+    LXB_STATUS_WARNING
 }
 lexbor_status_t;
 
@@ -80,6 +81,10 @@ lexbor_action_t;
 typedef lxb_status_t
 (*lexbor_serialize_cb_f)(const lxb_char_t *data, size_t len, void *ctx);
 
+typedef lxb_status_t
+(*lexbor_serialize_cb_cp_f)(const lxb_codepoint_t *cps, size_t len, void *ctx);
+
+
 typedef struct {
     lexbor_serialize_cb_f cb;
     void                  *ctx;

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/core/bst.c

@@ -5,6 +5,7 @@
  */
 
 #include "lexbor/core/bst.h"
+#include "lexbor/core/conv.h"
 
 
 lexbor_bst_t *
@@ -413,8 +414,8 @@ void
 lexbor_bst_serialize_entry(lexbor_bst_entry_t *entry,
                            lexbor_callback_f callback, void *ctx, size_t tabs)
 {
-    size_t buff_len;
-    char buff[1024];
+    size_t len;
+    lxb_char_t buff[1024];
 
     if (entry == NULL) {
         return;
@@ -427,8 +428,9 @@ lexbor_bst_serialize_entry(lexbor_bst_entry_t *entry,
     callback((lxb_char_t *) "<left ", 6, ctx);
 
     if (entry->left) {
-        buff_len = sprintf(buff, LEXBOR_FORMAT_Z, entry->left->size);
-        callback((lxb_char_t *) buff, buff_len, ctx);
+        len = lexbor_conv_int64_to_data((int64_t) entry->left->size,
+                                        buff, sizeof(buff));
+        callback(buff, len, ctx);
 
         callback((lxb_char_t *) ">\n", 2, ctx);
         lexbor_bst_serialize_entry(entry->left, callback, ctx, (tabs + 1));
@@ -450,8 +452,9 @@ lexbor_bst_serialize_entry(lexbor_bst_entry_t *entry,
     callback((lxb_char_t *) "<right ", 7, ctx);
 
     if (entry->right) {
-        buff_len = sprintf(buff, LEXBOR_FORMAT_Z, entry->right->size);
-        callback((lxb_char_t *) buff, buff_len, ctx);
+        len = lexbor_conv_int64_to_data((int64_t) entry->right->size,
+                                        buff, sizeof(buff));
+        callback(buff, len, ctx);
 
         callback((lxb_char_t *) ">\n", 2, ctx);
         lexbor_bst_serialize_entry(entry->right, callback, ctx, (tabs + 1));

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/core/conv.c

@@ -21,7 +21,69 @@ lexbor_conv_float_to_data(double num, lxb_char_t *buf, size_t len)
 size_t
 lexbor_conv_long_to_data(long num, lxb_char_t *buf, size_t len)
 {
-    return lexbor_dtoa((double) num, buf, len);
+    return lexbor_conv_int64_to_data((int64_t) num, buf, len);
+}
+
+size_t
+lexbor_conv_int64_to_data(int64_t num, lxb_char_t *buf, size_t len)
+{
+    int64_t tmp;
+    size_t have_minus, i, length;
+
+    static const lxb_char_t *digits = (const lxb_char_t *) "0123456789";
+
+    if (num != 0) {
+        tmp = num;
+        length = 0;
+        have_minus = 0;
+
+        if (num < 0) {
+            length = 1;
+            num = -num;
+            have_minus = 1;
+        }
+
+        while (tmp != 0) {
+            length += 1;
+            tmp /= 10;
+        }
+
+        /* length += (size_t) floor(log10(labs((long) num))) + 1; */
+    }
+    else {
+        if (len > 0) {
+            buf[0] = '0';
+            return 1;
+        }
+
+        return 0;
+    }
+
+    if (len < length) {
+        i = (length + have_minus) - len;
+
+        while (i != have_minus) {
+            i -= 1;
+            num /= 10;
+        }
+
+        length = len;
+    }
+
+    if (have_minus) {
+        buf[0] = '-';
+    }
+
+    i = length;
+    buf[length] = '\0';
+
+    while (i != have_minus) {
+        i -= 1;
+        buf[i] = digits[ num % 10 ];
+        num /= 10;
+    }
+
+    return length;
 }
 
 double
@@ -47,8 +109,10 @@ lexbor_conv_data_to_double(const lxb_char_t **start, size_t len)
     switch (**start) {
         case '-':
             minus = true;
+            /* fall through */
         case '+':
             (*start)++;
+            /* fall through */
         default:
             break;
     }
@@ -183,8 +247,10 @@ lexbor_conv_data_to_long(const lxb_char_t **data, size_t length)
     switch (*p) {
         case '-':
             minus = true;
+            /* fall through */
         case '+':
             p++;
+            /* fall through */
         default:
             break;
     }
@@ -237,3 +303,44 @@ done:
 
     return number;
 }
+
+size_t
+lexbor_conv_dec_to_hex(uint32_t number, lxb_char_t *out, size_t length)
+{
+    lxb_char_t c;
+    size_t len;
+    uint32_t tmp;
+
+    static const lxb_char_t map_str[] = "0123456789abcdef";
+
+    if(number != 0) {
+        tmp = number;
+        len = 0;
+
+        while (tmp != 0) {
+            len += 1;
+            tmp /= 16;
+        }
+
+        /* len = (size_t) floor(log10(labs((long) number))) + 1; */
+    }
+    else {
+        if (length > 0) {
+            out[0] = '0';
+            return 1;
+        }
+
+        return 0;
+    }
+
+    length = len - 1;
+
+    while (number != 0) {
+        c = number % 16;
+        number = number / 16;
+
+        out[ length-- ] = map_str[c];
+    }
+
+    return len;
+}

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/core/conv.h

@@ -21,6 +21,9 @@ lexbor_conv_float_to_data(double num, lxb_char_t *buf, size_t len);
 LXB_API size_t
 lexbor_conv_long_to_data(long num, lxb_char_t *buf, size_t len);
 
+LXB_API size_t
+lexbor_conv_int64_to_data(int64_t num, lxb_char_t *buf, size_t len);
+
 LXB_API double
 lexbor_conv_data_to_double(const lxb_char_t **start, size_t len);
 
@@ -33,6 +36,8 @@ lexbor_conv_data_to_long(const lxb_char_t **data, size_t length);
 LXB_API unsigned
 lexbor_conv_data_to_uint(const lxb_char_t **data, size_t length);
 
+LXB_API size_t
+lexbor_conv_dec_to_hex(uint32_t number, lxb_char_t *out, size_t length);
 
 lxb_inline long
 lexbor_conv_double_to_long(double number)

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/core/str.c

@@ -35,6 +35,31 @@ lexbor_str_init(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t size)
     return str->data;
 }
 
+lxb_char_t *
+lexbor_str_init_append(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                       const lxb_char_t *data, size_t length)
+{
+    lxb_char_t *p;
+
+    if (str == NULL) {
+        return NULL;
+    }
+
+    p = lexbor_mraw_alloc(mraw, (length + 1));
+    if (p == NULL) {
+        return NULL;
+    }
+
+    memcpy(p, data, length);
+
+    p[length] = '\0';
+
+    str->data = p;
+    str->length = length;
+
+    return p;
+}
+
 void
 lexbor_str_clean(lexbor_str_t *str)
 {

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/core/str.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 Alexander Borisov
+ * Copyright (C) 2018-2023 Alexander Borisov
  *
  * Author: Alexander Borisov <borisov@lexbor.com>
  */
@@ -56,6 +56,10 @@ lexbor_str_create(void);
 LXB_API lxb_char_t *
 lexbor_str_init(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t size);
 
+LXB_API lxb_char_t *
+lexbor_str_init_append(lexbor_str_t *str, lexbor_mraw_t *mraw,
+                       const lxb_char_t *data, size_t length);
+
 LXB_API void
 lexbor_str_clean(lexbor_str_t *str);
 

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/css/at_rule/state.c

@@ -57,7 +57,7 @@ lxb_css_at_rule_state__custom(lxb_css_parser_t *parser,
     lxb_css_syntax_parser_consume(parser);
     token = lxb_css_syntax_parser_token(parser);
 
-    while (token != NULL && token->type != LXB_CSS_SYNTAX_TOKEN__TERMINATED) {
+    while (token != NULL && token->type != LXB_CSS_SYNTAX_TOKEN__END) {
         status = lxb_css_syntax_token_serialize_str(token, &custom->prelude,
                                                     parser->memory->mraw);
         if (status != LXB_STATUS_OK) {
@@ -88,7 +88,7 @@ lxb_css_property_state__custom_block(lxb_css_parser_t *parser,
         return lxb_css_parser_memory_fail(parser);
     }
 
-    while (token != NULL && token->type != LXB_CSS_SYNTAX_TOKEN__TERMINATED) {
+    while (token != NULL && token->type != LXB_CSS_SYNTAX_TOKEN__END) {
         status = lxb_css_syntax_token_serialize_str(token, &custom->block,
                                                     parser->memory->mraw);
         if (status != LXB_STATUS_OK) {

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/css/base.h

@@ -18,7 +18,7 @@ extern "C" {
 
 
 #define LXB_CSS_VERSION_MAJOR 1
-#define LXB_CSS_VERSION_MINOR 1
+#define LXB_CSS_VERSION_MINOR 2
 #define LXB_CSS_VERSION_PATCH 0
 
 #define LXB_CSS_VERSION_STRING                                                 \

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/css/declaration.c

@@ -290,7 +290,7 @@ lxb_css_declaration_list_bad(lxb_css_parser_t *parser,
     lxb_css_rule_declaration_t *declar = ctx;
     const lxb_css_syntax_declarations_offset_t *offset;
 
-    while (token != NULL && token->type != LXB_CSS_SYNTAX_TOKEN__TERMINATED) {
+    while (token != NULL && token->type != LXB_CSS_SYNTAX_TOKEN__END) {
         lxb_css_syntax_parser_consume(parser);
         token = lxb_css_syntax_parser_token(parser);
     }

{selectolax-0.3.16 → selectolax-0.3.18}/lexbor/source/lexbor/css/parser.c

@@ -156,25 +156,29 @@ lxb_css_parser_state_t *
 lxb_css_parser_states_push(lxb_css_parser_t *parser,
                            lxb_css_parser_state_f state, void *ctx, bool root)
 {
+    size_t length, cur_length;
     lxb_css_parser_state_t *states = ++parser->states;
 
     if (states >= parser->states_end) {
-        size_t length = parser->states_end - parser->states_begin;
-        size_t new_length = length + 1024;
+        cur_length = states - parser->states_begin;
 
-        if (SIZE_MAX - length < 1024) {
+        if (SIZE_MAX - cur_length < 1024) {
             goto memory_error;
         }
 
+        length = cur_length + 1024;
+
         states = lexbor_realloc(parser->states_begin,
-                                new_length * sizeof(lxb_css_parser_state_t));
+                                length * sizeof(lxb_css_parser_state_t));
         if (states == NULL) {
             goto memory_error;
         }
 
         parser->states_begin = states;
-        parser->states_end = states + new_length;
-        parser->states = states + length;
+        parser->states_end = states + length;
+        parser->states = states + cur_length;
+
+        states = parser->states;
     }
 
     states->state = state;