nokolexbor 0.2.0

data/vendor/lexbor/source/lexbor/ports/posix/lexbor/core/perf.c

@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/perf.h"
+
+
+#ifdef LEXBOR_WITH_PERF
+
+#ifdef LEXBOR_OS_DARWIN
+    #include <sys/sysctl.h>
+#elif LEXBOR_OS_LINUX
+#endif
+
+
+static unsigned long long
+lexbor_perf_clock(void);
+
+static unsigned long long
+lexbor_perf_frequency(void);
+
+
+typedef struct lexbor_perf {
+    unsigned long long start;
+    unsigned long long end;
+    unsigned long long freq;
+}
+lexbor_perf_t;
+
+
+void *
+lexbor_perf_create(void)
+{
+    lexbor_perf_t *perf = lexbor_calloc(1, sizeof(lexbor_perf_t));
+    if (perf == NULL) {
+        return NULL;
+    }
+
+    perf->freq = lexbor_perf_frequency();
+
+    return perf;
+}
+
+void
+lexbor_perf_clean(void *perf)
+{
+    memset(perf, 0, sizeof(lexbor_perf_t));
+}
+
+void
+lexbor_perf_destroy(void *perf)
+{
+    if (perf != NULL) {
+        lexbor_free(perf);
+    }
+}
+
+lxb_status_t
+lexbor_perf_begin(void *perf)
+{
+    ((lexbor_perf_t *) (perf))->start = lexbor_perf_clock();
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lexbor_perf_end(void *perf)
+{
+    ((lexbor_perf_t *) (perf))->end = lexbor_perf_clock();
+
+    return LXB_STATUS_OK;
+}
+
+double
+lexbor_perf_in_sec(void *perf)
+{
+    lexbor_perf_t *obj_perf = (lexbor_perf_t *) perf;
+
+    if (obj_perf->freq != 0) {
+        return ((double) (obj_perf->end - obj_perf->start)
+                / (double)obj_perf->freq);
+    }
+
+    return 0.0f;
+}
+
+static unsigned long long
+lexbor_perf_clock(void)
+{
+    unsigned long long x;
+
+     /*
+      * cpuid serializes any out-of-order prefetches
+      * before executing rdtsc (clobbers ebx, ecx, edx).
+      */
+    __asm__ volatile (
+                      "cpuid\n\t"
+                      "rdtsc\n\t"
+                      "shl $32, %%rdx\n\t"
+                      "or %%rdx, %%rax"
+                      : "=a" (x)
+                      :
+                      : "rdx", "ebx", "ecx");
+
+    return x;
+}
+
+static unsigned long long
+lexbor_perf_frequency(void)
+{
+    unsigned long long freq = 0;
+
+#if defined(LEXBOR_OS_DARWIN) && defined(CTL_HW) && defined(HW_CPU_FREQ)
+
+    /* OSX kernel: sysctl(CTL_HW | HW_CPU_FREQ) */
+    size_t len = sizeof(freq);
+    int mib[2] = {CTL_HW, HW_CPU_FREQ};
+
+    if(sysctl(mib, 2, &freq, &len, NULL, 0)) {
+        return 0;
+    }
+
+    return freq;
+
+#elif defined(LEXBOR_OS_LINUX)
+
+    char buf[1024] = {0};
+    double fval = 0.0;
+
+    /* Use procfs on linux */
+    FILE* fp = fopen("/proc/cpuinfo", "r");
+    if (fp == NULL) {
+        return 0;
+    }
+
+    /* Find 'CPU MHz :' */
+    while (fgets(buf, sizeof(buf), fp) != NULL) {
+        if (sscanf(buf, "cpu MHz : %lf\n", &fval) == 1) {
+            freq = (unsigned long long)(fval * 1000000ull);
+
+            break;
+        }
+    }
+
+    fclose(fp);
+
+    return freq;
+
+#else
+
+    return freq;
+
+#endif /* LEXBOR_OS_DARWIN || LEXBOR_OS_LINUX */
+}
+
+#endif /* LEXBOR_WITH_PERF */

data/vendor/lexbor/source/lexbor/ports/windows_nt/config.cmake

@@ -0,0 +1,18 @@
+if("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+    if(NOT DEFINED LEXBOR_OPTIMIZATION_LEVEL)
+        set(LEXBOR_OPTIMIZATION_LEVEL "/O2")
+    endif()
+
+    add_definitions(/wd4100 /wd4255 /wd4820 /wd4668)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+else()
+    if(NOT DEFINED LEXBOR_OPTIMIZATION_LEVEL)
+        set(LEXBOR_OPTIMIZATION_LEVEL "-O2")
+    endif()
+
+    if(NOT DEFINED LEXBOR_C_FLAGS)
+        set(LEXBOR_C_FLAGS "-Wall -pedantic -pipe -std=c99")
+    endif()
+endif()
+
+message(STATUS "Set Windows definitions")

data/vendor/lexbor/source/lexbor/ports/windows_nt/lexbor/core/fs.c

@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Vincent Torri <vincent.torri@gmail.com>
+ */
+
+#ifndef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE
+#endif
+
+
+#include <string.h>
+#include <sys/stat.h>
+
+#include <windows.h>
+
+#include "lexbor/core/fs.h"
+
+
+lxb_status_t
+lexbor_fs_dir_read(const lxb_char_t *dirpath, lexbor_fs_dir_opt_t opt,
+                   lexbor_fs_dir_file_f callback, void *ctx)
+{
+    WIN32_FIND_DATA data;
+    HANDLE h;
+    size_t path_len, free_len, d_namlen;
+    lexbor_action_t action;
+    lexbor_fs_file_type_t f_type;
+
+    char *file_begin;
+    char full_path[4096];
+
+    path_len = strlen((const char *) dirpath);
+    if (path_len == 0 || path_len >= (sizeof(full_path) - 1)) {
+        return LXB_STATUS_ERROR;
+    }
+
+    memcpy(full_path, dirpath, path_len);
+
+    /* Check for a separating character at the end dirpath */
+    if (full_path[(path_len - 1)] != '/') {
+        path_len++;
+
+        if (path_len >= (sizeof(full_path) - 1)) {
+            return LXB_STATUS_ERROR;
+        }
+
+        full_path[(path_len - 1)] = '/';
+    }
+
+    file_begin = &full_path[path_len];
+    free_len = (sizeof(full_path) - 1) - path_len;
+
+    if (opt == LEXBOR_FS_DIR_OPT_UNDEF)
+    {
+        h = FindFirstFile((LPCSTR)dirpath, &data);
+        if (h == INVALID_HANDLE_VALUE) {
+            return LXB_STATUS_ERROR;
+        }
+
+        do {
+            if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_HIDDEN
+                && *data.cFileName == '.')
+            {
+                continue;
+            }
+
+            d_namlen = strlen(data.cFileName);
+
+            if (d_namlen >= free_len) {
+                goto error;
+            }
+
+            /* +1 copy terminating null byte '\0' */
+            memcpy(file_begin, data.cFileName, (d_namlen + 1));
+
+            action = callback((const lxb_char_t *) full_path,
+                              (path_len + d_namlen),
+                              (const lxb_char_t *) data.cFileName,
+                              d_namlen, ctx);
+            if (action == LEXBOR_ACTION_STOP) {
+                break;
+            }
+        }
+        while (FindNextFile(h, &data));
+
+        goto done;
+    }
+
+    h = FindFirstFile((LPCSTR)dirpath, &data);
+    if (h == INVALID_HANDLE_VALUE) {
+        return LXB_STATUS_ERROR;
+    }
+
+    do {
+        if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_HIDDEN
+            && *data.cFileName == '.') {
+            continue;
+        }
+
+        d_namlen = strlen(data.cFileName);
+
+        if (d_namlen >= free_len) {
+            goto error;
+        }
+
+        if ((data.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_NORMAL)) != 0) {
+            f_type = lexbor_fs_file_type((const lxb_char_t *) data.cFileName);
+
+            if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_DIR
+                && f_type == LEXBOR_FS_FILE_TYPE_DIRECTORY) {
+                continue;
+            }
+
+            if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_FILE
+                && f_type == LEXBOR_FS_FILE_TYPE_FILE)
+            {
+                continue;
+            }
+        }
+        else {
+            if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_DIR
+                && (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
+            {
+                continue;
+            }
+
+            if (opt & LEXBOR_FS_DIR_OPT_WITHOUT_FILE
+                && (data.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) == FILE_ATTRIBUTE_NORMAL)
+            {
+                continue;
+            }
+        }
+
+        /* +1 copy terminating null byte '\0' */
+        memcpy(file_begin, data.cFileName, (d_namlen + 1));
+
+        action = callback((const lxb_char_t *) full_path,
+                          (path_len + d_namlen),
+                          (const lxb_char_t *) data.cFileName,
+                          d_namlen, ctx);
+        if (action == LEXBOR_ACTION_STOP) {
+            break;
+        }
+    }
+    while (FindNextFile(h, &data));
+
+done:
+
+    FindClose(h);
+
+    return LXB_STATUS_OK;
+
+error:
+
+    FindClose(h);
+
+    return LXB_STATUS_ERROR;
+}
+
+lexbor_fs_file_type_t
+lexbor_fs_file_type(const lxb_char_t *full_path)
+{
+    struct stat sb;
+
+    if (stat((const char *) full_path, &sb) == -1) {
+        return LEXBOR_FS_FILE_TYPE_UNDEF;
+    }
+
+    switch (sb.st_mode & S_IFMT) {
+        case S_IFCHR:
+            return LEXBOR_FS_FILE_TYPE_CHARACTER_DEVICE;
+
+        case S_IFDIR:
+            return LEXBOR_FS_FILE_TYPE_DIRECTORY;
+
+        case S_IFREG:
+            return LEXBOR_FS_FILE_TYPE_FILE;
+
+        default:
+            return LEXBOR_FS_FILE_TYPE_UNDEF;
+    }
+
+    return LEXBOR_FS_FILE_TYPE_UNDEF;
+}
+
+lxb_char_t *
+lexbor_fs_file_easy_read(const lxb_char_t *full_path, size_t *len)
+{
+    LARGE_INTEGER size;
+    HANDLE fh;
+    char *data;
+    DWORD nread = 0;
+
+    fh = CreateFile((LPCSTR)full_path, GENERIC_READ, FILE_SHARE_READ,
+                    NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (fh == INVALID_HANDLE_VALUE) {
+        goto error;
+    }
+
+    if (GetFileSizeEx(fh, &size) == FALSE) {
+        goto error_close;
+    }
+
+    data = lexbor_malloc(size.QuadPart + 1);
+    if (data == NULL) {
+        goto error_close;
+    }
+
+    if (ReadFile(fh, data, (DWORD) size.QuadPart, &nread, NULL) != TRUE) {
+        goto error_close;
+    }
+
+    CloseHandle(fh);
+
+    if ((LONGLONG) nread != size.QuadPart) {
+            goto error;
+    }
+
+    if (len != NULL) {
+        *len = (size_t)size.QuadPart;
+    }
+
+    data[size.QuadPart] = '\0';
+
+    return (lxb_char_t *)data;
+
+error_close:
+
+    CloseHandle(fh);
+
+error:
+
+    if (len != NULL) {
+        *len = 0;
+    }
+
+    return NULL;
+}

data/vendor/lexbor/source/lexbor/ports/windows_nt/lexbor/core/memory.c

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#include "lexbor/core/base.h"
+
+
+void *
+lexbor_malloc(size_t size)
+{
+    return malloc(size);
+}
+
+void *
+lexbor_realloc(void *dst, size_t size)
+{
+    return realloc(dst, size);
+}
+
+void *
+lexbor_calloc(size_t num, size_t size)
+{
+    return calloc(num, size);
+}
+
+void *
+lexbor_free(void *dst)
+{
+    free(dst);
+    return NULL;
+}

data/vendor/lexbor/source/lexbor/ports/windows_nt/lexbor/core/perf.c

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2018 Alexander Borisov
+ *
+ * Author: Vincent Torri <vincent.torri@gmail.com>
+ */
+
+#include "lexbor/core/perf.h"
+
+#include <windows.h>
+
+
+typedef struct lexbor_perf {
+    LARGE_INTEGER start;
+    LARGE_INTEGER end;
+    LARGE_INTEGER freq;
+}
+lexbor_perf_t;
+
+
+void *
+lexbor_perf_create(void)
+{
+    lexbor_perf_t *perf = lexbor_calloc(1, sizeof(lexbor_perf_t));
+    if (perf == NULL) {
+        return NULL;
+    }
+
+    /*
+     * According to MSDN, QueryPerformanceFrequency() never fails
+     * on Windows XP or later
+     */
+    QueryPerformanceFrequency(&perf->freq);
+    return perf;
+}
+
+void
+lexbor_perf_clean(void *perf)
+{
+    memset(perf, 0, sizeof(lexbor_perf_t));
+}
+
+void
+lexbor_perf_destroy(void *perf)
+{
+    if (perf != NULL) {
+        lexbor_free(perf);
+    }
+}
+
+lxb_status_t
+lexbor_perf_begin(void *perf)
+{
+    /*
+     * According to MSDN, QueryPerformanceCounter() never fails
+     * on Windows XP or later
+     */
+    QueryPerformanceCounter(&(((lexbor_perf_t *) (perf))->start));
+
+    return LXB_STATUS_OK;
+}
+
+lxb_status_t
+lexbor_perf_end(void *perf)
+{
+    /*
+     * According to MSDN, QueryPerformanceCounter() never fails
+     * on Windows XP or later
+     */
+    QueryPerformanceCounter(&(((lexbor_perf_t *) (perf))->end));
+
+    return LXB_STATUS_OK;
+}
+
+double
+lexbor_perf_in_sec(void *perf)
+{
+    lexbor_perf_t *obj_perf = (lexbor_perf_t *) perf;
+
+    return ((double) (obj_perf->end.QuadPart - obj_perf->start.QuadPart)
+            / (double)obj_perf->freq.QuadPart);
+}

data/vendor/lexbor/source/lexbor/selectors/base.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2021 Alexander Borisov
+ *
+ * Author: Alexander Borisov <borisov@lexbor.com>
+ */
+
+#ifndef LEXBOR_SELECTORS_BASE_H
+#define LEXBOR_SELECTORS_BASE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lexbor/core/base.h"
+
+
+#define LXB_SELECTORS_VERSION_MAJOR 0
+#define LXB_SELECTORS_VERSION_MINOR 1
+#define LXB_SELECTORS_VERSION_PATCH 0
+
+#define LXB_SELECTORS_VERSION_STRING LEXBOR_STRINGIZE(LXB_SELECTORS_VERSION_MAJOR) "."   \
+                                     LEXBOR_STRINGIZE(LXB_SELECTORS_VERSION_MINOR) "."   \
+                                     LEXBOR_STRINGIZE(LXB_SELECTORS_VERSION_PATCH)
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LEXBOR_SELECTORS_BASE_H */

data/vendor/lexbor/source/lexbor/selectors/config.cmake

@@ -0,0 +1,2 @@
+set(DEPENDENCIES "core dom css tag ns")
+set(DESCRIPTION "Module for finding nodes in the DOM by Selectors.")