archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-16 05:58:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

[RFC] DOM HTML5 parsing and serialization support (Lexbor library part) (#12493)

Browse source 
* Update meta files

* Add (patched) Lexbor v2.4.0

* Add (already-applied) Lexbor patches

* Add linguist-vendored flag for Lexbor
This commit is contained in:
Niels Dossche 2023-10-22 16:26:21 +01:00 • committed by GitHub
parent 98b08c52db
commit f093409052
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
393 changed files with 274142 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

3
.gitattributes vendored
View file

@ -27,3 +27,6 @@
# The OSS fuzz files are binary
/ext/date/tests/ossfuzz*.txt binary
# Vendored libraries
/ext/dom/lexbor/lexbor linguist-vendored

1
.gitignore vendored
View file

@ -295,5 +295,6 @@ tmp-php.ini
!/ext/fileinfo/libmagic/config.h
!/ext/fileinfo/libmagic.patch
!/ext/fileinfo/magicdata.patch
!/ext/dom/lexbor/patches/*.patch
!/ext/pcre/pcre2lib/config.h
!/win32/build/Makefile

1
README.REDIST.BINS
View file

@ -17,6 +17,7 @@
17. ext/mbstring/ucgendat portions based on the ucgendat.c from the OpenLDAP
18. avifinfo (ext/standard/libavifinfo) see ext/standard/libavifinfo/LICENSE
19. xxHash (ext/hash/xxhash)
20. Lexbor (ext/dom/lexbor/lexbor) see ext/dom/lexbor/LICENSE
3. pcre2lib (ext/pcre)

2
codecov.yml Normal file
View file

@ -0,0 +1,2 @@
ignore:
- "ext/dom/lexbor/lexbor" # bundled library

177
ext/dom/lexbor/LICENSE Normal file
View file

@ -0,0 +1,177 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS

16
ext/dom/lexbor/NOTICE Normal file
View file

@ -0,0 +1,16 @@
Lexbor.
Copyright 2018-2020 Alexander Borisov
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

208
ext/dom/lexbor/lexbor/core/array.c Executable file
View file

@ -0,0 +1,208 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/array.h"
lexbor_array_t *
lexbor_array_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_array_t));
}
lxb_status_t
lexbor_array_init(lexbor_array_t *array, size_t size)
{
if (array == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (size == 0) {
return LXB_STATUS_ERROR_TOO_SMALL_SIZE;
}
array->length = 0;
array->size = size;
array->list = lexbor_malloc(sizeof(void *) * size);
if (array->list == NULL) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
return LXB_STATUS_OK;
}
void
lexbor_array_clean(lexbor_array_t *array)
{
if (array != NULL) {
array->length = 0;
}
}
lexbor_array_t *
lexbor_array_destroy(lexbor_array_t *array, bool self_destroy)
{
if (array == NULL)
return NULL;
if (array->list) {
array->length = 0;
array->size = 0;
array->list = lexbor_free(array->list);
}
if (self_destroy) {
return lexbor_free(array);
}
return array;
}
void **
lexbor_array_expand(lexbor_array_t *array, size_t up_to)
{
void **list;
size_t new_size;
if (array->length > (SIZE_MAX - up_to))
return NULL;
new_size = array->length + up_to;
list = lexbor_realloc(array->list, sizeof(void *) * new_size);
if (list == NULL)
return NULL;
array->list = list;
array->size = new_size;
return list;
}
lxb_status_t
lexbor_array_push(lexbor_array_t *array, void *value)
{
if (array->length >= array->size) {
if ((lexbor_array_expand(array, 128) == NULL)) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
}
array->list[ array->length ] = value;
array->length++;
return LXB_STATUS_OK;
}
void *
lexbor_array_pop(lexbor_array_t *array)
{
if (array->length == 0) {
return NULL;
}
array->length--;
return array->list[ array->length ];
}
lxb_status_t
lexbor_array_insert(lexbor_array_t *array, size_t idx, void *value)
{
if (idx >= array->length) {
size_t up_to = (idx - array->length) + 1;
if (idx >= array->size) {
if ((lexbor_array_expand(array, up_to) == NULL)) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
}
memset(&array->list[array->length], 0, sizeof(void *) * up_to);
array->list[ idx ] = value;
array->length += up_to;
return LXB_STATUS_OK;
}
if (array->length >= array->size) {
if ((lexbor_array_expand(array, 32) == NULL)) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
}
memmove(&array->list[idx + 1], &array->list[idx],
sizeof(void *) * (array->length - idx));
array->list[ idx ] = value;
array->length++;
return LXB_STATUS_OK;
}
lxb_status_t
lexbor_array_set(lexbor_array_t *array, size_t idx, void *value)
{
if (idx >= array->length) {
size_t up_to = (idx - array->length) + 1;
if (idx >= array->size) {
if ((lexbor_array_expand(array, up_to) == NULL)) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
}
memset(&array->list[array->length], 0, sizeof(void *) * up_to);
array->length += up_to;
}
array->list[idx] = value;
return LXB_STATUS_OK;
}
void
lexbor_array_delete(lexbor_array_t *array, size_t begin, size_t length)
{
if (begin >= array->length || length == 0) {
return;
}
size_t end_len = begin + length;
if (end_len >= array->length) {
array->length = begin;
return;
}
memmove(&array->list[begin], &array->list[end_len],
sizeof(void *) * (array->length - end_len));
array->length -= length;
}
/*
* No inline functions.
*/
void *
lexbor_array_get_noi(lexbor_array_t *array, size_t idx)
{
return lexbor_array_get(array, idx);
}
size_t
lexbor_array_length_noi(lexbor_array_t *array)
{
return lexbor_array_length(array);
}
size_t
lexbor_array_size_noi(lexbor_array_t *array)
{
return lexbor_array_size(array);
}

100
ext/dom/lexbor/lexbor/core/array.h Executable file
View file

@ -0,0 +1,100 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_ARRAY_H
#define LEXBOR_ARRAY_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
typedef struct {
void **list;
size_t size;
size_t length;
}
lexbor_array_t;
LXB_API lexbor_array_t *
lexbor_array_create(void);
LXB_API lxb_status_t
lexbor_array_init(lexbor_array_t *array, size_t size);
LXB_API void
lexbor_array_clean(lexbor_array_t *array);
LXB_API lexbor_array_t *
lexbor_array_destroy(lexbor_array_t *array, bool self_destroy);
LXB_API void **
lexbor_array_expand(lexbor_array_t *array, size_t up_to);
LXB_API lxb_status_t
lexbor_array_push(lexbor_array_t *array, void *value);
LXB_API void *
lexbor_array_pop(lexbor_array_t *array);
LXB_API lxb_status_t
lexbor_array_insert(lexbor_array_t *array, size_t idx, void *value);
LXB_API lxb_status_t
lexbor_array_set(lexbor_array_t *array, size_t idx, void *value);
LXB_API void
lexbor_array_delete(lexbor_array_t *array, size_t begin, size_t length);
/*
* Inline functions
*/
lxb_inline void *
lexbor_array_get(lexbor_array_t *array, size_t idx)
{
if (idx >= array->length) {
return NULL;
}
return array->list[idx];
}
lxb_inline size_t
lexbor_array_length(lexbor_array_t *array)
{
return array->length;
}
lxb_inline size_t
lexbor_array_size(lexbor_array_t *array)
{
return array->size;
}
/*
* No inline functions for ABI.
*/
LXB_API void *
lexbor_array_get_noi(lexbor_array_t *array, size_t idx);
LXB_API size_t
lexbor_array_length_noi(lexbor_array_t *array);
LXB_API size_t
lexbor_array_size_noi(lexbor_array_t *array);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_ARRAY_H */

216
ext/dom/lexbor/lexbor/core/array_obj.c Executable file
View file

@ -0,0 +1,216 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/array_obj.h"
lexbor_array_obj_t *
lexbor_array_obj_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_array_obj_t));
}
lxb_status_t
lexbor_array_obj_init(lexbor_array_obj_t *array,
size_t size, size_t struct_size)
{
if (array == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (size == 0 || struct_size == 0) {
return LXB_STATUS_ERROR_TOO_SMALL_SIZE;
}
array->length = 0;
array->size = size;
array->struct_size = struct_size;
array->list = lexbor_malloc(sizeof(uint8_t *)
* (array->size * struct_size));
if (array->list == NULL) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
return LXB_STATUS_OK;
}
void
lexbor_array_obj_clean(lexbor_array_obj_t *array)
{
if (array != NULL) {
array->length = 0;
}
}
lexbor_array_obj_t *
lexbor_array_obj_destroy(lexbor_array_obj_t *array, bool self_destroy)
{
if (array == NULL)
return NULL;
if (array->list) {
array->length = 0;
array->size = 0;
array->list = lexbor_free(array->list);
}
if (self_destroy) {
return lexbor_free(array);
}
return array;
}
uint8_t *
lexbor_array_obj_expand(lexbor_array_obj_t *array, size_t up_to)
{
uint8_t *list;
size_t new_size;
if (array->length > (SIZE_MAX - up_to)) {
return NULL;
}
new_size = array->length + up_to;
list = lexbor_realloc(array->list, sizeof(uint8_t *)
* (new_size * array->struct_size));
if (list == NULL) {
return NULL;
}
array->list = list;
array->size = new_size;
return list;
}
void *
lexbor_array_obj_push(lexbor_array_obj_t *array)
{
void *entry;
if (array->length >= array->size)
{
if ((lexbor_array_obj_expand(array, 128) == NULL)) {
return NULL;
}
}
entry = array->list + (array->length * array->struct_size);
array->length++;
memset(entry, 0, array->struct_size);
return entry;
}
void *
lexbor_array_obj_push_wo_cls(lexbor_array_obj_t *array)
{
void *entry;
if (array->length >= array->size) {
if ((lexbor_array_obj_expand(array, 128) == NULL)) {
return NULL;
}
}
entry = array->list + (array->length * array->struct_size);
array->length++;
return entry;
}
void *
lexbor_array_obj_push_n(lexbor_array_obj_t *array, size_t count)
{
void *entry;
if ((array->length + count) > array->size) {
if ((lexbor_array_obj_expand(array, count + 128) == NULL)) {
return NULL;
}
}
entry = array->list + (array->length * array->struct_size);
array->length += count;
return entry;
}
void *
lexbor_array_obj_pop(lexbor_array_obj_t *array)
{
if (array->length == 0) {
return NULL;
}
array->length--;
return array->list + (array->length * array->struct_size);
}
void
lexbor_array_obj_delete(lexbor_array_obj_t *array, size_t begin, size_t length)
{
if (begin >= array->length || length == 0) {
return;
}
size_t end_len = begin + length;
if (end_len >= array->length) {
array->length = begin;
return;
}
memmove(&array->list[ begin * array->struct_size ],
&array->list[ end_len * array->struct_size ],
sizeof(uint8_t *)
* ((array->length - end_len) * array->struct_size));
array->length -= length;
}
/*
* No inline functions.
*/
void
lexbor_array_obj_erase_noi(lexbor_array_obj_t *array)
{
lexbor_array_obj_erase(array);
}
void *
lexbor_array_obj_get_noi(lexbor_array_obj_t *array, size_t idx)
{
return lexbor_array_obj_get(array, idx);
}
size_t
lexbor_array_obj_length_noi(lexbor_array_obj_t *array)
{
return lexbor_array_obj_length(array);
}
size_t
lexbor_array_obj_size_noi(lexbor_array_obj_t *array)
{
return lexbor_array_obj_size(array);
}
size_t
lexbor_array_obj_struct_size_noi(lexbor_array_obj_t *array)
{
return lexbor_array_obj_struct_size(array);
}
void *
lexbor_array_obj_last_noi(lexbor_array_obj_t *array)
{
return lexbor_array_obj_last(array);
}

134
ext/dom/lexbor/lexbor/core/array_obj.h Executable file
View file

@ -0,0 +1,134 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_ARRAY_OBJ_H
#define LEXBOR_ARRAY_OBJ_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
typedef struct {
uint8_t *list;
size_t size;
size_t length;
size_t struct_size;
}
lexbor_array_obj_t;
LXB_API lexbor_array_obj_t *
lexbor_array_obj_create(void);
LXB_API lxb_status_t
lexbor_array_obj_init(lexbor_array_obj_t *array,
size_t size, size_t struct_size);
LXB_API void
lexbor_array_obj_clean(lexbor_array_obj_t *array);
LXB_API lexbor_array_obj_t *
lexbor_array_obj_destroy(lexbor_array_obj_t *array, bool self_destroy);
LXB_API uint8_t *
lexbor_array_obj_expand(lexbor_array_obj_t *array, size_t up_to);
LXB_API void *
lexbor_array_obj_push(lexbor_array_obj_t *array);
LXB_API void *
lexbor_array_obj_push_wo_cls(lexbor_array_obj_t *array);
LXB_API void *
lexbor_array_obj_push_n(lexbor_array_obj_t *array, size_t count);
LXB_API void *
lexbor_array_obj_pop(lexbor_array_obj_t *array);
LXB_API void
lexbor_array_obj_delete(lexbor_array_obj_t *array, size_t begin, size_t length);
/*
* Inline functions
*/
lxb_inline void
lexbor_array_obj_erase(lexbor_array_obj_t *array)
{
memset(array, 0, sizeof(lexbor_array_obj_t));
}
lxb_inline void *
lexbor_array_obj_get(const lexbor_array_obj_t *array, size_t idx)
{
if (idx >= array->length) {
return NULL;
}
return array->list + (idx * array->struct_size);
}
lxb_inline size_t
lexbor_array_obj_length(lexbor_array_obj_t *array)
{
return array->length;
}
lxb_inline size_t
lexbor_array_obj_size(lexbor_array_obj_t *array)
{
return array->size;
}
lxb_inline size_t
lexbor_array_obj_struct_size(lexbor_array_obj_t *array)
{
return array->struct_size;
}
lxb_inline void *
lexbor_array_obj_last(lexbor_array_obj_t *array)
{
if (array->length == 0) {
return NULL;
}
return array->list + ((array->length - 1) * array->struct_size);
}
/*
* No inline functions for ABI.
*/
LXB_API void
lexbor_array_obj_erase_noi(lexbor_array_obj_t *array);
LXB_API void *
lexbor_array_obj_get_noi(lexbor_array_obj_t *array, size_t idx);
LXB_API size_t
lexbor_array_obj_length_noi(lexbor_array_obj_t *array);
LXB_API size_t
lexbor_array_obj_size_noi(lexbor_array_obj_t *array);
LXB_API size_t
lexbor_array_obj_struct_size_noi(lexbor_array_obj_t *array);
LXB_API void *
lexbor_array_obj_last_noi(lexbor_array_obj_t *array);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_ARRAY_OBJ_H */

568
ext/dom/lexbor/lexbor/core/avl.c Executable file
View file

@ -0,0 +1,568 @@
/*
* Copyright (C) 2018-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/avl.h"
lxb_inline short
lexbor_avl_node_height(lexbor_avl_node_t *node);
lxb_inline short
lexbor_avl_node_balance_factor(lexbor_avl_node_t *node);
lxb_inline void
lexbor_avl_node_set_height(lexbor_avl_node_t *node);
static lexbor_avl_node_t *
lexbor_avl_node_rotate_right(lexbor_avl_node_t *pos);
static lexbor_avl_node_t *
lexbor_avl_node_rotate_left(lexbor_avl_node_t *pos);
static lexbor_avl_node_t *
lexbor_avl_node_balance(lexbor_avl_node_t *node,
lexbor_avl_node_t **scope);
lxb_inline lexbor_avl_node_t *
lexbor_avl_find_min(lexbor_avl_node_t *node);
lxb_inline void
lexbor_avl_rotate_for_delete(lexbor_avl_node_t *delete_node,
lexbor_avl_node_t *node,
lexbor_avl_node_t **root);
lexbor_avl_t *
lexbor_avl_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_avl_t));
}
lxb_status_t
lexbor_avl_init(lexbor_avl_t *avl, size_t chunk_len, size_t struct_size)
{
if (avl == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (chunk_len == 0
|| (struct_size != 0 && struct_size < sizeof(lexbor_avl_node_t)))
{
return LXB_STATUS_ERROR_WRONG_ARGS;
}
if (struct_size == 0) {
struct_size = sizeof(lexbor_avl_node_t);
}
avl->last_right = NULL;
avl->nodes = lexbor_dobject_create();
return lexbor_dobject_init(avl->nodes, chunk_len, struct_size);
}
void
lexbor_avl_clean(lexbor_avl_t *avl)
{
avl->last_right = NULL;
lexbor_dobject_clean(avl->nodes);
}
lexbor_avl_t *
lexbor_avl_destroy(lexbor_avl_t *avl, bool self_destroy)
{
if (avl == NULL)
return NULL;
avl->nodes = lexbor_dobject_destroy(avl->nodes, true);
if (self_destroy) {
return lexbor_free(avl);
}
return avl;
}
lexbor_avl_node_t *
lexbor_avl_node_make(lexbor_avl_t *avl, size_t type, void *value)
{
lexbor_avl_node_t *node = lexbor_dobject_calloc(avl->nodes);
if (node == NULL) {
return NULL;
}
node->type = type;
node->value = value;
return node;
}
void
lexbor_avl_node_clean(lexbor_avl_node_t *node)
{
memset(node, 0, sizeof(lexbor_avl_node_t));
}
lexbor_avl_node_t *
lexbor_avl_node_destroy(lexbor_avl_t *avl,
lexbor_avl_node_t *node, bool self_destroy)
{
if (node == NULL) {
return NULL;
}
if (self_destroy) {
return lexbor_dobject_free(avl->nodes, node);
}
return node;
}
lxb_inline short
lexbor_avl_node_height(lexbor_avl_node_t *node)
{
return (node) ? node->height : 0;
}
lxb_inline short
lexbor_avl_node_balance_factor(lexbor_avl_node_t *node)
{
return (lexbor_avl_node_height(node->right)
- lexbor_avl_node_height(node->left));
}
lxb_inline void
lexbor_avl_node_set_height(lexbor_avl_node_t *node)
{
short left_height = lexbor_avl_node_height(node->left);
short right_height = lexbor_avl_node_height(node->right);
node->height = ((left_height > right_height)
? left_height : right_height) + 1;
}
static lexbor_avl_node_t *
lexbor_avl_node_rotate_right(lexbor_avl_node_t *pos)
{
lexbor_avl_node_t *node = pos->left;
node->parent = pos->parent;
if (node->right) {
node->right->parent = pos;
}
pos->left = node->right;
pos->parent = node;
node->right = pos;
lexbor_avl_node_set_height(pos);
lexbor_avl_node_set_height(node);
return node;
}
static lexbor_avl_node_t *
lexbor_avl_node_rotate_left(lexbor_avl_node_t *pos)
{
lexbor_avl_node_t *node = pos->right;
node->parent = pos->parent;
if (node->left) {
node->left->parent = pos;
}
pos->right = node->left;
pos->parent = node;
node->left = pos;
lexbor_avl_node_set_height(pos);
lexbor_avl_node_set_height(node);
return node;
}
static lexbor_avl_node_t *
lexbor_avl_node_balance(lexbor_avl_node_t *node, lexbor_avl_node_t **scope)
{
/* Set height */
lexbor_avl_node_t *parent;
short left_height = lexbor_avl_node_height(node->left);
short right_height = lexbor_avl_node_height(node->right);
node->height = ((left_height > right_height)
? left_height : right_height) + 1;
/* Check balance */
switch ((right_height - left_height)) {
case 2: {
if (lexbor_avl_node_balance_factor(node->right) < 0) {
node->right = lexbor_avl_node_rotate_right(node->right);
}
parent = node->parent;
if (parent != NULL) {
if (parent->right == node) {
parent->right = lexbor_avl_node_rotate_left(node);
return parent->right;
}
else {
parent->left = lexbor_avl_node_rotate_left(node);
return parent->left;
}
}
return lexbor_avl_node_rotate_left(node);
}
case -2: {
if (lexbor_avl_node_balance_factor(node->left) > 0) {
node->left = lexbor_avl_node_rotate_left(node->left);
}
parent = node->parent;
if (parent != NULL) {
if (parent->right == node) {
parent->right = lexbor_avl_node_rotate_right(node);
return parent->right;
}
else {
parent->left = lexbor_avl_node_rotate_right(node);
return parent->left;
}
}
return lexbor_avl_node_rotate_right(node);
}
default:
break;
}
if (node->parent == NULL) {
*scope = node;
}
return node->parent;
}
lexbor_avl_node_t *
lexbor_avl_insert(lexbor_avl_t *avl, lexbor_avl_node_t **scope,
size_t type, void *value)
{
lexbor_avl_node_t *node, *new_node;
if (*scope == NULL) {
*scope = lexbor_avl_node_make(avl, type, value);
return *scope;
}
node = *scope;
new_node = lexbor_dobject_calloc(avl->nodes);
for (;;) {
if (type == node->type) {
node->value = value;
return node;
}
else if (type < node->type) {
if (node->left == NULL) {
node->left = new_node;
new_node->parent = node;
new_node->type = type;
new_node->value = value;
node = new_node;
break;
}
node = node->left;
}
else {
if (node->right == NULL) {
node->right = new_node;
new_node->parent = node;
new_node->type = type;
new_node->value = value;
node = new_node;
break;
}
node = node->right;
}
}
while (node != NULL) {
node = lexbor_avl_node_balance(node, scope);
}
return new_node;
}
lxb_inline lexbor_avl_node_t *
lexbor_avl_find_min(lexbor_avl_node_t *node)
{
if (node == NULL) {
return NULL;
}
while (node->right != NULL) {
node = node->right;
}
return node;
}
lxb_inline void
lexbor_avl_rotate_for_delete(lexbor_avl_node_t *delete_node,
lexbor_avl_node_t *node, lexbor_avl_node_t **scope)
{
lexbor_avl_node_t *balance_node;
if (node) {
if (delete_node->left == node) {
balance_node = (node->left) ? node->left : node;
node->parent = delete_node->parent;
node->right = delete_node->right;
if (delete_node->right)
delete_node->right->parent = node;
}
else {
balance_node = node;
node->parent->right = NULL;
node->parent = delete_node->parent;
node->right = delete_node->right;
node->left = delete_node->left;
if (delete_node->left != NULL) {
delete_node->left->parent = node;
}
if (delete_node->right != NULL) {
delete_node->right->parent = node;
}
}
if (delete_node->parent != NULL) {
if (delete_node->parent->left == delete_node) {
delete_node->parent->left = node;
}
else {
delete_node->parent->right = node;
}
}
else {
*scope = node;
}
}
else {
balance_node = delete_node->parent;
if (balance_node != NULL) {
if (balance_node->left == delete_node) {
balance_node->left = delete_node->right;
}
else {
balance_node->right = delete_node->right;
}
}
else {
*scope = delete_node->right;
}
if (delete_node->right != NULL) {
delete_node->right->parent = balance_node;
}
}
while (balance_node != NULL) {
balance_node = lexbor_avl_node_balance(balance_node, scope);
}
}
void *
lexbor_avl_remove(lexbor_avl_t *avl, lexbor_avl_node_t **scope, size_t type)
{
void *value;
lexbor_avl_node_t *node = *scope;
while (node != NULL) {
if (type == node->type) {
avl->last_right = lexbor_avl_find_min(node->left);
lexbor_avl_rotate_for_delete(node, avl->last_right, scope);
value = node->value;
lexbor_dobject_free(avl->nodes, node);
return value;
}
else if (type < node->type) {
node = node->left;
}
else {
node = node->right;
}
}
return NULL;
}
void
lexbor_avl_remove_by_node(lexbor_avl_t *avl, lexbor_avl_node_t **root,
lexbor_avl_node_t *node)
{
avl->last_right = lexbor_avl_find_min(node->left);
lexbor_avl_rotate_for_delete(node, avl->last_right, root);
(void) lexbor_dobject_free(avl->nodes, node);
}
lexbor_avl_node_t *
lexbor_avl_search(lexbor_avl_t *avl, lexbor_avl_node_t *node, size_t type)
{
while (node != NULL) {
if (type == node->type) {
return node;
}
else if (type < node->type) {
node = node->left;
}
else {
node = node->right;
}
}
return NULL;
}
lxb_status_t
lexbor_avl_foreach(lexbor_avl_t *avl, lexbor_avl_node_t **scope,
lexbor_avl_node_f cb, void *ctx)
{
lxb_status_t status;
int state = 0;
bool from_right = false;
lexbor_avl_node_t *node, *parent, *root;
if (scope == NULL || *scope == NULL) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
node = *scope;
root = node;
while (node->left != NULL) {
node = node->left;
}
do {
parent = node->parent;
if (!from_right) {
if (node == root) {
state = 2;
}
else {
state = parent->left == node;
}
status = cb(avl, scope, node, ctx);
if (status != LXB_STATUS_OK) {
return status;
}
if (state == 2) {
if (*scope != root) {
root = *scope;
if (root == NULL) {
return LXB_STATUS_OK;
}
else if (avl->last_right == root) {
node = root;
}
else {
node = root;
continue;
}
}
}
else if (parent->left != node && parent->right != node) {
if (state) {
if (parent->left != NULL && parent->left->right != NULL) {
node = parent->left;
}
else {
node = parent;
continue;
}
}
else {
if (parent->right != NULL) {
node = parent->right;
if (node != avl->last_right) {
continue;
}
}
else {
node = parent;
}
}
}
}
if (node->right != NULL && !from_right) {
node = node->right;
while (node->left != NULL) {
node = node->left;
}
continue;
}
if (parent == root->parent) {
return LXB_STATUS_OK;
}
else if (node == parent->left) {
from_right = false;
}
else {
from_right = true;
}
node = parent;
}
while (true);
}
void
lexbor_avl_foreach_recursion(lexbor_avl_t *avl, lexbor_avl_node_t *scope,
lexbor_avl_node_f callback, void *ctx)
{
if (scope == NULL) {
return;
}
callback(avl, NULL, scope, ctx);
lexbor_avl_foreach_recursion(avl, scope->left, callback, ctx);
lexbor_avl_foreach_recursion(avl, scope->right, callback, ctx);
}

92
ext/dom/lexbor/lexbor/core/avl.h Executable file
View file

@ -0,0 +1,92 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_AVL_H
#define LEXBOR_AVL_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/core/dobject.h"
typedef struct lexbor_avl lexbor_avl_t;
typedef struct lexbor_avl_node lexbor_avl_node_t;
typedef lxb_status_t
(*lexbor_avl_node_f)(lexbor_avl_t *avl, lexbor_avl_node_t **root,
lexbor_avl_node_t *node, void *ctx);
struct lexbor_avl_node {
size_t type;
short height;
void *value;
lexbor_avl_node_t *left;
lexbor_avl_node_t *right;
lexbor_avl_node_t *parent;
};
struct lexbor_avl {
lexbor_dobject_t *nodes;
lexbor_avl_node_t *last_right;
};
LXB_API lexbor_avl_t *
lexbor_avl_create(void);
LXB_API lxb_status_t
lexbor_avl_init(lexbor_avl_t *avl, size_t chunk_len, size_t struct_size);
LXB_API void
lexbor_avl_clean(lexbor_avl_t *avl);
LXB_API lexbor_avl_t *
lexbor_avl_destroy(lexbor_avl_t *avl, bool self_destroy);
LXB_API lexbor_avl_node_t *
lexbor_avl_node_make(lexbor_avl_t *avl, size_t type, void *value);
LXB_API void
lexbor_avl_node_clean(lexbor_avl_node_t *node);
LXB_API lexbor_avl_node_t *
lexbor_avl_node_destroy(lexbor_avl_t *avl, lexbor_avl_node_t *node,
bool self_destroy);
LXB_API lexbor_avl_node_t *
lexbor_avl_insert(lexbor_avl_t *avl, lexbor_avl_node_t **scope,
size_t type, void *value);
LXB_API lexbor_avl_node_t *
lexbor_avl_search(lexbor_avl_t *avl, lexbor_avl_node_t *scope, size_t type);
LXB_API void *
lexbor_avl_remove(lexbor_avl_t *avl, lexbor_avl_node_t **scope, size_t type);
LXB_API void
lexbor_avl_remove_by_node(lexbor_avl_t *avl, lexbor_avl_node_t **root,
lexbor_avl_node_t *node);
LXB_API lxb_status_t
lexbor_avl_foreach(lexbor_avl_t *avl, lexbor_avl_node_t **scope,
lexbor_avl_node_f cb, void *ctx);
LXB_API void
lexbor_avl_foreach_recursion(lexbor_avl_t *avl, lexbor_avl_node_t *scope,
lexbor_avl_node_f callback, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_AVL_H */

103
ext/dom/lexbor/lexbor/core/base.h Normal file
View file

@ -0,0 +1,103 @@
/*
* Copyright (C) 2018-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_BASE_H
#define LEXBOR_BASE_H
#ifdef __cplusplus
#define __STDC_LIMIT_MACROS
#define __STDC_CONSTANT_MACROS
extern "C" {
#endif
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <stdarg.h>
#include <memory.h>
#include <limits.h>
#include <string.h>
#include "lexbor/core/def.h"
#include "lexbor/core/types.h"
#include "lexbor/core/lexbor.h"
#define LEXBOR_VERSION_MAJOR 1
#define LEXBOR_VERSION_MINOR 7
#define LEXBOR_VERSION_PATCH 0
#define LEXBOR_VERSION_STRING LEXBOR_STRINGIZE(LEXBOR_VERSION_MAJOR) "." \
LEXBOR_STRINGIZE(LEXBOR_VERSION_MINOR) "." \
LEXBOR_STRINGIZE(LEXBOR_VERSION_PATCH)
#define lexbor_assert(val)
#define lexbor_max(val1, val2) ((val1) > (val2) ? (val1) : (val2))
#define lexbor_min(val1, val2) ((val1) < (val2) ? (val1) : (val2))
/*
* Very important!!!
*
* for lexbor 0..00AFFF; LXB_STATUS_OK == 0x000000
*/
typedef enum {
LXB_STATUS_OK = 0x0000,
LXB_STATUS_ERROR = 0x0001,
LXB_STATUS_ERROR_MEMORY_ALLOCATION,
LXB_STATUS_ERROR_OBJECT_IS_NULL,
LXB_STATUS_ERROR_SMALL_BUFFER,
LXB_STATUS_ERROR_INCOMPLETE_OBJECT,
LXB_STATUS_ERROR_NO_FREE_SLOT,
LXB_STATUS_ERROR_TOO_SMALL_SIZE,
LXB_STATUS_ERROR_NOT_EXISTS,
LXB_STATUS_ERROR_WRONG_ARGS,
LXB_STATUS_ERROR_WRONG_STAGE,
LXB_STATUS_ERROR_UNEXPECTED_RESULT,
LXB_STATUS_ERROR_UNEXPECTED_DATA,
LXB_STATUS_ERROR_OVERFLOW,
LXB_STATUS_CONTINUE,
LXB_STATUS_SMALL_BUFFER,
LXB_STATUS_ABORTED,
LXB_STATUS_STOPPED,
LXB_STATUS_NEXT,
LXB_STATUS_STOP,
LXB_STATUS_WARNING
}
lexbor_status_t;
typedef enum {
LEXBOR_ACTION_OK = 0x00,
LEXBOR_ACTION_STOP = 0x01,
LEXBOR_ACTION_NEXT = 0x02
}
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;
intptr_t opt;
size_t count;
}
lexbor_serialize_ctx_t;
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_BASE_H */

471
ext/dom/lexbor/lexbor/core/bst.c Executable file
View file

@ -0,0 +1,471 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/bst.h"
#include "lexbor/core/conv.h"
lexbor_bst_t *
lexbor_bst_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_bst_t));
}
lxb_status_t
lexbor_bst_init(lexbor_bst_t *bst, size_t size)
{
lxb_status_t status;
if (bst == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (size == 0) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
bst->dobject = lexbor_dobject_create();
status = lexbor_dobject_init(bst->dobject, size,
sizeof(lexbor_bst_entry_t));
if (status != LXB_STATUS_OK) {
return status;
}
bst->root = 0;
bst->tree_length = 0;
return LXB_STATUS_OK;
}
void
lexbor_bst_clean(lexbor_bst_t *bst)
{
if (bst != NULL) {
lexbor_dobject_clean(bst->dobject);
bst->root = 0;
bst->tree_length = 0;
}
}
lexbor_bst_t *
lexbor_bst_destroy(lexbor_bst_t *bst, bool self_destroy)
{
if (bst == NULL) {
return NULL;
}
bst->dobject = lexbor_dobject_destroy(bst->dobject, true);
if (self_destroy) {
return lexbor_free(bst);
}
return bst;
}
lexbor_bst_entry_t *
lexbor_bst_entry_make(lexbor_bst_t *bst, size_t size)
{
lexbor_bst_entry_t *new_entry = lexbor_dobject_calloc(bst->dobject);
if (new_entry == NULL) {
return NULL;
}
new_entry->size = size;
bst->tree_length++;
return new_entry;
}
lexbor_bst_entry_t *
lexbor_bst_insert(lexbor_bst_t *bst, lexbor_bst_entry_t **scope,
size_t size, void *value)
{
lexbor_bst_entry_t *new_entry, *entry;
new_entry = lexbor_dobject_calloc(bst->dobject);
if (new_entry == NULL) {
return NULL;
}
new_entry->size = size;
new_entry->value = value;
bst->tree_length++;
if (*scope == NULL) {
*scope = new_entry;
return new_entry;
}
entry = *scope;
while (entry != NULL) {
if (size == entry->size) {
if (entry->next) {
new_entry->next = entry->next;
}
entry->next = new_entry;
new_entry->parent = entry->parent;
return new_entry;
}
else if (size > entry->size) {
if (entry->right == NULL) {
entry->right = new_entry;
new_entry->parent = entry;
return new_entry;
}
entry = entry->right;
}
else {
if (entry->left == NULL) {
entry->left = new_entry;
new_entry->parent = entry;
return new_entry;
}
entry = entry->left;
}
}
return NULL;
}
lexbor_bst_entry_t *
lexbor_bst_insert_not_exists(lexbor_bst_t *bst, lexbor_bst_entry_t **scope,
size_t size)
{
lexbor_bst_entry_t *entry;
if (*scope == NULL) {
*scope = lexbor_bst_entry_make(bst, size);
return *scope;
}
entry = *scope;
while (entry != NULL) {
if (size == entry->size) {
return entry;
}
else if (size > entry->size) {
if (entry->right == NULL) {
entry->right = lexbor_bst_entry_make(bst, size);
entry->right->parent = entry;
return entry->right;
}
entry = entry->right;
}
else {
if (entry->left == NULL) {
entry->left = lexbor_bst_entry_make(bst, size);
entry->left->parent = entry;
return entry->left;
}
entry = entry->left;
}
}
return NULL;
}
lexbor_bst_entry_t *
lexbor_bst_search(lexbor_bst_t *bst, lexbor_bst_entry_t *scope, size_t size)
{
while (scope != NULL) {
if (scope->size == size) {
return scope;
}
else if (size > scope->size) {
scope = scope->right;
}
else {
scope = scope->left;
}
}
return NULL;
}
lexbor_bst_entry_t *
lexbor_bst_search_close(lexbor_bst_t *bst, lexbor_bst_entry_t *scope,
size_t size)
{
lexbor_bst_entry_t *max = NULL;
while (scope != NULL) {
if (scope->size == size) {
return scope;
}
else if (size > scope->size) {
scope = scope->right;
}
else {
max = scope;
scope = scope->left;
}
}
return max;
}
void *
lexbor_bst_remove(lexbor_bst_t *bst, lexbor_bst_entry_t **scope, size_t size)
{
lexbor_bst_entry_t *entry = *scope;
while (entry != NULL) {
if (entry->size == size) {
return lexbor_bst_remove_by_pointer(bst, entry, scope);
}
else if (size > entry->size) {
entry = entry->right;
}
else {
entry = entry->left;
}
}
return NULL;
}
void *
lexbor_bst_remove_close(lexbor_bst_t *bst, lexbor_bst_entry_t **scope,
size_t size, size_t *found_size)
{
lexbor_bst_entry_t *entry = *scope;
lexbor_bst_entry_t *max = NULL;
while (entry != NULL) {
if (entry->size == size) {
if (found_size) {
*found_size = entry->size;
}
return lexbor_bst_remove_by_pointer(bst, entry, scope);
}
else if (size > entry->size) {
entry = entry->right;
}
else {
max = entry;
entry = entry->left;
}
}
if (max != NULL) {
if (found_size != NULL) {
*found_size = max->size;
}
return lexbor_bst_remove_by_pointer(bst, max, scope);
}
if (found_size != NULL) {
*found_size = 0;
}
return NULL;
}
void *
lexbor_bst_remove_by_pointer(lexbor_bst_t *bst, lexbor_bst_entry_t *entry,
lexbor_bst_entry_t **root)
{
void *value;
lexbor_bst_entry_t *next, *right, *left;
bst->tree_length--;
if (entry->next != NULL) {
next = entry->next;
entry->next = entry->next->next;
value = next->value;
lexbor_dobject_free(bst->dobject, next);
return value;
}
value = entry->value;
if (entry->left == NULL && entry->right == NULL) {
if (entry->parent != NULL) {
if (entry->parent->left == entry) entry->parent->left = NULL;
if (entry->parent->right == entry) entry->parent->right = NULL;
}
else {
*root = NULL;
}
lexbor_dobject_free(bst->dobject, entry);
}
else if (entry->left == NULL) {
if (entry->parent == NULL) {
entry->right->parent = NULL;
*root = entry->right;
lexbor_dobject_free(bst->dobject, entry);
entry = *root;
}
else {
right = entry->right;
right->parent = entry->parent;
memcpy(entry, right, sizeof(lexbor_bst_entry_t));
lexbor_dobject_free(bst->dobject, right);
}
if (entry->right != NULL) {
entry->right->parent = entry;
}
if (entry->left != NULL) {
entry->left->parent = entry;
}
}
else if (entry->right == NULL) {
if (entry->parent == NULL) {
entry->left->parent = NULL;
*root = entry->left;
lexbor_dobject_free(bst->dobject, entry);
entry = *root;
}
else {
left = entry->left;
left->parent = entry->parent;
memcpy(entry, left, sizeof(lexbor_bst_entry_t));
lexbor_dobject_free(bst->dobject, left);
}
if (entry->right != NULL) {
entry->right->parent = entry;
}
if (entry->left != NULL) {
entry->left->parent = entry;
}
}
else {
left = entry->right;
while (left->left != NULL) {
left = left->left;
}
/* Swap */
entry->size = left->size;
entry->next = left->next;
entry->value = left->value;
/* Change parrent */
if (entry->right == left) {
entry->right = left->right;
if (entry->right != NULL) {
left->right->parent = entry;
}
}
else {
left->parent->left = left->right;
if (left->right != NULL) {
left->right->parent = left->parent;
}
}
lexbor_dobject_free(bst->dobject, left);
}
return value;
}
void
lexbor_bst_serialize(lexbor_bst_t *bst, lexbor_callback_f callback, void *ctx)
{
lexbor_bst_serialize_entry(bst->root, callback, ctx, 0);
}
void
lexbor_bst_serialize_entry(lexbor_bst_entry_t *entry,
lexbor_callback_f callback, void *ctx, size_t tabs)
{
size_t len;
lxb_char_t buff[1024];
if (entry == NULL) {
return;
}
/* Left */
for (size_t i = 0; i < tabs; i++) {
callback((lxb_char_t *) "\t", 1, ctx);
}
callback((lxb_char_t *) "<left ", 6, ctx);
if (entry->left) {
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));
for (size_t i = 0; i < tabs; i++) {
callback((lxb_char_t *) "\t", 1, ctx);
}
}
else {
callback((lxb_char_t *) "NULL>", 5, ctx);
}
callback((lxb_char_t *) "</left>\n", 8, ctx);
/* Right */
for (size_t i = 0; i < tabs; i++) {
callback((lxb_char_t *) "\t", 1, ctx);
}
callback((lxb_char_t *) "<right ", 7, ctx);
if (entry->right) {
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));
for (size_t i = 0; i < tabs; i++) {
callback((lxb_char_t *) "\t", 1, ctx);
}
}
else {
callback((lxb_char_t *) "NULL>", 5, ctx);
}
callback((lxb_char_t *) "</right>\n", 9, ctx);
}

108
ext/dom/lexbor/lexbor/core/bst.h Executable file
View file

@ -0,0 +1,108 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_BST_H
#define LEXBOR_BST_H
#ifdef __cplusplus
extern "C" {
#endif
#include <string.h>
#include "lexbor/core/base.h"
#include "lexbor/core/dobject.h"
#define lexbor_bst_root(bst) (bst)->root
#define lexbor_bst_root_ref(bst) &((bst)->root)
typedef struct lexbor_bst_entry lexbor_bst_entry_t;
typedef struct lexbor_bst lexbor_bst_t;
typedef bool (*lexbor_bst_entry_f)(lexbor_bst_t *bst,
lexbor_bst_entry_t *entry, void *ctx);
struct lexbor_bst_entry {
void *value;
lexbor_bst_entry_t *right;
lexbor_bst_entry_t *left;
lexbor_bst_entry_t *next;
lexbor_bst_entry_t *parent;
size_t size;
};
struct lexbor_bst {
lexbor_dobject_t *dobject;
lexbor_bst_entry_t *root;
size_t tree_length;
};
LXB_API lexbor_bst_t *
lexbor_bst_create(void);
LXB_API lxb_status_t
lexbor_bst_init(lexbor_bst_t *bst, size_t size);
LXB_API void
lexbor_bst_clean(lexbor_bst_t *bst);
LXB_API lexbor_bst_t *
lexbor_bst_destroy(lexbor_bst_t *bst, bool self_destroy);
LXB_API lexbor_bst_entry_t *
lexbor_bst_entry_make(lexbor_bst_t *bst, size_t size);
LXB_API lexbor_bst_entry_t *
lexbor_bst_insert(lexbor_bst_t *bst, lexbor_bst_entry_t **scope,
size_t size, void *value);
LXB_API lexbor_bst_entry_t *
lexbor_bst_insert_not_exists(lexbor_bst_t *bst, lexbor_bst_entry_t **scope,
size_t size);
LXB_API lexbor_bst_entry_t *
lexbor_bst_search(lexbor_bst_t *bst, lexbor_bst_entry_t *scope, size_t size);
LXB_API lexbor_bst_entry_t *
lexbor_bst_search_close(lexbor_bst_t *bst, lexbor_bst_entry_t *scope,
size_t size);
LXB_API void *
lexbor_bst_remove(lexbor_bst_t *bst, lexbor_bst_entry_t **root, size_t size);
LXB_API void *
lexbor_bst_remove_close(lexbor_bst_t *bst, lexbor_bst_entry_t **root,
size_t size, size_t *found_size);
LXB_API void *
lexbor_bst_remove_by_pointer(lexbor_bst_t *bst, lexbor_bst_entry_t *entry,
lexbor_bst_entry_t **root);
LXB_API void
lexbor_bst_serialize(lexbor_bst_t *bst, lexbor_callback_f callback, void *ctx);
LXB_API void
lexbor_bst_serialize_entry(lexbor_bst_entry_t *entry,
lexbor_callback_f callback, void *ctx, size_t tabs);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_BST_H */

238
ext/dom/lexbor/lexbor/core/bst_map.c Executable file
View file

@ -0,0 +1,238 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/bst_map.h"
#include "lexbor/core/utils.h"
lexbor_bst_map_t *
lexbor_bst_map_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_bst_map_t));
}
lxb_status_t
lexbor_bst_map_init(lexbor_bst_map_t *bst_map, size_t size)
{
lxb_status_t status;
if (bst_map == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (size == 0) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
/* bst */
bst_map->bst = lexbor_bst_create();
status = lexbor_bst_init(bst_map->bst, size);
if (status) {
return status;
}
/* dobject */
bst_map->entries = lexbor_dobject_create();
status = lexbor_dobject_init(bst_map->entries, size,
sizeof(lexbor_bst_map_entry_t));
if (status) {
return status;
}
/* mraw */
bst_map->mraw = lexbor_mraw_create();
status = lexbor_mraw_init(bst_map->mraw, (size * 6));
if (status) {
return status;
}
return LXB_STATUS_OK;
}
void
lexbor_bst_map_clean(lexbor_bst_map_t *bst_map)
{
lexbor_bst_clean(bst_map->bst);
lexbor_mraw_clean(bst_map->mraw);
lexbor_dobject_clean(bst_map->entries);
}
lexbor_bst_map_t *
lexbor_bst_map_destroy(lexbor_bst_map_t *bst_map, bool self_destroy)
{
if (bst_map == NULL) {
return NULL;
}
bst_map->bst = lexbor_bst_destroy(bst_map->bst, true);
bst_map->mraw = lexbor_mraw_destroy(bst_map->mraw, true);
bst_map->entries = lexbor_dobject_destroy(bst_map->entries, true);
if (self_destroy) {
return lexbor_free(bst_map);
}
return bst_map;
}
lexbor_bst_map_entry_t *
lexbor_bst_map_search(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t *scope,
const lxb_char_t *key, size_t key_len)
{
lexbor_bst_map_entry_t *entry;
lexbor_bst_entry_t *bst_entry;
size_t hash_id = lexbor_utils_hash_hash(key, key_len);
bst_entry = lexbor_bst_search(bst_map->bst, scope, hash_id);
if (bst_entry == NULL) {
return NULL;
}
do {
entry = bst_entry->value;
if (entry->str.length == key_len &&
lexbor_str_data_cmp(entry->str.data, key))
{
return entry;
}
bst_entry = bst_entry->next;
}
while (bst_entry != NULL);
return NULL;
}
lexbor_bst_map_entry_t *
lexbor_bst_map_insert(lexbor_bst_map_t *bst_map,
lexbor_bst_entry_t **scope,
const lxb_char_t *key, size_t key_len, void *value)
{
lexbor_bst_map_entry_t *entry;
entry = lexbor_bst_map_insert_not_exists(bst_map, scope, key, key_len);
if (entry == NULL) {
return NULL;
}
entry->value = value;
return entry;
}
lexbor_bst_map_entry_t *
lexbor_bst_map_insert_not_exists(lexbor_bst_map_t *bst_map,
lexbor_bst_entry_t **scope,
const lxb_char_t *key, size_t key_len)
{
lexbor_bst_map_entry_t *entry;
lexbor_bst_entry_t *bst_entry;
size_t hash_id = lexbor_utils_hash_hash(key, key_len);
bst_entry = lexbor_bst_insert_not_exists(bst_map->bst, scope, hash_id);
if (bst_entry == NULL) {
return NULL;
}
if (bst_entry->value == NULL) {
goto new_entry;
}
do {
entry = bst_entry->value;
if (entry->str.length == key_len &&
lexbor_str_data_cmp(entry->str.data, key))
{
return entry;
}
if (bst_entry->next == NULL) {
bst_entry->next = lexbor_bst_entry_make(bst_map->bst, hash_id);
bst_entry = bst_entry->next;
if (bst_entry == NULL) {
return NULL;
}
goto new_entry;
}
bst_entry = bst_entry->next;
}
while (1);
return NULL;
new_entry:
entry = lexbor_dobject_calloc(bst_map->entries);
if (entry == NULL) {
return NULL;
}
lexbor_str_init(&entry->str, bst_map->mraw, key_len);
if (entry->str.data == NULL) {
lexbor_dobject_free(bst_map->entries, entry);
return NULL;
}
lexbor_str_append(&entry->str, bst_map->mraw, key, key_len);
bst_entry->value = entry;
return entry;
}
void *
lexbor_bst_map_remove(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t **scope,
const lxb_char_t *key, size_t key_len)
{
lexbor_bst_map_entry_t *entry;
lexbor_bst_entry_t *bst_entry;
size_t hash_id = lexbor_utils_hash_hash(key, key_len);
bst_entry = lexbor_bst_search(bst_map->bst, *scope, hash_id);
if (bst_entry == NULL) {
return NULL;
}
do {
entry = bst_entry->value;
if (entry->str.length == key_len &&
lexbor_str_data_cmp(entry->str.data, key))
{
void *value = entry->value;
lexbor_bst_remove_by_pointer(bst_map->bst, bst_entry, scope);
lexbor_str_destroy(&entry->str, bst_map->mraw, false);
lexbor_dobject_free(bst_map->entries, entry);
return value;
}
bst_entry = bst_entry->next;
}
while (bst_entry != NULL);
return NULL;
}
/*
* No inline functions.
*/
lexbor_mraw_t *
lexbor_bst_map_mraw_noi(lexbor_bst_map_t *bst_map)
{
return lexbor_bst_map_mraw(bst_map);
}

87
ext/dom/lexbor/lexbor/core/bst_map.h Executable file
View file

@ -0,0 +1,87 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_BST_MAP_H
#define LEXBOR_BST_MAP_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/bst.h"
#include "lexbor/core/str.h"
#include "lexbor/core/mraw.h"
#include "lexbor/core/dobject.h"
typedef struct {
lexbor_str_t str;
void *value;
}
lexbor_bst_map_entry_t;
typedef struct {
lexbor_bst_t *bst;
lexbor_mraw_t *mraw;
lexbor_dobject_t *entries;
}
lexbor_bst_map_t;
LXB_API lexbor_bst_map_t *
lexbor_bst_map_create(void);
LXB_API lxb_status_t
lexbor_bst_map_init(lexbor_bst_map_t *bst_map, size_t size);
LXB_API void
lexbor_bst_map_clean(lexbor_bst_map_t *bst_map);
LXB_API lexbor_bst_map_t *
lexbor_bst_map_destroy(lexbor_bst_map_t *bst_map, bool self_destroy);
LXB_API lexbor_bst_map_entry_t *
lexbor_bst_map_search(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t *scope,
const lxb_char_t *key, size_t key_len);
LXB_API lexbor_bst_map_entry_t *
lexbor_bst_map_insert(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t **scope,
const lxb_char_t *key, size_t key_len, void *value);
LXB_API lexbor_bst_map_entry_t *
lexbor_bst_map_insert_not_exists(lexbor_bst_map_t *bst_map,
lexbor_bst_entry_t **scope,
const lxb_char_t *key, size_t key_len);
LXB_API void *
lexbor_bst_map_remove(lexbor_bst_map_t *bst_map, lexbor_bst_entry_t **scope,
const lxb_char_t *key, size_t key_len);
/*
* Inline functions
*/
lxb_inline lexbor_mraw_t *
lexbor_bst_map_mraw(lexbor_bst_map_t *bst_map)
{
return bst_map->mraw;
}
/*
* No inline functions for ABI.
*/
LXB_API lexbor_mraw_t *
lexbor_bst_map_mraw_noi(lexbor_bst_map_t *bst_map);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_BST_MAP_H */

346
ext/dom/lexbor/lexbor/core/conv.c Normal file
View file

@ -0,0 +1,346 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include <math.h>
#include <float.h>
#include "lexbor/core/conv.h"
#include "lexbor/core/dtoa.h"
#include "lexbor/core/strtod.h"
size_t
lexbor_conv_float_to_data(double num, lxb_char_t *buf, size_t len)
{
return lexbor_dtoa(num, buf, len);
}
size_t
lexbor_conv_long_to_data(long num, lxb_char_t *buf, size_t 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
lexbor_conv_data_to_double(const lxb_char_t **start, size_t len)
{
int exponent, exp, insignf;
lxb_char_t c, *pos;
bool minus, ex_minus;
double num;
const lxb_char_t *e, *p, *last, *end;
lxb_char_t data[128];
end = *start + len;
exponent = 0;
insignf = 0;
pos = data;
last = data + sizeof(data);
minus = false;
switch (**start) {
case '-':
minus = true;
/* fall through */
case '+':
(*start)++;
/* fall through */
default:
break;
}
for (p = *start; p < end; p++) {
/* Values less than '0' become >= 208. */
c = *p - '0';
if (c > 9) {
break;
}
if (pos < last) {
*pos++ = *p;
}
else {
insignf++;
}
}
/* Do not emit a '.', but adjust the exponent instead. */
if (p < end && *p == '.') {
for (p++; p < end; p++) {
/* Values less than '0' become >= 208. */
c = *p - '0';
if (c > 9) {
break;
}
if (pos < last) {
*pos++ = *p;
exponent--;
}
else {
/* Ignore insignificant digits in the fractional part. */
}
}
}
e = p + 1;
if (e < end && (*p == 'e' || *p == 'E')) {
ex_minus = 0;
if (e + 1 < end) {
if (*e == '-') {
e++;
ex_minus = 1;
}
else if (*e == '+') {
e++;
}
}
/* Values less than '0' become >= 208. */
c = *e - '0';
if (c <= 9) {
exp = c;
for (p = e + 1; p < end; p++) {
/* Values less than '0' become >= 208. */
c = *p - '0';
if (c > 9) {
break;
}
exp = exp * 10 + c;
}
exponent += ex_minus ? -exp : exp;
}
}
*start = p;
exponent += insignf;
num = lexbor_strtod_internal(data, pos - data, exponent);
if (minus) {
num = -num;
}
return num;
}
unsigned long
lexbor_conv_data_to_ulong(const lxb_char_t **data, size_t length)
{
const lxb_char_t *p = *data;
const lxb_char_t *end = p + length;
unsigned long last_number = 0, number = 0;
for (; p < end; p++) {
if (*p < '0' || *p > '9') {
goto done;
}
number = (*p - '0') + number * 10;
if (last_number > number) {
*data = p - 1;
return last_number;
}
last_number = number;
}
done:
*data = p;
return number;
}
long
lexbor_conv_data_to_long(const lxb_char_t **data, size_t length)
{
bool minus;
const lxb_char_t *p;
const lxb_char_t *end;
unsigned long n = 0, number = 0;
minus = false;
p = *data;
end = p + length;
switch (*p) {
case '-':
minus = true;
/* fall through */
case '+':
p++;
/* fall through */
default:
break;
}
for (; p < end; p++) {
if (*p < '0' || *p > '9') {
break;
}
n = (*p - '0') + number * 10;
if (n > LONG_MAX) {
p -= 1;
break;
}
number = n;
}
*data = p;
return (minus) ? -number : number;
}
unsigned
lexbor_conv_data_to_uint(const lxb_char_t **data, size_t length)
{
const lxb_char_t *p = *data;
const lxb_char_t *end = p + length;
unsigned last_number = 0, number = 0;
for (; p < end; p++) {
if (*p < '0' || *p > '9') {
goto done;
}
number = (*p - '0') + number * 10;
if (last_number > number) {
*data = p - 1;
return last_number;
}
last_number = number;
}
done:
*data = p;
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;
}

61
ext/dom/lexbor/lexbor/core/conv.h Normal file
View file

@ -0,0 +1,61 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CONV_H
#define LEXBOR_CONV_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
LXB_API size_t
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);
LXB_API unsigned long
lexbor_conv_data_to_ulong(const lxb_char_t **data, size_t length);
LXB_API long
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)
{
if (number > (double) LONG_MAX) {
return LONG_MAX;
}
if (number < (double) LONG_MIN) {
return -LONG_MAX;
}
return (long) number;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CONV_H */

35
ext/dom/lexbor/lexbor/core/core.h Normal file
View file

@ -0,0 +1,35 @@
/*
* Copyright (C) 2020 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CORE_H
#define LEXBOR_CORE_H
#include "lexbor/core/base.h"
#include "lexbor/core/def.h"
#include "lexbor/core/types.h"
#include "lexbor/core/array.h"
#include "lexbor/core/array_obj.h"
#include "lexbor/core/avl.h"
#include "lexbor/core/bst.h"
#include "lexbor/core/bst_map.h"
#include "lexbor/core/dobject.h"
#include "lexbor/core/fs.h"
#include "lexbor/core/in.h"
#include "lexbor/core/lexbor.h"
#include "lexbor/core/mem.h"
#include "lexbor/core/mraw.h"
#include "lexbor/core/perf.h"
#include "lexbor/core/sbst.h"
#include "lexbor/core/shs.h"
#include "lexbor/core/str.h"
#include "lexbor/core/conv.h"
#include "lexbor/core/utils.h"
#include "lexbor/core/diyfp.h"
#include "lexbor/core/dtoa.h"
#include "lexbor/core/strtod.h"
#include "lexbor/core/serialize.h"
#endif /* LEXBOR_CORE_H */

57
ext/dom/lexbor/lexbor/core/def.h Executable file
View file

@ -0,0 +1,57 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_DEF_H
#define LEXBOR_DEF_H
#define LEXBOR_STRINGIZE_HELPER(x) #x
#define LEXBOR_STRINGIZE(x) LEXBOR_STRINGIZE_HELPER(x)
/* Format */
#ifdef _WIN32
#define LEXBOR_FORMAT_Z "%Iu"
#else
#define LEXBOR_FORMAT_Z "%zu"
#endif
/* Deprecated */
#ifdef _MSC_VER
#define LXB_DEPRECATED(func) __declspec(deprecated) func
#elif defined(__GNUC__) || defined(__INTEL_COMPILER)
#define LXB_DEPRECATED(func) func __attribute__((deprecated))
#else
#define LXB_DEPRECATED(func) func
#endif
/* Debug */
//#define LEXBOR_DEBUG(...) do {} while (0)
//#define LEXBOR_DEBUG_ERROR(...) do {} while (0)
#define LEXBOR_MEM_ALIGN_STEP sizeof(void *)
#ifndef LEXBOR_STATIC
#ifdef _WIN32
#ifdef LEXBOR_BUILDING
#define LXB_API __declspec(dllexport)
#else
#define LXB_API __declspec(dllimport)
#endif
#elif (defined(__SUNPRO_C) || defined(__SUNPRO_CC))
#define LXB_API __global
#else
#if (defined(__GNUC__) && __GNUC__ >= 4) || defined(__INTEL_COMPILER)
#define LXB_API __attribute__ ((visibility("default")))
#else
#define LXB_API
#endif
#endif
#else
#define LXB_API
#endif
#define LXB_EXTERN extern LXB_API
#endif /* LEXBOR_DEF_H */

153
ext/dom/lexbor/lexbor/core/diyfp.c Executable file
View file

@ -0,0 +1,153 @@
/*
* Copyright (C) Alexander Borisov
*
* Based on nxt_diyfp.c from NGINX NJS project
*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* An internal diy_fp implementation.
* For details, see Loitsch, Florian. "Printing floating-point numbers quickly
* and accurately with integers." ACM Sigplan Notices 45.6 (2010): 233-243.
*/
#include "lexbor/core/diyfp.h"
typedef struct {
uint64_t significand;
int16_t bin_exp;
int16_t dec_exp;
}
lexbor_diyfp_cpe_t;
static const lexbor_diyfp_cpe_t lexbor_cached_powers[] = {
{ lexbor_uint64_hl(0xfa8fd5a0, 0x081c0288), -1220, -348 },
{ lexbor_uint64_hl(0xbaaee17f, 0xa23ebf76), -1193, -340 },
{ lexbor_uint64_hl(0x8b16fb20, 0x3055ac76), -1166, -332 },
{ lexbor_uint64_hl(0xcf42894a, 0x5dce35ea), -1140, -324 },
{ lexbor_uint64_hl(0x9a6bb0aa, 0x55653b2d), -1113, -316 },
{ lexbor_uint64_hl(0xe61acf03, 0x3d1a45df), -1087, -308 },
{ lexbor_uint64_hl(0xab70fe17, 0xc79ac6ca), -1060, -300 },
{ lexbor_uint64_hl(0xff77b1fc, 0xbebcdc4f), -1034, -292 },
{ lexbor_uint64_hl(0xbe5691ef, 0x416bd60c), -1007, -284 },
{ lexbor_uint64_hl(0x8dd01fad, 0x907ffc3c), -980, -276 },
{ lexbor_uint64_hl(0xd3515c28, 0x31559a83), -954, -268 },
{ lexbor_uint64_hl(0x9d71ac8f, 0xada6c9b5), -927, -260 },
{ lexbor_uint64_hl(0xea9c2277, 0x23ee8bcb), -901, -252 },
{ lexbor_uint64_hl(0xaecc4991, 0x4078536d), -874, -244 },
{ lexbor_uint64_hl(0x823c1279, 0x5db6ce57), -847, -236 },
{ lexbor_uint64_hl(0xc2109436, 0x4dfb5637), -821, -228 },
{ lexbor_uint64_hl(0x9096ea6f, 0x3848984f), -794, -220 },
{ lexbor_uint64_hl(0xd77485cb, 0x25823ac7), -768, -212 },
{ lexbor_uint64_hl(0xa086cfcd, 0x97bf97f4), -741, -204 },
{ lexbor_uint64_hl(0xef340a98, 0x172aace5), -715, -196 },
{ lexbor_uint64_hl(0xb23867fb, 0x2a35b28e), -688, -188 },
{ lexbor_uint64_hl(0x84c8d4df, 0xd2c63f3b), -661, -180 },
{ lexbor_uint64_hl(0xc5dd4427, 0x1ad3cdba), -635, -172 },
{ lexbor_uint64_hl(0x936b9fce, 0xbb25c996), -608, -164 },
{ lexbor_uint64_hl(0xdbac6c24, 0x7d62a584), -582, -156 },
{ lexbor_uint64_hl(0xa3ab6658, 0x0d5fdaf6), -555, -148 },
{ lexbor_uint64_hl(0xf3e2f893, 0xdec3f126), -529, -140 },
{ lexbor_uint64_hl(0xb5b5ada8, 0xaaff80b8), -502, -132 },
{ lexbor_uint64_hl(0x87625f05, 0x6c7c4a8b), -475, -124 },
{ lexbor_uint64_hl(0xc9bcff60, 0x34c13053), -449, -116 },
{ lexbor_uint64_hl(0x964e858c, 0x91ba2655), -422, -108 },
{ lexbor_uint64_hl(0xdff97724, 0x70297ebd), -396, -100 },
{ lexbor_uint64_hl(0xa6dfbd9f, 0xb8e5b88f), -369, -92 },
{ lexbor_uint64_hl(0xf8a95fcf, 0x88747d94), -343, -84 },
{ lexbor_uint64_hl(0xb9447093, 0x8fa89bcf), -316, -76 },
{ lexbor_uint64_hl(0x8a08f0f8, 0xbf0f156b), -289, -68 },
{ lexbor_uint64_hl(0xcdb02555, 0x653131b6), -263, -60 },
{ lexbor_uint64_hl(0x993fe2c6, 0xd07b7fac), -236, -52 },
{ lexbor_uint64_hl(0xe45c10c4, 0x2a2b3b06), -210, -44 },
{ lexbor_uint64_hl(0xaa242499, 0x697392d3), -183, -36 },
{ lexbor_uint64_hl(0xfd87b5f2, 0x8300ca0e), -157, -28 },
{ lexbor_uint64_hl(0xbce50864, 0x92111aeb), -130, -20 },
{ lexbor_uint64_hl(0x8cbccc09, 0x6f5088cc), -103, -12 },
{ lexbor_uint64_hl(0xd1b71758, 0xe219652c), -77, -4 },
{ lexbor_uint64_hl(0x9c400000, 0x00000000), -50, 4 },
{ lexbor_uint64_hl(0xe8d4a510, 0x00000000), -24, 12 },
{ lexbor_uint64_hl(0xad78ebc5, 0xac620000), 3, 20 },
{ lexbor_uint64_hl(0x813f3978, 0xf8940984), 30, 28 },
{ lexbor_uint64_hl(0xc097ce7b, 0xc90715b3), 56, 36 },
{ lexbor_uint64_hl(0x8f7e32ce, 0x7bea5c70), 83, 44 },
{ lexbor_uint64_hl(0xd5d238a4, 0xabe98068), 109, 52 },
{ lexbor_uint64_hl(0x9f4f2726, 0x179a2245), 136, 60 },
{ lexbor_uint64_hl(0xed63a231, 0xd4c4fb27), 162, 68 },
{ lexbor_uint64_hl(0xb0de6538, 0x8cc8ada8), 189, 76 },
{ lexbor_uint64_hl(0x83c7088e, 0x1aab65db), 216, 84 },
{ lexbor_uint64_hl(0xc45d1df9, 0x42711d9a), 242, 92 },
{ lexbor_uint64_hl(0x924d692c, 0xa61be758), 269, 100 },
{ lexbor_uint64_hl(0xda01ee64, 0x1a708dea), 295, 108 },
{ lexbor_uint64_hl(0xa26da399, 0x9aef774a), 322, 116 },
{ lexbor_uint64_hl(0xf209787b, 0xb47d6b85), 348, 124 },
{ lexbor_uint64_hl(0xb454e4a1, 0x79dd1877), 375, 132 },
{ lexbor_uint64_hl(0x865b8692, 0x5b9bc5c2), 402, 140 },
{ lexbor_uint64_hl(0xc83553c5, 0xc8965d3d), 428, 148 },
{ lexbor_uint64_hl(0x952ab45c, 0xfa97a0b3), 455, 156 },
{ lexbor_uint64_hl(0xde469fbd, 0x99a05fe3), 481, 164 },
{ lexbor_uint64_hl(0xa59bc234, 0xdb398c25), 508, 172 },
{ lexbor_uint64_hl(0xf6c69a72, 0xa3989f5c), 534, 180 },
{ lexbor_uint64_hl(0xb7dcbf53, 0x54e9bece), 561, 188 },
{ lexbor_uint64_hl(0x88fcf317, 0xf22241e2), 588, 196 },
{ lexbor_uint64_hl(0xcc20ce9b, 0xd35c78a5), 614, 204 },
{ lexbor_uint64_hl(0x98165af3, 0x7b2153df), 641, 212 },
{ lexbor_uint64_hl(0xe2a0b5dc, 0x971f303a), 667, 220 },
{ lexbor_uint64_hl(0xa8d9d153, 0x5ce3b396), 694, 228 },
{ lexbor_uint64_hl(0xfb9b7cd9, 0xa4a7443c), 720, 236 },
{ lexbor_uint64_hl(0xbb764c4c, 0xa7a44410), 747, 244 },
{ lexbor_uint64_hl(0x8bab8eef, 0xb6409c1a), 774, 252 },
{ lexbor_uint64_hl(0xd01fef10, 0xa657842c), 800, 260 },
{ lexbor_uint64_hl(0x9b10a4e5, 0xe9913129), 827, 268 },
{ lexbor_uint64_hl(0xe7109bfb, 0xa19c0c9d), 853, 276 },
{ lexbor_uint64_hl(0xac2820d9, 0x623bf429), 880, 284 },
{ lexbor_uint64_hl(0x80444b5e, 0x7aa7cf85), 907, 292 },
{ lexbor_uint64_hl(0xbf21e440, 0x03acdd2d), 933, 300 },
{ lexbor_uint64_hl(0x8e679c2f, 0x5e44ff8f), 960, 308 },
{ lexbor_uint64_hl(0xd433179d, 0x9c8cb841), 986, 316 },
{ lexbor_uint64_hl(0x9e19db92, 0xb4e31ba9), 1013, 324 },
{ lexbor_uint64_hl(0xeb96bf6e, 0xbadf77d9), 1039, 332 },
{ lexbor_uint64_hl(0xaf87023b, 0x9bf0ee6b), 1066, 340 },
};
#define LEXBOR_DIYFP_D_1_LOG2_10 0.30102999566398114 /* 1 / log2(10). */
lexbor_diyfp_t
lexbor_cached_power_dec(int exp, int *dec_exp)
{
unsigned int index;
const lexbor_diyfp_cpe_t *cp;
index = (exp + LEXBOR_DECIMAL_EXPONENT_OFF) / LEXBOR_DECIMAL_EXPONENT_DIST;
cp = &lexbor_cached_powers[index];
*dec_exp = cp->dec_exp;
return lexbor_diyfp(cp->significand, cp->bin_exp);
}
lexbor_diyfp_t
lexbor_cached_power_bin(int exp, int *dec_exp)
{
int k;
unsigned int index;
const lexbor_diyfp_cpe_t *cp;
k = (int) ceil((-61 - exp) * LEXBOR_DIYFP_D_1_LOG2_10)
+ LEXBOR_DECIMAL_EXPONENT_OFF - 1;
index = (unsigned) (k >> 3) + 1;
cp = &lexbor_cached_powers[index];
*dec_exp = -(LEXBOR_DECIMAL_EXPONENT_MIN + (int) (index << 3));
return lexbor_diyfp(cp->significand, cp->bin_exp);
}
#undef LEXBOR_DIYFP_D_1_LOG2_10

258
ext/dom/lexbor/lexbor/core/diyfp.h Executable file
View file

@ -0,0 +1,258 @@
/*
* Copyright (C) Alexander Borisov
*
* Based on nxt_diyfp.h from NGINX NJS project
*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* An internal diy_fp implementation.
* For details, see Loitsch, Florian. "Printing floating-point numbers quickly
* and accurately with integers." ACM Sigplan Notices 45.6 (2010): 233-243.
*/
#ifndef LEXBOR_DIYFP_H
#define LEXBOR_DIYFP_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include <math.h>
#ifdef __cplusplus
#define lexbor_diyfp(_s, _e) { .significand = (_s), .exp = (int) (_e) }
#else
#define lexbor_diyfp(_s, _e) (lexbor_diyfp_t) \
{ .significand = (_s), .exp = (int) (_e) }
#endif
#define lexbor_uint64_hl(h, l) (((uint64_t) (h) << 32) + (l))
#define LEXBOR_DBL_SIGNIFICAND_SIZE 52
#define LEXBOR_DBL_EXPONENT_BIAS (0x3FF + LEXBOR_DBL_SIGNIFICAND_SIZE)
#define LEXBOR_DBL_EXPONENT_MIN (-LEXBOR_DBL_EXPONENT_BIAS)
#define LEXBOR_DBL_EXPONENT_MAX (0x7FF - LEXBOR_DBL_EXPONENT_BIAS)
#define LEXBOR_DBL_EXPONENT_DENORMAL (-LEXBOR_DBL_EXPONENT_BIAS + 1)
#define LEXBOR_DBL_SIGNIFICAND_MASK lexbor_uint64_hl(0x000FFFFF, 0xFFFFFFFF)
#define LEXBOR_DBL_HIDDEN_BIT lexbor_uint64_hl(0x00100000, 0x00000000)
#define LEXBOR_DBL_EXPONENT_MASK lexbor_uint64_hl(0x7FF00000, 0x00000000)
#define LEXBOR_DIYFP_SIGNIFICAND_SIZE 64
#define LEXBOR_SIGNIFICAND_SIZE 53
#define LEXBOR_SIGNIFICAND_SHIFT (LEXBOR_DIYFP_SIGNIFICAND_SIZE \
- LEXBOR_DBL_SIGNIFICAND_SIZE)
#define LEXBOR_DECIMAL_EXPONENT_OFF 348
#define LEXBOR_DECIMAL_EXPONENT_MIN (-348)
#define LEXBOR_DECIMAL_EXPONENT_MAX 340
#define LEXBOR_DECIMAL_EXPONENT_DIST 8
typedef struct {
uint64_t significand;
int exp;
}
lexbor_diyfp_t;
LXB_API lexbor_diyfp_t
lexbor_cached_power_dec(int exp, int *dec_exp);
LXB_API lexbor_diyfp_t
lexbor_cached_power_bin(int exp, int *dec_exp);
/*
* Inline functions
*/
#if (LEXBOR_HAVE_BUILTIN_CLZLL)
#define nxt_leading_zeros64(x) (((x) == 0) ? 64 : __builtin_clzll(x))
#else
lxb_inline uint64_t
lexbor_diyfp_leading_zeros64(uint64_t x)
{
uint64_t n;
if (x == 0) {
return 64;
}
n = 0;
while ((x & 0x8000000000000000) == 0) {
n++;
x <<= 1;
}
return n;
}
#endif
lxb_inline lexbor_diyfp_t
lexbor_diyfp_from_d2(double d)
{
int biased_exp;
uint64_t significand;
lexbor_diyfp_t r;
union {
double d;
uint64_t u64;
}
u;
u.d = d;
biased_exp = (u.u64 & LEXBOR_DBL_EXPONENT_MASK)
>> LEXBOR_DBL_SIGNIFICAND_SIZE;
significand = u.u64 & LEXBOR_DBL_SIGNIFICAND_MASK;
if (biased_exp != 0) {
r.significand = significand + LEXBOR_DBL_HIDDEN_BIT;
r.exp = biased_exp - LEXBOR_DBL_EXPONENT_BIAS;
}
else {
r.significand = significand;
r.exp = LEXBOR_DBL_EXPONENT_MIN + 1;
}
return r;
}
lxb_inline double
lexbor_diyfp_2d(lexbor_diyfp_t v)
{
int exp;
uint64_t significand, biased_exp;
union {
double d;
uint64_t u64;
}
u;
exp = v.exp;
significand = v.significand;
while (significand > LEXBOR_DBL_HIDDEN_BIT + LEXBOR_DBL_SIGNIFICAND_MASK) {
significand >>= 1;
exp++;
}
if (exp >= LEXBOR_DBL_EXPONENT_MAX) {
return INFINITY;
}
if (exp < LEXBOR_DBL_EXPONENT_DENORMAL) {
return 0.0;
}
while (exp > LEXBOR_DBL_EXPONENT_DENORMAL
&& (significand & LEXBOR_DBL_HIDDEN_BIT) == 0)
{
significand <<= 1;
exp--;
}
if (exp == LEXBOR_DBL_EXPONENT_DENORMAL
&& (significand & LEXBOR_DBL_HIDDEN_BIT) == 0)
{
biased_exp = 0;
} else {
biased_exp = (uint64_t) (exp + LEXBOR_DBL_EXPONENT_BIAS);
}
u.u64 = (significand & LEXBOR_DBL_SIGNIFICAND_MASK)
| (biased_exp << LEXBOR_DBL_SIGNIFICAND_SIZE);
return u.d;
}
lxb_inline lexbor_diyfp_t
lexbor_diyfp_shift_left(lexbor_diyfp_t v, unsigned shift)
{
return lexbor_diyfp(v.significand << shift, v.exp - shift);
}
lxb_inline lexbor_diyfp_t
lexbor_diyfp_shift_right(lexbor_diyfp_t v, unsigned shift)
{
return lexbor_diyfp(v.significand >> shift, v.exp + shift);
}
lxb_inline lexbor_diyfp_t
lexbor_diyfp_sub(lexbor_diyfp_t lhs, lexbor_diyfp_t rhs)
{
return lexbor_diyfp(lhs.significand - rhs.significand, lhs.exp);
}
lxb_inline lexbor_diyfp_t
lexbor_diyfp_mul(lexbor_diyfp_t lhs, lexbor_diyfp_t rhs)
{
#if (LEXBOR_HAVE_UNSIGNED_INT128)
uint64_t l, h;
lxb_uint128_t u128;
u128 = (lxb_uint128_t) (lhs.significand)
* (lxb_uint128_t) (rhs.significand);
h = u128 >> 64;
l = (uint64_t) u128;
/* rounding. */
if (l & ((uint64_t) 1 << 63)) {
h++;
}
return lexbor_diyfp(h, lhs.exp + rhs.exp + 64);
#else
uint64_t a, b, c, d, ac, bc, ad, bd, tmp;
a = lhs.significand >> 32;
b = lhs.significand & 0xffffffff;
c = rhs.significand >> 32;
d = rhs.significand & 0xffffffff;
ac = a * c;
bc = b * c;
ad = a * d;
bd = b * d;
tmp = (bd >> 32) + (ad & 0xffffffff) + (bc & 0xffffffff);
/* mult_round. */
tmp += 1U << 31;
return lexbor_diyfp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32),
lhs.exp + rhs.exp + 64);
#endif
}
lxb_inline lexbor_diyfp_t
lexbor_diyfp_normalize(lexbor_diyfp_t v)
{
return lexbor_diyfp_shift_left(v,
(unsigned) lexbor_diyfp_leading_zeros64(v.significand));
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_DIYFP_H */

187
ext/dom/lexbor/lexbor/core/dobject.c Executable file
View file

@ -0,0 +1,187 @@
/*
* Copyright (C) 2018-2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/dobject.h"
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
#include <sanitizer/asan_interface.h>
#endif
lexbor_dobject_t *
lexbor_dobject_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_dobject_t));
}
lxb_status_t
lexbor_dobject_init(lexbor_dobject_t *dobject,
size_t chunk_size, size_t struct_size)
{
lxb_status_t status;
if (dobject == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (chunk_size == 0 || struct_size == 0) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
/* Set params */
dobject->allocated = 0UL;
dobject->struct_size = struct_size;
/* Init memory */
dobject->mem = lexbor_mem_create();
status = lexbor_mem_init(dobject->mem,
lexbor_mem_align(chunk_size * dobject->struct_size));
if (status) {
return status;
}
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(dobject->mem->chunk->data,
dobject->mem->chunk->size);
#endif
/* Array */
dobject->cache = lexbor_array_create();
status = lexbor_array_init(dobject->cache, chunk_size);
if (status)
return status;
return LXB_STATUS_OK;
}
void
lexbor_dobject_clean(lexbor_dobject_t *dobject)
{
if (dobject != NULL) {
dobject->allocated = 0UL;
lexbor_mem_clean(dobject->mem);
lexbor_array_clean(dobject->cache);
}
}
lexbor_dobject_t *
lexbor_dobject_destroy(lexbor_dobject_t *dobject, bool destroy_self)
{
if (dobject == NULL)
return NULL;
dobject->mem = lexbor_mem_destroy(dobject->mem, true);
dobject->cache = lexbor_array_destroy(dobject->cache, true);
if (destroy_self == true) {
return lexbor_free(dobject);
}
return dobject;
}
void *
lexbor_dobject_alloc(lexbor_dobject_t *dobject)
{
void *data;
if (lexbor_array_length(dobject->cache) != 0) {
dobject->allocated++;
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
data = lexbor_array_pop(dobject->cache);
ASAN_UNPOISON_MEMORY_REGION(data, dobject->struct_size);
return data;
#else
return lexbor_array_pop(dobject->cache);
#endif
}
data = lexbor_mem_alloc(dobject->mem, dobject->struct_size);
if (data == NULL) {
return NULL;
}
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_UNPOISON_MEMORY_REGION(data, dobject->struct_size);
#endif
dobject->allocated++;
return data;
}
void *
lexbor_dobject_calloc(lexbor_dobject_t *dobject)
{
void *data = lexbor_dobject_alloc(dobject);
if (data != NULL) {
memset(data, 0, dobject->struct_size);
}
return data;
}
void *
lexbor_dobject_free(lexbor_dobject_t *dobject, void *data)
{
if (data == NULL) {
return NULL;
}
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(data, dobject->struct_size);
#endif
if (lexbor_array_push(dobject->cache, data) == LXB_STATUS_OK) {
dobject->allocated--;
return NULL;
}
return data;
}
void *
lexbor_dobject_by_absolute_position(lexbor_dobject_t *dobject, size_t pos)
{
size_t chunk_idx, chunk_pos, i;
lexbor_mem_chunk_t *chunk;
if (pos >= dobject->allocated) {
return NULL;
}
chunk = dobject->mem->chunk_first;
chunk_pos = pos * dobject->struct_size;
chunk_idx = chunk_pos / dobject->mem->chunk_min_size;
for (i = 0; i < chunk_idx; i++) {
chunk = chunk->next;
}
return &chunk->data[chunk_pos % chunk->size];
}
/*
* No inline functions for ABI.
*/
size_t
lexbor_dobject_allocated_noi(lexbor_dobject_t *dobject)
{
return lexbor_dobject_allocated(dobject);
}
size_t
lexbor_dobject_cache_length_noi(lexbor_dobject_t *dobject)
{
return lexbor_dobject_cache_length(dobject);
}

92
ext/dom/lexbor/lexbor/core/dobject.h Executable file
View file

@ -0,0 +1,92 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_DOBJECT_H
#define LEXBOR_DOBJECT_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/core/mem.h"
#include "lexbor/core/array.h"
typedef struct {
lexbor_mem_t *mem;
lexbor_array_t *cache;
size_t allocated;
size_t struct_size;
}
lexbor_dobject_t;
LXB_API lexbor_dobject_t *
lexbor_dobject_create(void);
LXB_API lxb_status_t
lexbor_dobject_init(lexbor_dobject_t *dobject,
size_t chunk_size, size_t struct_size);
LXB_API void
lexbor_dobject_clean(lexbor_dobject_t *dobject);
LXB_API lexbor_dobject_t *
lexbor_dobject_destroy(lexbor_dobject_t *dobject, bool destroy_self);
LXB_API uint8_t *
lexbor_dobject_init_list_entries(lexbor_dobject_t *dobject, size_t pos);
LXB_API void *
lexbor_dobject_alloc(lexbor_dobject_t *dobject);
LXB_API void *
lexbor_dobject_calloc(lexbor_dobject_t *dobject);
LXB_API void *
lexbor_dobject_free(lexbor_dobject_t *dobject, void *data);
LXB_API void *
lexbor_dobject_by_absolute_position(lexbor_dobject_t *dobject, size_t pos);
/*
* Inline functions
*/
lxb_inline size_t
lexbor_dobject_allocated(lexbor_dobject_t *dobject)
{
return dobject->allocated;
}
lxb_inline size_t
lexbor_dobject_cache_length(lexbor_dobject_t *dobject)
{
return lexbor_array_length(dobject->cache);
}
/*
* No inline functions for ABI.
*/
LXB_API size_t
lexbor_dobject_allocated_noi(lexbor_dobject_t *dobject);
LXB_API size_t
lexbor_dobject_cache_length_noi(lexbor_dobject_t *dobject);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_DOBJECT_H */

404
ext/dom/lexbor/lexbor/core/dtoa.c Executable file
View file

@ -0,0 +1,404 @@
/*
* Copyright (C) Alexander Borisov
*
* Based on nxt_dtoa.c from NGINX NJS project
*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* Grisu2 algorithm implementation for printing floating-point numbers based
* upon the work of Milo Yip and Doug Currie.
*
* For algorithm information, see Loitsch, Florian. "Printing
* floating-point numbers quickly and accurately with integers." ACM Sigplan
* Notices 45.6 (2010): 233-243.
*
* Copyright (C) 2015 Doug Currie
* based on dtoa_milo.h
* Copyright (C) 2014 Milo Yip
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "lexbor/core/str.h"
#include "lexbor/core/diyfp.h"
#include "lexbor/core/dtoa.h"
#include <math.h>
#include <string.h>
lxb_inline void
lexbor_grisu2_round(lxb_char_t *start, size_t len, uint64_t delta, uint64_t rest,
uint64_t ten_kappa, uint64_t wp_w)
{
while (rest < wp_w && delta - rest >= ten_kappa
&& (rest + ten_kappa < wp_w || /* closer */
wp_w - rest > rest + ten_kappa - wp_w))
{
start[len - 1]--;
rest += ten_kappa;
}
}
lxb_inline int
lexbor_dec_count(uint32_t n)
{
if (n < 10) return 1;
if (n < 100) return 2;
if (n < 1000) return 3;
if (n < 10000) return 4;
if (n < 100000) return 5;
if (n < 1000000) return 6;
if (n < 10000000) return 7;
if (n < 100000000) return 8;
if (n < 1000000000) return 9;
return 10;
}
lxb_inline size_t
lexbor_grisu2_gen(lexbor_diyfp_t W, lexbor_diyfp_t Mp, uint64_t delta,
lxb_char_t *begin, lxb_char_t *end, int *dec_exp)
{
int kappa;
lxb_char_t c, *p;
uint32_t p1, d;
uint64_t p2, tmp;
lexbor_diyfp_t one, wp_w;
static const uint64_t pow10[] = {
1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000
};
wp_w = lexbor_diyfp_sub(Mp, W);
one = lexbor_diyfp((uint64_t) 1 << -Mp.exp, Mp.exp);
p1 = (uint32_t) (Mp.significand >> -one.exp);
p2 = Mp.significand & (one.significand - 1);
p = begin;
/* GCC 4.2 complains about uninitialized d. */
d = 0;
kappa = lexbor_dec_count(p1);
while (kappa > 0) {
switch (kappa) {
case 10: d = p1 / 1000000000; p1 %= 1000000000; break;
case 9: d = p1 / 100000000; p1 %= 100000000; break;
case 8: d = p1 / 10000000; p1 %= 10000000; break;
case 7: d = p1 / 1000000; p1 %= 1000000; break;
case 6: d = p1 / 100000; p1 %= 100000; break;
case 5: d = p1 / 10000; p1 %= 10000; break;
case 4: d = p1 / 1000; p1 %= 1000; break;
case 3: d = p1 / 100; p1 %= 100; break;
case 2: d = p1 / 10; p1 %= 10; break;
case 1: d = p1; p1 = 0; break;
default:
/* Never go here. */
return 0;
}
if (d != 0 || p != begin) {
*p = '0' + d;
p += 1;
if (p == end) {
return p - begin;
}
}
kappa--;
tmp = ((uint64_t) p1 << -one.exp) + p2;
if (tmp <= delta) {
*dec_exp += kappa;
lexbor_grisu2_round(begin, p - begin, delta, tmp,
pow10[kappa] << -one.exp, wp_w.significand);
return p - begin;
}
}
/* kappa = 0. */
for ( ;; ) {
p2 *= 10;
delta *= 10;
c = (char) (p2 >> -one.exp);
if (c != 0 || p != begin) {
*p = '0' + c;
p += 1;
if (p == end) {
return p - begin;
}
}
p2 &= one.significand - 1;
kappa--;
if (p2 < delta) {
*dec_exp += kappa;
tmp = (-kappa < 10) ? pow10[-kappa] : 0;
lexbor_grisu2_round(begin, p - begin, delta, p2, one.significand,
wp_w.significand * tmp);
break;
}
}
return p - begin;
}
lxb_inline lexbor_diyfp_t
lexbor_diyfp_normalize_boundary(lexbor_diyfp_t v)
{
while ((v.significand & (LEXBOR_DBL_HIDDEN_BIT << 1)) == 0) {
v.significand <<= 1;
v.exp--;
}
return lexbor_diyfp_shift_left(v, LEXBOR_SIGNIFICAND_SHIFT - 2);
}
lxb_inline void
lexbor_diyfp_normalize_boundaries(lexbor_diyfp_t v, lexbor_diyfp_t* minus,
lexbor_diyfp_t* plus)
{
lexbor_diyfp_t pl, mi;
pl = lexbor_diyfp_normalize_boundary(lexbor_diyfp((v.significand << 1) + 1,
v.exp - 1));
if (v.significand == LEXBOR_DBL_HIDDEN_BIT) {
mi = lexbor_diyfp((v.significand << 2) - 1, v.exp - 2);
} else {
mi = lexbor_diyfp((v.significand << 1) - 1, v.exp - 1);
}
mi.significand <<= mi.exp - pl.exp;
mi.exp = pl.exp;
*plus = pl;
*minus = mi;
}
lxb_inline size_t
lexbor_grisu2(double value, lxb_char_t *begin, lxb_char_t *end, int *dec_exp)
{
lexbor_diyfp_t v, w_m, w_p, c_mk, W, Wp, Wm;
v = lexbor_diyfp_from_d2(value);
lexbor_diyfp_normalize_boundaries(v, &w_m, &w_p);
c_mk = lexbor_cached_power_bin(w_p.exp, dec_exp);
W = lexbor_diyfp_mul(lexbor_diyfp_normalize(v), c_mk);
Wp = lexbor_diyfp_mul(w_p, c_mk);
Wm = lexbor_diyfp_mul(w_m, c_mk);
Wm.significand++;
Wp.significand--;
return lexbor_grisu2_gen(W, Wp, Wp.significand - Wm.significand, begin, end,
dec_exp);
}
lxb_inline size_t
lexbor_write_exponent(int exp, lxb_char_t *begin, lxb_char_t *end)
{
char *p;
size_t len;
uint32_t u32;
char buf[4];
/* -324 <= exp <= 308. */
if ((begin + (sizeof(buf) - 1) + 1) >= end) {
return 0;
}
if (exp < 0) {
*begin = '-';
begin += 1;
exp = -exp;
}
else {
*begin++ = '+';
}
u32 = exp;
p = buf + (sizeof(buf) - 1);
do {
*--p = u32 % 10 + '0';
u32 /= 10;
}
while (u32 != 0);
len = buf + (sizeof(buf) - 1) - p;
memcpy(begin, p, len);
return len + 1;
}
lxb_inline size_t
lexbor_prettify(lxb_char_t *begin, lxb_char_t *end, size_t len, int dec_exp)
{
int kk, offset, length;
size_t size;
/* 10^(kk-1) <= v < 10^kk */
length = (int) len;
kk = length + dec_exp;
if (length <= kk && kk <= 21) {
/* 1234e7 -> 12340000000 */
if (kk - length > 0) {
if ((&begin[length] + (kk - length)) < end) {
memset(&begin[length], '0', kk - length);
}
else {
memset(&begin[length], '0', (end - &begin[length]));
}
}
return kk;
}
else if (0 < kk && kk <= 21) {
/* 1234e-2 -> 12.34 */
if ((&begin[kk + 1] + (length - kk)) >= end) {
return length;
}
memmove(&begin[kk + 1], &begin[kk], length - kk);
begin[kk] = '.';
return (length + 1);
}
else if (-6 < kk && kk <= 0) {
/* 1234e-6 -> 0.001234 */
offset = 2 - kk;
if ((&begin[offset] + length) >= end
|| (begin + 2) >= end)
{
return length;
}
memmove(&begin[offset], begin, length);
begin[0] = '0';
begin[1] = '.';
if (offset - 2 > 0) {
if ((&begin[2] + (offset - 2)) >= end) {
return length;
}
memset(&begin[2], '0', offset - 2);
}
return (length + offset);
}
else if (length == 1) {
/* 1e30 */
if ((begin + 1) >= end) {
return length;
}
begin[1] = 'e';
size = lexbor_write_exponent(kk - 1, &begin[2], end);
return (size + 2);
}
/* 1234e30 -> 1.234e33 */
if ((&begin[2] + (length - 1)) >= end) {
return length;
}
memmove(&begin[2], &begin[1], length - 1);
begin[1] = '.';
begin[length + 1] = 'e';
size = lexbor_write_exponent(kk - 1, &begin[length + 2], end);
return (size + length + 2);
}
size_t
lexbor_dtoa(double value, lxb_char_t *begin, size_t len)
{
int dec_exp, minus;
size_t length;
lxb_char_t *end = begin + len;
if (len == 0) {
return 0;
}
/* Not handling NaN and inf. */
minus = 0;
if (value == 0) {
*begin = '0';
return 1;
}
if (signbit(value)) {
*begin = '-';
begin += 1;
if (begin == end) {
return 1;
}
value = -value;
minus = 1;
}
length = lexbor_grisu2(value, begin, end, &dec_exp);
length = lexbor_prettify(begin, end, length, dec_exp);
return (minus + length);
}

28
ext/dom/lexbor/lexbor/core/dtoa.h Executable file
View file

@ -0,0 +1,28 @@
/*
* Copyright (C) Alexander Borisov
*
* Based on nxt_dtoa.h from NGINX NJS project
*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) Nginx, Inc.
*/
#ifndef LEXBOR_DTOA_H
#define LEXBOR_DTOA_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
LXB_API size_t
lexbor_dtoa(double value, lxb_char_t *begin, size_t len);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_DTOA_H */

60
ext/dom/lexbor/lexbor/core/fs.h Executable file
View file

@ -0,0 +1,60 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_FS_H
#define LEXBOR_FS_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
typedef lexbor_action_t (*lexbor_fs_dir_file_f)(const lxb_char_t *fullpath,
size_t fullpath_len,
const lxb_char_t *filename,
size_t filename_len, void *ctx);
typedef int lexbor_fs_dir_opt_t;
enum lexbor_fs_dir_opt {
LEXBOR_FS_DIR_OPT_UNDEF = 0x00,
LEXBOR_FS_DIR_OPT_WITHOUT_DIR = 0x01,
LEXBOR_FS_DIR_OPT_WITHOUT_FILE = 0x02,
LEXBOR_FS_DIR_OPT_WITHOUT_HIDDEN = 0x04,
};
typedef enum {
LEXBOR_FS_FILE_TYPE_UNDEF = 0x00,
LEXBOR_FS_FILE_TYPE_FILE = 0x01,
LEXBOR_FS_FILE_TYPE_DIRECTORY = 0x02,
LEXBOR_FS_FILE_TYPE_BLOCK_DEVICE = 0x03,
LEXBOR_FS_FILE_TYPE_CHARACTER_DEVICE = 0x04,
LEXBOR_FS_FILE_TYPE_PIPE = 0x05,
LEXBOR_FS_FILE_TYPE_SYMLINK = 0x06,
LEXBOR_FS_FILE_TYPE_SOCKET = 0x07
}
lexbor_fs_file_type_t;
LXB_API 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);
LXB_API lexbor_fs_file_type_t
lexbor_fs_file_type(const lxb_char_t *full_path);
LXB_API lxb_char_t *
lexbor_fs_file_easy_read(const lxb_char_t *full_path, size_t *len);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_FS_H */

476
ext/dom/lexbor/lexbor/core/hash.c Normal file
View file

@ -0,0 +1,476 @@
/*
* Copyright (C) 2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#define LEXBOR_HASH_EXTERN
#include "lexbor/core/hash.h"
#undef LEXBOR_HASH_EXTERN
#include "lexbor/core/str.h"
#define LEXBOR_STR_RES_MAP_LOWERCASE
#define LEXBOR_STR_RES_MAP_UPPERCASE
#include "lexbor/core/str_res.h"
/* Insert variable. */
const lexbor_hash_insert_t lexbor_hash_insert_var = {
.hash = lexbor_hash_make_id,
.copy = lexbor_hash_copy,
.cmp = lexbor_str_data_ncmp
};
const lexbor_hash_insert_t lexbor_hash_insert_lower_var = {
.hash = lexbor_hash_make_id_lower,
.copy = lexbor_hash_copy_lower,
.cmp = lexbor_str_data_nlocmp_right
};
const lexbor_hash_insert_t lexbor_hash_insert_upper_var = {
.hash = lexbor_hash_make_id_upper,
.copy = lexbor_hash_copy_upper,
.cmp = lexbor_str_data_nupcmp_right
};
LXB_API const lexbor_hash_insert_t
*lexbor_hash_insert_raw = &lexbor_hash_insert_var;
LXB_API const lexbor_hash_insert_t
*lexbor_hash_insert_lower = &lexbor_hash_insert_lower_var;
LXB_API const lexbor_hash_insert_t
*lexbor_hash_insert_upper = &lexbor_hash_insert_upper_var;
/* Search variable. */
const lexbor_hash_search_t lexbor_hash_search_var = {
.hash = lexbor_hash_make_id,
.cmp = lexbor_str_data_ncmp
};
const lexbor_hash_search_t lexbor_hash_search_lower_var = {
.hash = lexbor_hash_make_id_lower,
.cmp = lexbor_str_data_nlocmp_right
};
const lexbor_hash_search_t lexbor_hash_search_upper_var = {
.hash = lexbor_hash_make_id_upper,
.cmp = lexbor_str_data_nupcmp_right
};
LXB_API const lexbor_hash_search_t
*lexbor_hash_search_raw = &lexbor_hash_search_var;
LXB_API const lexbor_hash_search_t
*lexbor_hash_search_lower = &lexbor_hash_search_lower_var;
LXB_API const lexbor_hash_search_t
*lexbor_hash_search_upper = &lexbor_hash_search_upper_var;
lxb_inline lexbor_hash_entry_t **
lexbor_hash_table_create(lexbor_hash_t *hash)
{
return lexbor_calloc(hash->table_size, sizeof(lexbor_hash_entry_t *));
}
lxb_inline void
lexbor_hash_table_clean(lexbor_hash_t *hash)
{
memset(hash->table, 0, sizeof(lexbor_hash_t *) * hash->table_size);
}
lxb_inline lexbor_hash_entry_t **
lexbor_hash_table_destroy(lexbor_hash_t *hash)
{
if (hash->table != NULL) {
return lexbor_free(hash->table);
}
return NULL;
}
lxb_inline lexbor_hash_entry_t *
_lexbor_hash_entry_create(lexbor_hash_t *hash, const lexbor_hash_copy_f copy_func,
const lxb_char_t *key, size_t length)
{
lexbor_hash_entry_t *entry = lexbor_dobject_calloc(hash->entries);
if (entry == NULL) {
return NULL;
}
entry->length = length;
if (copy_func(hash, entry, key, length) != LXB_STATUS_OK) {
lexbor_dobject_free(hash->entries, entry);
return NULL;
}
return entry;
}
lexbor_hash_t *
lexbor_hash_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_hash_t));
}
lxb_status_t
lexbor_hash_init(lexbor_hash_t *hash, size_t table_size, size_t struct_size)
{
lxb_status_t status;
size_t chunk_size;
if (hash == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (table_size < LEXBOR_HASH_TABLE_MIN_SIZE) {
table_size = LEXBOR_HASH_TABLE_MIN_SIZE;
}
chunk_size = table_size / 2;
hash->table_size = table_size;
hash->entries = lexbor_dobject_create();
status = lexbor_dobject_init(hash->entries, chunk_size, struct_size);
if (status != LXB_STATUS_OK) {
return status;
}
hash->mraw = lexbor_mraw_create();
status = lexbor_mraw_init(hash->mraw, chunk_size * 12);
if (status != LXB_STATUS_OK) {
return status;
}
hash->table = lexbor_hash_table_create(hash);
if (hash->table == NULL) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
hash->struct_size = struct_size;
return LXB_STATUS_OK;
}
void
lexbor_hash_clean(lexbor_hash_t *hash)
{
lexbor_dobject_clean(hash->entries);
lexbor_mraw_clean(hash->mraw);
lexbor_hash_table_clean(hash);
}
lexbor_hash_t *
lexbor_hash_destroy(lexbor_hash_t *hash, bool destroy_obj)
{
if (hash == NULL) {
return NULL;
}
hash->entries = lexbor_dobject_destroy(hash->entries, true);
hash->mraw = lexbor_mraw_destroy(hash->mraw, true);
hash->table = lexbor_hash_table_destroy(hash);
if (destroy_obj) {
return lexbor_free(hash);
}
return hash;
}
void *
lexbor_hash_insert(lexbor_hash_t *hash, const lexbor_hash_insert_t *insert,
const lxb_char_t *key, size_t length)
{
lxb_char_t *str;
uint32_t hash_id, table_idx;
lexbor_hash_entry_t *entry;
hash_id = insert->hash(key, length);
table_idx = hash_id % hash->table_size;
entry = hash->table[table_idx];
if (entry == NULL) {
entry = _lexbor_hash_entry_create(hash, insert->copy, key, length);
hash->table[table_idx] = entry;
return entry;
}
do {
str = lexbor_hash_entry_str(entry);
if (entry->length == length && insert->cmp(str, key, length)) {
return entry;
}
if (entry->next == NULL) {
break;
}
entry = entry->next;
}
while (1);
entry->next = _lexbor_hash_entry_create(hash, insert->copy, key, length);
return entry->next;
}
void *
lexbor_hash_insert_by_entry(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lexbor_hash_search_t *search,
const lxb_char_t *key, size_t length)
{
lxb_char_t *str;
uint32_t hash_id, table_idx;
lexbor_hash_entry_t *item;
hash_id = search->hash(key, length);
table_idx = hash_id % hash->table_size;
item = hash->table[table_idx];
if (item == NULL) {
hash->table[table_idx] = entry;
return entry;
}
do {
str = lexbor_hash_entry_str(item);
if (item->length == length && search->cmp(str, key, length)) {
return item;
}
if (item->next == NULL) {
break;
}
item = item->next;
}
while (1);
item->next = entry;
return entry;
}
void
lexbor_hash_remove(lexbor_hash_t *hash, const lexbor_hash_search_t *search,
const lxb_char_t *key, size_t length)
{
lexbor_hash_remove_by_hash_id(hash, search->hash(key, length),
key, length, search->cmp);
}
void *
lexbor_hash_search(lexbor_hash_t *hash, const lexbor_hash_search_t *search,
const lxb_char_t *key, size_t length)
{
return lexbor_hash_search_by_hash_id(hash, search->hash(key, length),
key, length, search->cmp);
}
void
lexbor_hash_remove_by_hash_id(lexbor_hash_t *hash, uint32_t hash_id,
const lxb_char_t *key, size_t length,
const lexbor_hash_cmp_f cmp_func)
{
uint32_t table_idx;
lxb_char_t *str;
lexbor_hash_entry_t *entry, *prev;
table_idx = hash_id % hash->table_size;
entry = hash->table[table_idx];
prev = NULL;
while (entry != NULL) {
str = lexbor_hash_entry_str(entry);
if (entry->length == length && cmp_func(str, key, length)) {
if (prev == NULL) {
hash->table[table_idx] = entry->next;
}
else {
prev->next = entry->next;
}
if (length > LEXBOR_HASH_SHORT_SIZE) {
lexbor_mraw_free(hash->mraw, entry->u.long_str);
}
lexbor_dobject_free(hash->entries, entry);
return;
}
prev = entry;
entry = entry->next;
}
}
void *
lexbor_hash_search_by_hash_id(lexbor_hash_t *hash, uint32_t hash_id,
const lxb_char_t *key, size_t length,
const lexbor_hash_cmp_f cmp_func)
{
lxb_char_t *str;
lexbor_hash_entry_t *entry;
entry = hash->table[ hash_id % hash->table_size ];
while (entry != NULL) {
str = lexbor_hash_entry_str(entry);
if (entry->length == length && cmp_func(str, key, length)) {
return entry;
}
entry = entry->next;
}
return NULL;
}
uint32_t
lexbor_hash_make_id(const lxb_char_t *key, size_t length)
{
size_t i;
uint32_t hash_id;
for (i = hash_id = 0; i < length; i++) {
hash_id += key[i];
hash_id += (hash_id << 10);
hash_id ^= (hash_id >> 6);
}
hash_id += (hash_id << 3);
hash_id ^= (hash_id >> 11);
hash_id += (hash_id << 15);
return hash_id;
}
uint32_t
lexbor_hash_make_id_lower(const lxb_char_t *key, size_t length)
{
size_t i;
uint32_t hash_id;
for (i = hash_id = 0; i < length; i++) {
hash_id += lexbor_str_res_map_lowercase[ key[i] ];
hash_id += (hash_id << 10);
hash_id ^= (hash_id >> 6);
}
hash_id += (hash_id << 3);
hash_id ^= (hash_id >> 11);
hash_id += (hash_id << 15);
return hash_id;
}
uint32_t
lexbor_hash_make_id_upper(const lxb_char_t *key, size_t length)
{
size_t i;
uint32_t hash_id;
for (i = hash_id = 0; i < length; i++) {
hash_id += lexbor_str_res_map_uppercase[ key[i] ];
hash_id += (hash_id << 10);
hash_id ^= (hash_id >> 6);
}
hash_id += (hash_id << 3);
hash_id ^= (hash_id >> 11);
hash_id += (hash_id << 15);
return hash_id;
}
lxb_status_t
lexbor_hash_copy(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lxb_char_t *key, size_t length)
{
lxb_char_t *to;
if (length <= LEXBOR_HASH_SHORT_SIZE) {
to = entry->u.short_str;
}
else {
entry->u.long_str = lexbor_mraw_alloc(hash->mraw, length + 1);
if (entry->u.long_str == NULL) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
to = entry->u.long_str;
}
memcpy(to, key, length);
to[length] = '\0';
return LXB_STATUS_OK;
}
lxb_status_t
lexbor_hash_copy_lower(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lxb_char_t *key, size_t length)
{
lxb_char_t *to;
if (length <= LEXBOR_HASH_SHORT_SIZE) {
to = entry->u.short_str;
}
else {
entry->u.long_str = lexbor_mraw_alloc(hash->mraw, length + 1);
if (entry->u.long_str == NULL) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
to = entry->u.long_str;
}
for (size_t i = 0; i < length; i++) {
to[i] = lexbor_str_res_map_lowercase[ key[i] ];
}
to[length] = '\0';
return LXB_STATUS_OK;
}
lxb_status_t
lexbor_hash_copy_upper(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lxb_char_t *key, size_t length)
{
lxb_char_t *to;
if (length <= LEXBOR_HASH_SHORT_SIZE) {
to = entry->u.short_str;
}
else {
entry->u.long_str = lexbor_mraw_alloc(hash->mraw, length + 1);
if (entry->u.long_str == NULL) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
to = entry->u.long_str;
}
for (size_t i = 0; i < length; i++) {
to[i] = lexbor_str_res_map_uppercase[ key[i] ];
}
to[length] = '\0';
return LXB_STATUS_OK;
}

218
ext/dom/lexbor/lexbor/core/hash.h Normal file
View file

@ -0,0 +1,218 @@
/*
* Copyright (C) 2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_HASH_H
#define LEXBOR_HASH_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/dobject.h"
#include "lexbor/core/mraw.h"
#define LEXBOR_HASH_SHORT_SIZE 16
#define LEXBOR_HASH_TABLE_MIN_SIZE 32
typedef struct lexbor_hash_search lexbor_hash_search_t;
typedef struct lexbor_hash_insert lexbor_hash_insert_t;
#ifndef LEXBOR_HASH_EXTERN
LXB_EXTERN const lexbor_hash_insert_t *lexbor_hash_insert_raw;
LXB_EXTERN const lexbor_hash_insert_t *lexbor_hash_insert_lower;
LXB_EXTERN const lexbor_hash_insert_t *lexbor_hash_insert_upper;
LXB_EXTERN const lexbor_hash_search_t *lexbor_hash_search_raw;
LXB_EXTERN const lexbor_hash_search_t *lexbor_hash_search_lower;
LXB_EXTERN const lexbor_hash_search_t *lexbor_hash_search_upper;
#endif
/*
* FIXME:
* It is necessary to add the rebuild of a hash table
* and optimize collisions.
*/
typedef struct lexbor_hash lexbor_hash_t;
typedef struct lexbor_hash_entry lexbor_hash_entry_t;
typedef uint32_t
(*lexbor_hash_id_f)(const lxb_char_t *key, size_t size);
typedef lxb_status_t
(*lexbor_hash_copy_f)(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lxb_char_t *key, size_t size);
typedef bool
(*lexbor_hash_cmp_f)(const lxb_char_t *first,
const lxb_char_t *second, size_t size);
struct lexbor_hash_entry {
union {
lxb_char_t *long_str;
lxb_char_t short_str[LEXBOR_HASH_SHORT_SIZE + 1];
} u;
size_t length;
lexbor_hash_entry_t *next;
};
struct lexbor_hash {
lexbor_dobject_t *entries;
lexbor_mraw_t *mraw;
lexbor_hash_entry_t **table;
size_t table_size;
size_t struct_size;
};
struct lexbor_hash_insert {
lexbor_hash_id_f hash; /* For generate a hash id. */
lexbor_hash_cmp_f cmp; /* For compare key. */
lexbor_hash_copy_f copy; /* For copy key. */
};
struct lexbor_hash_search {
lexbor_hash_id_f hash; /* For generate a hash id. */
lexbor_hash_cmp_f cmp; /* For compare key. */
};
LXB_API lexbor_hash_t *
lexbor_hash_create(void);
LXB_API lxb_status_t
lexbor_hash_init(lexbor_hash_t *hash, size_t table_size, size_t struct_size);
LXB_API void
lexbor_hash_clean(lexbor_hash_t *hash);
LXB_API lexbor_hash_t *
lexbor_hash_destroy(lexbor_hash_t *hash, bool destroy_obj);
LXB_API void *
lexbor_hash_insert(lexbor_hash_t *hash, const lexbor_hash_insert_t *insert,
const lxb_char_t *key, size_t length);
LXB_API void *
lexbor_hash_insert_by_entry(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lexbor_hash_search_t *search,
const lxb_char_t *key, size_t length);
LXB_API void
lexbor_hash_remove(lexbor_hash_t *hash, const lexbor_hash_search_t *search,
const lxb_char_t *key, size_t length);
LXB_API void *
lexbor_hash_search(lexbor_hash_t *hash, const lexbor_hash_search_t *search,
const lxb_char_t *key, size_t length);
LXB_API void
lexbor_hash_remove_by_hash_id(lexbor_hash_t *hash, uint32_t hash_id,
const lxb_char_t *key, size_t length,
const lexbor_hash_cmp_f cmp_func);
LXB_API void *
lexbor_hash_search_by_hash_id(lexbor_hash_t *hash, uint32_t hash_id,
const lxb_char_t *key, size_t length,
const lexbor_hash_cmp_f cmp_func);
LXB_API uint32_t
lexbor_hash_make_id(const lxb_char_t *key, size_t length);
LXB_API uint32_t
lexbor_hash_make_id_lower(const lxb_char_t *key, size_t length);
LXB_API uint32_t
lexbor_hash_make_id_upper(const lxb_char_t *key, size_t length);
LXB_API lxb_status_t
lexbor_hash_copy(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lxb_char_t *key, size_t length);
LXB_API lxb_status_t
lexbor_hash_copy_lower(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lxb_char_t *key, size_t length);
LXB_API lxb_status_t
lexbor_hash_copy_upper(lexbor_hash_t *hash, lexbor_hash_entry_t *entry,
const lxb_char_t *key, size_t length);
/*
* Inline functions
*/
lxb_inline lexbor_mraw_t *
lexbor_hash_mraw(const lexbor_hash_t *hash)
{
return hash->mraw;
}
lxb_inline lxb_char_t *
lexbor_hash_entry_str(const lexbor_hash_entry_t *entry)
{
if (entry->length <= LEXBOR_HASH_SHORT_SIZE) {
return (lxb_char_t *) entry->u.short_str;
}
return entry->u.long_str;
}
lxb_inline lxb_char_t *
lexbor_hash_entry_str_set(lexbor_hash_entry_t *entry,
lxb_char_t *data, size_t length)
{
entry->length = length;
if (length <= LEXBOR_HASH_SHORT_SIZE) {
memcpy(entry->u.short_str, data, length);
return (lxb_char_t *) entry->u.short_str;
}
entry->u.long_str = data;
return entry->u.long_str;
}
lxb_inline void
lexbor_hash_entry_str_free(lexbor_hash_t *hash, lexbor_hash_entry_t *entry)
{
if (entry->length > LEXBOR_HASH_SHORT_SIZE) {
lexbor_mraw_free(hash->mraw, entry->u.long_str);
}
entry->length = 0;
}
lxb_inline lexbor_hash_entry_t *
lexbor_hash_entry_create(lexbor_hash_t *hash)
{
return (lexbor_hash_entry_t *) lexbor_dobject_calloc(hash->entries);
}
lxb_inline lexbor_hash_entry_t *
lexbor_hash_entry_destroy(lexbor_hash_t *hash, lexbor_hash_entry_t *entry)
{
return (lexbor_hash_entry_t *) lexbor_dobject_free(hash->entries, entry);
}
lxb_inline size_t
lexbor_hash_entries_count(lexbor_hash_t *hash)
{
return lexbor_dobject_allocated(hash->entries);
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_HASH_H */

267
ext/dom/lexbor/lexbor/core/in.c Executable file
View file

@ -0,0 +1,267 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/in.h"
#include "lexbor/core/str_res.h"
lexbor_in_t *
lexbor_in_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_in_t));
}
lxb_status_t
lexbor_in_init(lexbor_in_t *incoming, size_t chunk_size)
{
if (incoming == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (chunk_size == 0) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
incoming->nodes = lexbor_dobject_create();
return lexbor_dobject_init(incoming->nodes, chunk_size,
sizeof(lexbor_in_node_t));
}
void
lexbor_in_clean(lexbor_in_t *incoming)
{
lexbor_dobject_clean(incoming->nodes);
}
lexbor_in_t *
lexbor_in_destroy(lexbor_in_t *incoming, bool self_destroy)
{
if (incoming == NULL) {
return NULL;
}
incoming->nodes = lexbor_dobject_destroy(incoming->nodes, true);
if (self_destroy == true) {
return lexbor_free(incoming);
}
return incoming;
}
lexbor_in_node_t *
lexbor_in_node_make(lexbor_in_t *incoming, lexbor_in_node_t *last_node,
const lxb_char_t *buf, size_t buf_size)
{
lexbor_in_node_t *node = lexbor_dobject_alloc(incoming->nodes);
if (node == NULL) {
return NULL;
}
node->opt = LEXBOR_IN_OPT_UNDEF;
node->begin = buf;
node->end = buf + buf_size;
node->use = buf;
if (last_node != NULL) {
last_node->next = node;
node->offset = last_node->offset + (last_node->end - last_node->begin);
}
else {
node->offset = 0;
}
node->prev = last_node;
node->next = NULL;
node->incoming = incoming;
return node;
}
void
lexbor_in_node_clean(lexbor_in_node_t *node)
{
lexbor_in_t *incoming = node->incoming;
memset(node, 0, sizeof(lexbor_in_node_t));
node->incoming = incoming;
}
lexbor_in_node_t *
lexbor_in_node_destroy(lexbor_in_t *incoming,
lexbor_in_node_t *node, bool self_destroy)
{
if (node == NULL) {
return NULL;
}
if (self_destroy) {
return lexbor_dobject_free(incoming->nodes, node);
}
return node;
}
lexbor_in_node_t *
lexbor_in_node_split(lexbor_in_node_t *node, const lxb_char_t *pos)
{
lexbor_in_node_t *new_node;
new_node = lexbor_dobject_alloc(node->incoming->nodes);
if (new_node == NULL) {
return NULL;
}
new_node->offset = node->offset + (pos - node->begin);
new_node->opt = LEXBOR_IN_OPT_UNDEF;
new_node->begin = pos;
new_node->end = node->end;
new_node->next = NULL;
new_node->prev = node;
new_node->incoming = node->incoming;
node->end = pos;
node->next = new_node;
if (node->use > pos) {
new_node->use = node->use;
node->use = pos;
}
else {
new_node->use = pos;
}
return new_node;
}
lexbor_in_node_t *
lexbor_in_node_find(lexbor_in_node_t *node, const lxb_char_t *pos)
{
while (node->next) {
node = node->next;
}
while (node && (node->begin > pos || node->end < pos)) {
node = node->prev;
}
return node;
}
const lxb_char_t *
lexbor_in_node_pos_up(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
const lxb_char_t *pos, size_t offset)
{
do {
pos = pos + offset;
if (node->end >= pos) {
if (return_node != NULL && *return_node != node) {
*return_node = node;
}
return pos;
}
if (node->next == NULL) {
if (return_node != NULL && *return_node != node) {
*return_node = node;
}
return node->end;
}
offset = pos - node->end;
node = node->next;
pos = node->begin;
}
while (1);
return NULL;
}
const lxb_char_t *
lexbor_in_node_pos_down(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
const lxb_char_t *pos, size_t offset)
{
do {
pos = pos - offset;
if (node->begin <= pos) {
if (return_node != NULL && *return_node != node) {
*return_node = node;
}
return pos;
}
if (node->prev == NULL) {
if (return_node != NULL && *return_node != node) {
*return_node = node;
}
return node->begin;
}
offset = node->begin - pos;
node = node->prev;
pos = node->end;
}
while (1);
return NULL;
}
/*
* No inline functions for ABI.
*/
const lxb_char_t *
lexbor_in_node_begin_noi(const lexbor_in_node_t *node)
{
return lexbor_in_node_begin(node);
}
const lxb_char_t *
lexbor_in_node_end_noi(const lexbor_in_node_t *node)
{
return lexbor_in_node_end(node);
}
size_t
lexbor_in_node_offset_noi(const lexbor_in_node_t *node)
{
return lexbor_in_node_offset(node);
}
lexbor_in_node_t *
lexbor_in_node_next_noi(const lexbor_in_node_t *node)
{
return lexbor_in_node_next(node);
}
lexbor_in_node_t *
lexbor_in_node_prev_noi(const lexbor_in_node_t *node)
{
return lexbor_in_node_prev(node);
}
lexbor_in_t *
lexbor_in_node_in_noi(const lexbor_in_node_t *node)
{
return lexbor_in_node_in(node);
}
bool
lexbor_in_segment_noi(const lexbor_in_node_t *node, const lxb_char_t *data)
{
return lexbor_in_segment(node, data);
}

172
ext/dom/lexbor/lexbor/core/in.h Executable file
View file

@ -0,0 +1,172 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_IN_H
#define LEXBOR_IN_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/core/dobject.h"
typedef struct lexbor_in_node lexbor_in_node_t;
typedef int lexbor_in_opt_t;
enum lexbor_in_opt {
LEXBOR_IN_OPT_UNDEF = 0x00,
LEXBOR_IN_OPT_READONLY = 0x01,
LEXBOR_IN_OPT_DONE = 0x02,
LEXBOR_IN_OPT_FAKE = 0x04,
LEXBOR_IN_OPT_ALLOC = 0x08
};
typedef struct {
lexbor_dobject_t *nodes;
}
lexbor_in_t;
struct lexbor_in_node {
size_t offset;
lexbor_in_opt_t opt;
const lxb_char_t *begin;
const lxb_char_t *end;
const lxb_char_t *use;
lexbor_in_node_t *next;
lexbor_in_node_t *prev;
lexbor_in_t *incoming;
};
LXB_API lexbor_in_t *
lexbor_in_create(void);
LXB_API lxb_status_t
lexbor_in_init(lexbor_in_t *incoming, size_t chunk_size);
LXB_API void
lexbor_in_clean(lexbor_in_t *incoming);
LXB_API lexbor_in_t *
lexbor_in_destroy(lexbor_in_t *incoming, bool self_destroy);
LXB_API lexbor_in_node_t *
lexbor_in_node_make(lexbor_in_t *incoming, lexbor_in_node_t *last_node,
const lxb_char_t *buf, size_t buf_size);
LXB_API void
lexbor_in_node_clean(lexbor_in_node_t *node);
LXB_API lexbor_in_node_t *
lexbor_in_node_destroy(lexbor_in_t *incoming,
lexbor_in_node_t *node, bool self_destroy);
LXB_API lexbor_in_node_t *
lexbor_in_node_split(lexbor_in_node_t *node, const lxb_char_t *pos);
LXB_API lexbor_in_node_t *
lexbor_in_node_find(lexbor_in_node_t *node, const lxb_char_t *pos);
/**
* Get position by `offset`.
* If position outside of nodes return `begin` position of first node
* in nodes chain.
*/
LXB_API const lxb_char_t *
lexbor_in_node_pos_up(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
const lxb_char_t *pos, size_t offset);
/**
* Get position by `offset`.
* If position outside of nodes return `end`
* position of last node in nodes chain.
*/
LXB_API const lxb_char_t *
lexbor_in_node_pos_down(lexbor_in_node_t *node, lexbor_in_node_t **return_node,
const lxb_char_t *pos, size_t offset);
/*
* Inline functions
*/
lxb_inline const lxb_char_t *
lexbor_in_node_begin(const lexbor_in_node_t *node)
{
return node->begin;
}
lxb_inline const lxb_char_t *
lexbor_in_node_end(const lexbor_in_node_t *node)
{
return node->end;
}
lxb_inline size_t
lexbor_in_node_offset(const lexbor_in_node_t *node)
{
return node->offset;
}
lxb_inline lexbor_in_node_t *
lexbor_in_node_next(const lexbor_in_node_t *node)
{
return node->next;
}
lxb_inline lexbor_in_node_t *
lexbor_in_node_prev(const lexbor_in_node_t *node)
{
return node->prev;
}
lxb_inline lexbor_in_t *
lexbor_in_node_in(const lexbor_in_node_t *node)
{
return node->incoming;
}
lxb_inline bool
lexbor_in_segment(const lexbor_in_node_t *node, const lxb_char_t *data)
{
return node->begin <= data && node->end >= data;
}
/*
* No inline functions for ABI.
*/
LXB_API const lxb_char_t *
lexbor_in_node_begin_noi(const lexbor_in_node_t *node);
LXB_API const lxb_char_t *
lexbor_in_node_end_noi(const lexbor_in_node_t *node);
LXB_API size_t
lexbor_in_node_offset_noi(const lexbor_in_node_t *node);
LXB_API lexbor_in_node_t *
lexbor_in_node_next_noi(const lexbor_in_node_t *node);
LXB_API lexbor_in_node_t *
lexbor_in_node_prev_noi(const lexbor_in_node_t *node);
LXB_API lexbor_in_t *
lexbor_in_node_in_noi(const lexbor_in_node_t *node);
LXB_API bool
lexbor_in_segment_noi(const lexbor_in_node_t *node, const lxb_char_t *data);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_IN_H */

43
ext/dom/lexbor/lexbor/core/lexbor.h Executable file
View file

@ -0,0 +1,43 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_H
#define LEXBOR_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/def.h"
typedef void *(*lexbor_memory_malloc_f)(size_t size);
typedef void *(*lexbor_memory_realloc_f)(void *dst, size_t size);
typedef void *(*lexbor_memory_calloc_f)(size_t num, size_t size);
typedef void (*lexbor_memory_free_f)(void *dst);
LXB_API void *
lexbor_malloc(size_t size);
LXB_API void *
lexbor_realloc(void *dst, size_t size);
LXB_API void *
lexbor_calloc(size_t num, size_t size);
LXB_API void *
lexbor_free(void *dst);
LXB_API lxb_status_t
lexbor_memory_setup(lexbor_memory_malloc_f new_malloc, lexbor_memory_realloc_f new_realloc,
lexbor_memory_calloc_f new_calloc, lexbor_memory_free_f new_free);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_H */

228
ext/dom/lexbor/lexbor/core/mem.c Executable file
View file

@ -0,0 +1,228 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/mem.h"
lexbor_mem_t *
lexbor_mem_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_mem_t));
}
lxb_status_t
lexbor_mem_init(lexbor_mem_t *mem, size_t min_chunk_size)
{
if (mem == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (min_chunk_size == 0) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
mem->chunk_min_size = lexbor_mem_align(min_chunk_size);
/* Create first chunk */
mem->chunk = lexbor_mem_chunk_make(mem, mem->chunk_min_size);
if (mem->chunk == NULL) {
return LXB_STATUS_ERROR_MEMORY_ALLOCATION;
}
mem->chunk_length = 1;
mem->chunk_first = mem->chunk;
return LXB_STATUS_OK;
}
void
lexbor_mem_clean(lexbor_mem_t *mem)
{
lexbor_mem_chunk_t *prev, *chunk;
if (mem == NULL) {
return;
}
chunk = mem->chunk;
while (chunk->prev) {
prev = chunk->prev;
chunk->data = lexbor_free(chunk->data);
lexbor_free(chunk);
chunk = prev;
}
chunk->next = NULL;
chunk->length = 0;
mem->chunk = mem->chunk_first;
mem->chunk_length = 1;
}
lexbor_mem_t *
lexbor_mem_destroy(lexbor_mem_t *mem, bool destroy_self)
{
lexbor_mem_chunk_t *chunk, *prev;
if (mem == NULL) {
return NULL;
}
/* Destroy all chunk */
if (mem->chunk) {
chunk = mem->chunk;
while (chunk) {
prev = chunk->prev;
lexbor_mem_chunk_destroy(mem, chunk, true);
chunk = prev;
}
mem->chunk = NULL;
}
if (destroy_self) {
return lexbor_free(mem);
}
return mem;
}
uint8_t *
lexbor_mem_chunk_init(lexbor_mem_t *mem,
lexbor_mem_chunk_t *chunk, size_t length)
{
length = lexbor_mem_align(length);
if (length > mem->chunk_min_size) {
if (mem->chunk_min_size > (SIZE_MAX - length)) {
chunk->size = length;
}
else {
chunk->size = length + mem->chunk_min_size;
}
}
else {
chunk->size = mem->chunk_min_size;
}
chunk->length = 0;
chunk->data = lexbor_malloc(chunk->size * sizeof(uint8_t));
return chunk->data;
}
lexbor_mem_chunk_t *
lexbor_mem_chunk_make(lexbor_mem_t *mem, size_t length)
{
lexbor_mem_chunk_t *chunk = lexbor_calloc(1, sizeof(lexbor_mem_chunk_t));
if (chunk == NULL) {
return NULL;
}
if (lexbor_mem_chunk_init(mem, chunk, length) == NULL) {
return lexbor_free(chunk);
}
return chunk;
}
lexbor_mem_chunk_t *
lexbor_mem_chunk_destroy(lexbor_mem_t *mem,
lexbor_mem_chunk_t *chunk, bool self_destroy)
{
if (chunk == NULL || mem == NULL) {
return NULL;
}
if (chunk->data) {
chunk->data = lexbor_free(chunk->data);
}
if (self_destroy) {
return lexbor_free(chunk);
}
return chunk;
}
void *
lexbor_mem_alloc(lexbor_mem_t *mem, size_t length)
{
if (length == 0) {
return NULL;
}
length = lexbor_mem_align(length);
if ((mem->chunk->length + length) > mem->chunk->size) {
if ((SIZE_MAX - mem->chunk_length) == 0) {
return NULL;
}
mem->chunk->next = lexbor_mem_chunk_make(mem, length);
if (mem->chunk->next == NULL) {
return NULL;
}
mem->chunk->next->prev = mem->chunk;
mem->chunk = mem->chunk->next;
mem->chunk_length++;
}
mem->chunk->length += length;
return &mem->chunk->data[(mem->chunk->length - length)];
}
void *
lexbor_mem_calloc(lexbor_mem_t *mem, size_t length)
{
void *data = lexbor_mem_alloc(mem, length);
if (data != NULL) {
memset(data, 0, length);
}
return data;
}
/*
* No inline functions for ABI.
*/
size_t
lexbor_mem_current_length_noi(lexbor_mem_t *mem)
{
return lexbor_mem_current_length(mem);
}
size_t
lexbor_mem_current_size_noi(lexbor_mem_t *mem)
{
return lexbor_mem_current_size(mem);
}
size_t
lexbor_mem_chunk_length_noi(lexbor_mem_t *mem)
{
return lexbor_mem_chunk_length(mem);
}
size_t
lexbor_mem_align_noi(size_t size)
{
return lexbor_mem_align(size);
}
size_t
lexbor_mem_align_floor_noi(size_t size)
{
return lexbor_mem_align_floor(size);
}

141
ext/dom/lexbor/lexbor/core/mem.h Executable file
View file

@ -0,0 +1,141 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_MEM_H
#define LEXBOR_MEM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <string.h>
#include "lexbor/core/base.h"
typedef struct lexbor_mem_chunk lexbor_mem_chunk_t;
typedef struct lexbor_mem lexbor_mem_t;
struct lexbor_mem_chunk {
uint8_t *data;
size_t length;
size_t size;
lexbor_mem_chunk_t *next;
lexbor_mem_chunk_t *prev;
};
struct lexbor_mem {
lexbor_mem_chunk_t *chunk;
lexbor_mem_chunk_t *chunk_first;
size_t chunk_min_size;
size_t chunk_length;
};
LXB_API lexbor_mem_t *
lexbor_mem_create(void);
LXB_API lxb_status_t
lexbor_mem_init(lexbor_mem_t *mem, size_t min_chunk_size);
LXB_API void
lexbor_mem_clean(lexbor_mem_t *mem);
LXB_API lexbor_mem_t *
lexbor_mem_destroy(lexbor_mem_t *mem, bool destroy_self);
/*
* The memory allocated in lexbor_mem_chunk_* functions needs to be freed
* by lexbor_mem_chunk_destroy function.
*
* This memory will not be automatically freed by a function lexbor_mem_destroy.
*/
LXB_API uint8_t *
lexbor_mem_chunk_init(lexbor_mem_t *mem,
lexbor_mem_chunk_t *chunk, size_t length);
LXB_API lexbor_mem_chunk_t *
lexbor_mem_chunk_make(lexbor_mem_t *mem, size_t length);
LXB_API lexbor_mem_chunk_t *
lexbor_mem_chunk_destroy(lexbor_mem_t *mem,
lexbor_mem_chunk_t *chunk, bool self_destroy);
/*
* The memory allocated in lexbor_mem_alloc and lexbor_mem_calloc function
* will be freeds after calling lexbor_mem_destroy function.
*/
LXB_API void *
lexbor_mem_alloc(lexbor_mem_t *mem, size_t length);
LXB_API void *
lexbor_mem_calloc(lexbor_mem_t *mem, size_t length);
/*
* Inline functions
*/
lxb_inline size_t
lexbor_mem_current_length(lexbor_mem_t *mem)
{
return mem->chunk->length;
}
lxb_inline size_t
lexbor_mem_current_size(lexbor_mem_t *mem)
{
return mem->chunk->size;
}
lxb_inline size_t
lexbor_mem_chunk_length(lexbor_mem_t *mem)
{
return mem->chunk_length;
}
lxb_inline size_t
lexbor_mem_align(size_t size)
{
return ((size % LEXBOR_MEM_ALIGN_STEP) != 0)
? size + (LEXBOR_MEM_ALIGN_STEP - (size % LEXBOR_MEM_ALIGN_STEP))
: size;
}
lxb_inline size_t
lexbor_mem_align_floor(size_t size)
{
return ((size % LEXBOR_MEM_ALIGN_STEP) != 0)
? size - (size % LEXBOR_MEM_ALIGN_STEP)
: size;
}
/*
* No inline functions for ABI.
*/
LXB_API size_t
lexbor_mem_current_length_noi(lexbor_mem_t *mem);
LXB_API size_t
lexbor_mem_current_size_noi(lexbor_mem_t *mem);
LXB_API size_t
lexbor_mem_chunk_length_noi(lexbor_mem_t *mem);
LXB_API size_t
lexbor_mem_align_noi(size_t size);
LXB_API size_t
lexbor_mem_align_floor_noi(size_t size);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_MEM_H */

428
ext/dom/lexbor/lexbor/core/mraw.c Executable file
View file

@ -0,0 +1,428 @@
/*
* Copyright (C) 2018-2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/mraw.h"
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
#include <sanitizer/asan_interface.h>
#endif
#define lexbor_mraw_meta_set(data, size) \
do { \
memcpy(data, size, sizeof(size_t)); \
} \
while (0)
#define lexbor_mraw_data_begin(data) \
&((uint8_t *) (data))[ lexbor_mraw_meta_size() ]
lxb_inline void *
lexbor_mraw_realloc_tail(lexbor_mraw_t *mraw, void *data, void *begin,
size_t size, size_t begin_len, size_t new_size,
bool *is_valid);
lexbor_mraw_t *
lexbor_mraw_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_mraw_t));
}
lxb_status_t
lexbor_mraw_init(lexbor_mraw_t *mraw, size_t chunk_size)
{
lxb_status_t status;
if (mraw == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (chunk_size == 0) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
/* Init memory */
mraw->mem = lexbor_mem_create();
status = lexbor_mem_init(mraw->mem, chunk_size + lexbor_mraw_meta_size());
if (status) {
return status;
}
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(mraw->mem->chunk->data, mraw->mem->chunk->size);
#endif
/* Cache */
mraw->cache = lexbor_bst_create();
status = lexbor_bst_init(mraw->cache, 512);
if (status) {
return status;
}
mraw->ref_count = 0;
return LXB_STATUS_OK;
}
void
lexbor_mraw_clean(lexbor_mraw_t *mraw)
{
if (mraw != NULL) {
lexbor_mem_clean(mraw->mem);
lexbor_bst_clean(mraw->cache);
mraw->ref_count = 0;
}
}
lexbor_mraw_t *
lexbor_mraw_destroy(lexbor_mraw_t *mraw, bool destroy_self)
{
if (mraw == NULL) {
return NULL;
}
mraw->mem = lexbor_mem_destroy(mraw->mem, true);
mraw->cache = lexbor_bst_destroy(mraw->cache, true);
if (destroy_self) {
return lexbor_free(mraw);
}
return mraw;
}
lxb_inline void *
lexbor_mraw_mem_alloc(lexbor_mraw_t *mraw, size_t length)
{
uint8_t *data;
lexbor_mem_t *mem = mraw->mem;
if (length == 0) {
return NULL;
}
if ((mem->chunk->length + length) > mem->chunk->size) {
lexbor_mem_chunk_t *chunk = mem->chunk;
if ((SIZE_MAX - mem->chunk_length) == 0) {
return NULL;
}
if (chunk->length == 0) {
lexbor_mem_chunk_destroy(mem, chunk, false);
lexbor_mem_chunk_init(mem, chunk, length);
chunk->length = length;
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(chunk->data, chunk->size);
#endif
return chunk->data;
}
size_t diff = lexbor_mem_align_floor(chunk->size - chunk->length);
/* Save tail to cache */
if (diff > lexbor_mraw_meta_size()) {
diff -= lexbor_mraw_meta_size();
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_UNPOISON_MEMORY_REGION(&chunk->data[chunk->length],
lexbor_mraw_meta_size());
#endif
lexbor_mraw_meta_set(&chunk->data[chunk->length], &diff);
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(&chunk->data[chunk->length],
diff + lexbor_mraw_meta_size());
#endif
lexbor_bst_insert(mraw->cache,
lexbor_bst_root_ref(mraw->cache), diff,
lexbor_mraw_data_begin(&chunk->data[chunk->length]));
chunk->length = chunk->size;
}
chunk->next = lexbor_mem_chunk_make(mem, length);
if (chunk->next == NULL) {
return NULL;
}
chunk->next->prev = chunk;
mem->chunk = chunk->next;
mem->chunk_length++;
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(mem->chunk->data, mem->chunk->size);
#endif
}
data = &mem->chunk->data[ mem->chunk->length ];
mem->chunk->length += length;
return data;
}
void *
lexbor_mraw_alloc(lexbor_mraw_t *mraw, size_t size)
{
void *data;
size = lexbor_mem_align(size);
if (mraw->cache->tree_length != 0) {
data = lexbor_bst_remove_close(mraw->cache,
lexbor_bst_root_ref(mraw->cache),
size, NULL);
if (data != NULL) {
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
uint8_t *real_data = ((uint8_t *) data) - lexbor_mraw_meta_size();
/* Set unpoison for current data size */
ASAN_UNPOISON_MEMORY_REGION(real_data, lexbor_mraw_meta_size());
size_t cur_size = lexbor_mraw_data_size(data);
ASAN_UNPOISON_MEMORY_REGION(real_data,
(cur_size + lexbor_mraw_meta_size()));
#endif
mraw->ref_count++;
return data;
}
}
data = lexbor_mraw_mem_alloc(mraw, (size + lexbor_mraw_meta_size()));
if (data == NULL) {
return NULL;
}
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_UNPOISON_MEMORY_REGION(data, (size + lexbor_mraw_meta_size()));
#endif
mraw->ref_count++;
lexbor_mraw_meta_set(data, &size);
return lexbor_mraw_data_begin(data);
}
void *
lexbor_mraw_calloc(lexbor_mraw_t *mraw, size_t size)
{
void *data = lexbor_mraw_alloc(mraw, size);
if (data != NULL) {
memset(data, 0, lexbor_mraw_data_size(data));
}
return data;
}
/*
* TODO: I don't really like this interface. Perhaps need to simplify.
*/
lxb_inline void *
lexbor_mraw_realloc_tail(lexbor_mraw_t *mraw, void *data, void *begin,
size_t size, size_t begin_len, size_t new_size,
bool *is_valid)
{
lexbor_mem_chunk_t *chunk = mraw->mem->chunk;
if (chunk->size > (begin_len + new_size)) {
*is_valid = true;
if (new_size == 0) {
chunk->length = begin_len - lexbor_mraw_meta_size();
return NULL;
}
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_UNPOISON_MEMORY_REGION(begin, new_size + lexbor_mraw_meta_size());
#endif
chunk->length = begin_len + new_size;
memcpy(begin, &new_size, sizeof(size_t));
return data;
}
/*
* If the tail is short then we increase the current data.
*/
if (begin_len == lexbor_mraw_meta_size()) {
void *new_data;
lexbor_mem_chunk_t new_chunk;
*is_valid = true;
lexbor_mem_chunk_init(mraw->mem, &new_chunk,
new_size + lexbor_mraw_meta_size());
if(new_chunk.data == NULL) {
return NULL;
}
lexbor_mraw_meta_set(new_chunk.data, &new_size);
new_data = lexbor_mraw_data_begin(new_chunk.data);
if (size != 0) {
memcpy(new_data, data, sizeof(uint8_t) * size);
}
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_UNPOISON_MEMORY_REGION(chunk->data, chunk->size);
#endif
lexbor_mem_chunk_destroy(mraw->mem, chunk, false);
chunk->data = new_chunk.data;
chunk->size = new_chunk.size;
chunk->length = new_size + lexbor_mraw_meta_size();
return new_data;
}
*is_valid = false;
/*
* Next, this piece will go into the cache.
*/
size = lexbor_mem_align_floor(size + (chunk->size - chunk->length));
memcpy(begin, &size, sizeof(size_t));
chunk->length = chunk->size;
return NULL;
}
void *
lexbor_mraw_realloc(lexbor_mraw_t *mraw, void *data, size_t new_size)
{
void *begin;
size_t size, begin_len;
lexbor_mem_chunk_t *chunk = mraw->mem->chunk;
begin = ((uint8_t *) data) - lexbor_mraw_meta_size();
memcpy(&size, begin, sizeof(size_t));
new_size = lexbor_mem_align(new_size);
/*
* Look, whether there is an opportunity
* to prolong the current data in chunk?
*/
if (chunk->length >= size) {
begin_len = chunk->length - size;
if (&chunk->data[begin_len] == data) {
bool is_valid;
void *ptr = lexbor_mraw_realloc_tail(mraw, data, begin,
size, begin_len, new_size,
&is_valid);
if (is_valid == true) {
return ptr;
}
}
}
if (new_size < size) {
if (new_size == 0) {
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(begin, size + lexbor_mraw_meta_size());
#endif
mraw->ref_count--;
lexbor_bst_insert(mraw->cache, lexbor_bst_root_ref(mraw->cache),
size, data);
return NULL;
}
size_t diff = lexbor_mem_align_floor(size - new_size);
if (diff > lexbor_mraw_meta_size()) {
memcpy(begin, &new_size, sizeof(size_t));
new_size = diff - lexbor_mraw_meta_size();
begin = &((uint8_t *) data)[diff];
lexbor_mraw_meta_set(begin, &new_size);
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
ASAN_POISON_MEMORY_REGION(begin, new_size + lexbor_mraw_meta_size());
#endif
lexbor_bst_insert(mraw->cache, lexbor_bst_root_ref(mraw->cache),
new_size, lexbor_mraw_data_begin(begin));
}
return data;
}
begin = lexbor_mraw_alloc(mraw, new_size);
if (begin == NULL) {
return NULL;
}
if (size != 0) {
memcpy(begin, data, sizeof(uint8_t) * size);
}
lexbor_mraw_free(mraw, data);
return begin;
}
void *
lexbor_mraw_free(lexbor_mraw_t *mraw, void *data)
{
size_t size = lexbor_mraw_data_size(data);
#if defined(LEXBOR_HAVE_ADDRESS_SANITIZER)
uint8_t *real_data = ((uint8_t *) data) - lexbor_mraw_meta_size();
ASAN_POISON_MEMORY_REGION(real_data, size + lexbor_mraw_meta_size());
#endif
lexbor_bst_insert(mraw->cache, lexbor_bst_root_ref(mraw->cache),
size, data);
mraw->ref_count--;
return NULL;
}
/*
* No inline functions for ABI.
*/
size_t
lexbor_mraw_data_size_noi(void *data)
{
return lexbor_mraw_data_size(data);
}
void
lexbor_mraw_data_size_set_noi(void *data, size_t size)
{
lexbor_mraw_data_size_set(data, size);
}
void *
lexbor_mraw_dup_noi(lexbor_mraw_t *mraw, const void *src, size_t size)
{
return lexbor_mraw_dup(mraw, src, size);
}

114
ext/dom/lexbor/lexbor/core/mraw.h Executable file
View file

@ -0,0 +1,114 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_MRAW_H
#define LEXBOR_MRAW_H
#ifdef __cplusplus
extern "C" {
#endif
#include <string.h>
#include "lexbor/core/base.h"
#include "lexbor/core/mem.h"
#include "lexbor/core/bst.h"
#define lexbor_mraw_meta_size() \
(((sizeof(size_t) % LEXBOR_MEM_ALIGN_STEP) != 0) \
? sizeof(size_t) \
+ (LEXBOR_MEM_ALIGN_STEP - (sizeof(size_t) % LEXBOR_MEM_ALIGN_STEP)) \
: sizeof(size_t))
typedef struct {
lexbor_mem_t *mem;
lexbor_bst_t *cache;
size_t ref_count;
}
lexbor_mraw_t;
LXB_API lexbor_mraw_t *
lexbor_mraw_create(void);
LXB_API lxb_status_t
lexbor_mraw_init(lexbor_mraw_t *mraw, size_t chunk_size);
LXB_API void
lexbor_mraw_clean(lexbor_mraw_t *mraw);
LXB_API lexbor_mraw_t *
lexbor_mraw_destroy(lexbor_mraw_t *mraw, bool destroy_self);
LXB_API void *
lexbor_mraw_alloc(lexbor_mraw_t *mraw, size_t size);
LXB_API void *
lexbor_mraw_calloc(lexbor_mraw_t *mraw, size_t size);
LXB_API void *
lexbor_mraw_realloc(lexbor_mraw_t *mraw, void *data, size_t new_size);
LXB_API void *
lexbor_mraw_free(lexbor_mraw_t *mraw, void *data);
/*
* Inline functions
*/
lxb_inline size_t
lexbor_mraw_data_size(void *data)
{
return *((size_t *) (((uint8_t *) data) - lexbor_mraw_meta_size()));
}
lxb_inline void
lexbor_mraw_data_size_set(void *data, size_t size)
{
data = (((uint8_t *) data) - lexbor_mraw_meta_size());
memcpy(data, &size, sizeof(size_t));
}
lxb_inline void *
lexbor_mraw_dup(lexbor_mraw_t *mraw, const void *src, size_t size)
{
void *data = lexbor_mraw_alloc(mraw, size);
if (data != NULL) {
memcpy(data, src, size);
}
return data;
}
lxb_inline size_t
lexbor_mraw_reference_count(lexbor_mraw_t *mraw)
{
return mraw->ref_count;
}
/*
* No inline functions for ABI.
*/
LXB_API size_t
lexbor_mraw_data_size_noi(void *data);
LXB_API void
lexbor_mraw_data_size_set_noi(void *data, size_t size);
LXB_API void *
lexbor_mraw_dup_noi(lexbor_mraw_t *mraw, const void *src, size_t size);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_MRAW_H */

45
ext/dom/lexbor/lexbor/core/perf.h Normal file
View file

@ -0,0 +1,45 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_PERF_H
#define LEXBOR_PERF_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#ifdef LEXBOR_WITH_PERF
LXB_API void *
lexbor_perf_create(void);
LXB_API void
lexbor_perf_clean(void *perf);
LXB_API void
lexbor_perf_destroy(void *perf);
LXB_API lxb_status_t
lexbor_perf_begin(void *perf);
LXB_API lxb_status_t
lexbor_perf_end(void *perf);
LXB_API double
lexbor_perf_in_sec(void *perf);
#endif /* LEXBOR_WITH_PERF */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_PERF_H */

73
ext/dom/lexbor/lexbor/core/plog.c Executable file
View file

@ -0,0 +1,73 @@
/*
* Copyright (C) 2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/plog.h"
lxb_status_t
lexbor_plog_init(lexbor_plog_t *plog, size_t init_size, size_t struct_size)
{
lxb_status_t status;
if (plog == NULL) {
return LXB_STATUS_ERROR_OBJECT_IS_NULL;
}
if (struct_size < sizeof(lexbor_plog_entry_t)) {
struct_size = sizeof(lexbor_plog_entry_t);
}
status = lexbor_array_obj_init(&plog->list, init_size, struct_size);
if (status != LXB_STATUS_OK) {
return status;
}
return LXB_STATUS_OK;
}
lexbor_plog_t *
lexbor_plog_destroy(lexbor_plog_t *plog, bool self_destroy)
{
if (plog == NULL) {
return NULL;
}
lexbor_array_obj_destroy(&plog->list, false);
if (self_destroy) {
return lexbor_free(plog);
}
return plog;
}
/*
* No inline functions.
*/
lexbor_plog_t *
lexbor_plog_create_noi(void)
{
return lexbor_plog_create();
}
void
lexbor_plog_clean_noi(lexbor_plog_t *plog)
{
lexbor_plog_clean(plog);
}
void *
lexbor_plog_push_noi(lexbor_plog_t *plog, const lxb_char_t *data, void *ctx,
unsigned id)
{
return lexbor_plog_push(plog, data, ctx, id);
}
size_t
lexbor_plog_length_noi(lexbor_plog_t *plog)
{
return lexbor_plog_length(plog);
}

102
ext/dom/lexbor/lexbor/core/plog.h Executable file
View file

@ -0,0 +1,102 @@
/*
* Copyright (C) 2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_PLOG_H
#define LEXBOR_PLOG_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/array_obj.h"
typedef struct {
const lxb_char_t *data;
void *context;
unsigned id;
}
lexbor_plog_entry_t;
typedef struct {
lexbor_array_obj_t list;
}
lexbor_plog_t;
LXB_API lxb_status_t
lexbor_plog_init(lexbor_plog_t *plog, size_t init_size, size_t struct_size);
LXB_API lexbor_plog_t *
lexbor_plog_destroy(lexbor_plog_t *plog, bool self_destroy);
/*
* Inline functions
*/
lxb_inline lexbor_plog_t *
lexbor_plog_create(void)
{
return (lexbor_plog_t *) lexbor_calloc(1, sizeof(lexbor_plog_t));
}
lxb_inline void
lexbor_plog_clean(lexbor_plog_t *plog)
{
lexbor_array_obj_clean(&plog->list);
}
lxb_inline void *
lexbor_plog_push(lexbor_plog_t *plog, const lxb_char_t *data, void *ctx,
unsigned id)
{
lexbor_plog_entry_t *entry;
if (plog == NULL) {
return NULL;
}
entry = (lexbor_plog_entry_t *) lexbor_array_obj_push(&plog->list);
if (entry == NULL) {
return NULL;
}
entry->data = data;
entry->context = ctx;
entry->id = id;
return (void *) entry;
}
lxb_inline size_t
lexbor_plog_length(lexbor_plog_t *plog)
{
return lexbor_array_obj_length(&plog->list);
}
/*
* No inline functions for ABI.
*/
LXB_API lexbor_plog_t *
lexbor_plog_create_noi(void);
LXB_API void
lexbor_plog_clean_noi(lexbor_plog_t *plog);
LXB_API void *
lexbor_plog_push_noi(lexbor_plog_t *plog, const lxb_char_t *data, void *ctx,
unsigned id);
LXB_API size_t
lexbor_plog_length_noi(lexbor_plog_t *plog);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_PLOG_H */

168
ext/dom/lexbor/lexbor/core/print.c Normal file
View file

@ -0,0 +1,168 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/str.h"
#include "lexbor/core/print.h"
#define lexbor_sprintf_append(dst, end, src, length) \
do { \
if ((size_t) ((end) - (dst)) < (length)) { \
return (end) - (dst); \
} \
\
memcpy((dst), (src), (length)); \
(dst) += (length); \
} \
while (false)
size_t
lexbor_printf_size(const char *format, ...)
{
size_t ret;
va_list va;
va_start(va, format);
ret = lexbor_vprintf_size(format, va);
va_end(va);
return ret;
}
size_t
lexbor_vprintf_size(const char *format, va_list va)
{
char c;
const char *begin, *cdata;
size_t size;
lexbor_str_t *str;
begin = format;
size = 0;
while (true) {
c = *format;
if (c == '%') {
c = format[1];
switch (c) {
case '\0':
return size + (format - begin) + 1;
case 's':
cdata = va_arg(va, const char *);
size += (format - begin) + strlen(cdata);
break;
case 'S':
str = va_arg(va, lexbor_str_t *);
size += (format - begin) + str->length;
break;
case '%':
size += (format - begin) + 1;
break;
default:
return LXB_PRINT_ERROR;
}
format++;
begin = format + 1;
}
else if (c == '\0') {
return size + (format - begin);
}
format++;
}
}
size_t
lexbor_sprintf(lxb_char_t *dst, size_t size, const char *format, ...)
{
size_t ret;
va_list va;
va_start(va, format);
ret = lexbor_vsprintf(dst, size, format, va);
va_end(va);
return ret;
}
size_t
lexbor_vsprintf(lxb_char_t *dst, size_t size, const char *format, va_list va)
{
char c;
const char *begin, *cdata;
lxb_char_t *end, *start;
lexbor_str_t *str;
begin = format;
start = dst;
end = dst + size;
while (true) {
c = *format;
if (c == '%') {
c = format[1];
switch (c) {
case '\0':
size = (format - begin) + 1;
lexbor_sprintf_append(dst, end, begin, size);
goto done;
case 's':
size = format - begin;
lexbor_sprintf_append(dst, end, begin, size);
cdata = va_arg(va, const char *);
size = strlen(cdata);
lexbor_sprintf_append(dst, end, cdata, size);
break;
case 'S':
size = format - begin;
lexbor_sprintf_append(dst, end, begin, size);
str = va_arg(va, lexbor_str_t *);
lexbor_sprintf_append(dst, end, str->data, str->length);
break;
case '%':
size = (format - begin) + 1;
lexbor_sprintf_append(dst, end, begin, size);
break;
default:
return LXB_PRINT_ERROR;
}
format++;
begin = format + 1;
}
else if (c == '\0') {
size = format - begin;
lexbor_sprintf_append(dst, end, begin, size);
goto done;
}
format++;
}
done:
if (end - dst > 0) {
*dst = '\0';
}
return dst - start;
}

39
ext/dom/lexbor/lexbor/core/print.h Normal file
View file

@ -0,0 +1,39 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_PRINT_H
#define LEXBOR_PRINT_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdarg.h>
#include "lexbor/core/base.h"
#define LXB_PRINT_ERROR ((size_t) - 1)
LXB_API size_t
lexbor_printf_size(const char *format, ...);
LXB_API size_t
lexbor_vprintf_size(const char *format, va_list va);
LXB_API size_t
lexbor_sprintf(lxb_char_t *dst, size_t size, const char *format, ...);
LXB_API size_t
lexbor_vsprintf(lxb_char_t *dst, size_t size, const char *format, va_list va);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_PRINT_H */

59
ext/dom/lexbor/lexbor/core/sbst.h Executable file
View file

@ -0,0 +1,59 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_SBST_H
#define LEXBOR_SBST_H
#ifdef __cplusplus
extern "C" {
#endif
#include <string.h>
#include "lexbor/core/base.h"
typedef struct {
lxb_char_t key;
void *value;
size_t value_len;
size_t left;
size_t right;
size_t next;
}
lexbor_sbst_entry_static_t;
/*
* Inline functions
*/
lxb_inline const lexbor_sbst_entry_static_t *
lexbor_sbst_entry_static_find(const lexbor_sbst_entry_static_t *strt,
const lexbor_sbst_entry_static_t *root,
const lxb_char_t key)
{
while (root != strt) {
if (root->key == key) {
return root;
}
else if (key > root->key) {
root = &strt[root->right];
}
else {
root = &strt[root->left];
}
}
return NULL;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_SBST_H */

27
ext/dom/lexbor/lexbor/core/serialize.c Normal file
View file

@ -0,0 +1,27 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/serialize.h"
#include "lexbor/core/str.h"
lxb_status_t
lexbor_serialize_length_cb(const lxb_char_t *data, size_t length, void *ctx)
{
*((size_t *) ctx) += length;
return LXB_STATUS_OK;
}
lxb_status_t
lexbor_serialize_copy_cb(const lxb_char_t *data, size_t length, void *ctx)
{
lexbor_str_t *str = ctx;
memcpy(str->data + str->length, data, length);
str->length += length;
return LXB_STATUS_OK;
}

32
ext/dom/lexbor/lexbor/core/serialize.h Normal file
View file

@ -0,0 +1,32 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_SERIALIZE_H
#define LEXBOR_SERIALIZE_H
#include "lexbor/core/base.h"
#define lexbor_serialize_write(cb, data, length, ctx, status) \
do { \
(status) = (cb)((lxb_char_t *) (data), (length), (ctx)); \
if ((status) != LXB_STATUS_OK) { \
return (status); \
} \
} \
while (false)
LXB_API lxb_status_t
lexbor_serialize_length_cb(const lxb_char_t *data, size_t length, void *ctx);
LXB_API lxb_status_t
lexbor_serialize_copy_cb(const lxb_char_t *data, size_t length, void *ctx);
#endif /* LEXBOR_SERIALIZE_H */

118
ext/dom/lexbor/lexbor/core/shs.c Executable file
View file

@ -0,0 +1,118 @@
/*
* Copyright (C) 2018-2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/shs.h"
#include "lexbor/core/str.h"
#define LEXBOR_STR_RES_MAP_LOWERCASE
#define LEXBOR_STR_RES_MAP_UPPERCASE
#include "lexbor/core/str_res.h"
#define lexbor_shs_make_id_m(key, size, table_size) \
(((((key[0] * key[size - 1]) * key[0]) + size) % table_size) + 0x01)
#define lexbor_shs_make_id_lower_m(key, size, table_size) \
(((((lexbor_str_res_map_lowercase[key[0]] \
* lexbor_str_res_map_lowercase[key[size - 1]]) \
* lexbor_str_res_map_lowercase[key[0]]) \
+ size) \
% table_size) + 0x01)
#define lexbor_shs_make_id_upper_m(key, size, table_size) \
(((((lexbor_str_res_map_uppercase[key[0]] \
* lexbor_str_res_map_uppercase[key[size - 1]]) \
* lexbor_str_res_map_uppercase[key[0]]) \
+ size) \
% table_size) + 0x01)
const lexbor_shs_entry_t *
lexbor_shs_entry_get_static(const lexbor_shs_entry_t *root,
const lxb_char_t *key, size_t key_len)
{
const lexbor_shs_entry_t *entry;
entry = root + lexbor_shs_make_id_m(key, key_len, root->key_len);
while (entry->key != NULL)
{
if (entry->key_len == key_len) {
if (lexbor_str_data_ncmp((const lxb_char_t *) entry->key,
key, key_len))
{
return entry;
}
entry = &root[entry->next];
}
else if (entry->key_len > key_len) {
return NULL;
}
else {
entry = &root[entry->next];
}
}
return NULL;
}
const lexbor_shs_entry_t *
lexbor_shs_entry_get_lower_static(const lexbor_shs_entry_t *root,
const lxb_char_t *key, size_t key_len)
{
const lexbor_shs_entry_t *entry;
entry = root + lexbor_shs_make_id_lower_m(key, key_len, root->key_len);
while (entry->key != NULL)
{
if (entry->key_len == key_len) {
if (lexbor_str_data_nlocmp_right((const lxb_char_t *) entry->key,
key, key_len))
{
return entry;
}
entry = &root[entry->next];
}
else if (entry->key_len > key_len) {
return NULL;
}
else {
entry = &root[entry->next];
}
}
return NULL;
}
const lexbor_shs_entry_t *
lexbor_shs_entry_get_upper_static(const lexbor_shs_entry_t *root,
const lxb_char_t *key, size_t key_len)
{
const lexbor_shs_entry_t *entry;
entry = root + lexbor_shs_make_id_upper_m(key, key_len, root->key_len);
while (entry->key != NULL)
{
if (entry->key_len == key_len) {
if (lexbor_str_data_nupcmp_right((const lxb_char_t *) entry->key,
key, key_len))
{
return entry;
}
entry = &root[entry->next];
}
else if (entry->key_len > key_len) {
return NULL;
}
else {
entry = &root[entry->next];
}
}
return NULL;
}

82
ext/dom/lexbor/lexbor/core/shs.h Executable file
View file

@ -0,0 +1,82 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_SHS_H
#define LEXBOR_SHS_H
#ifdef __cplusplus
extern "C" {
#endif
#include <string.h>
#include "lexbor/core/base.h"
typedef struct {
char *key;
void *value;
size_t key_len;
size_t next;
}
lexbor_shs_entry_t;
typedef struct {
uint32_t key;
uint32_t value;
uint32_t next;
}
lexbor_shs_hash_t;
LXB_API const lexbor_shs_entry_t *
lexbor_shs_entry_get_static(const lexbor_shs_entry_t *tree,
const lxb_char_t *key, size_t size);
LXB_API const lexbor_shs_entry_t *
lexbor_shs_entry_get_lower_static(const lexbor_shs_entry_t *root,
const lxb_char_t *key, size_t key_len);
LXB_API const lexbor_shs_entry_t *
lexbor_shs_entry_get_upper_static(const lexbor_shs_entry_t *root,
const lxb_char_t *key, size_t key_len);
/*
* Inline functions
*/
lxb_inline const lexbor_shs_hash_t *
lexbor_shs_hash_get_static(const lexbor_shs_hash_t *table,
const size_t table_size, const uint32_t key)
{
const lexbor_shs_hash_t *entry;
entry = &table[ (key % table_size) + 1 ];
do {
if (entry->key == key) {
return entry;
}
entry = &table[entry->next];
}
while (entry != table);
return NULL;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_SHS_H */

642
ext/dom/lexbor/lexbor/core/str.c Executable file
View file

@ -0,0 +1,642 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/str.h"
#define LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER
#define LEXBOR_STR_RES_MAP_LOWERCASE
#define LEXBOR_STR_RES_MAP_UPPERCASE
#include "lexbor/core/str_res.h"
lexbor_str_t *
lexbor_str_create(void)
{
return lexbor_calloc(1, sizeof(lexbor_str_t));
}
lxb_char_t *
lexbor_str_init(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t size)
{
if (str == NULL) {
return NULL;
}
str->data = lexbor_mraw_alloc(mraw, (size + 1));
str->length = 0;
if (str->data != NULL) {
*str->data = '\0';
}
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)
{
str->length = 0;
}
void
lexbor_str_clean_all(lexbor_str_t *str)
{
memset(str, 0, sizeof(lexbor_str_t));
}
lexbor_str_t *
lexbor_str_destroy(lexbor_str_t *str, lexbor_mraw_t *mraw, bool destroy_obj)
{
if (str == NULL) {
return NULL;
}
if (str->data != NULL) {
str->data = lexbor_mraw_free(mraw, str->data);
}
if (destroy_obj) {
return lexbor_free(str);
}
return str;
}
lxb_char_t *
lexbor_str_realloc(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t new_size)
{
lxb_char_t *tmp = lexbor_mraw_realloc(mraw, str->data, new_size);
if (tmp == NULL) {
return NULL;
}
str->data = tmp;
return tmp;
}
lxb_char_t *
lexbor_str_check_size(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t plus_len)
{
lxb_char_t *tmp;
if (str->length > (SIZE_MAX - plus_len)) {
return NULL;
}
if ((str->length + plus_len) <= lexbor_str_size(str)) {
return str->data;
}
tmp = lexbor_mraw_realloc(mraw, str->data, (str->length + plus_len));
if (tmp == NULL) {
return NULL;
}
str->data = tmp;
return tmp;
}
/* Append API */
lxb_char_t *
lexbor_str_append(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *buff, size_t length)
{
lxb_char_t *data_begin;
lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
mraw, (length + 1), NULL);
data_begin = &str->data[str->length];
memcpy(data_begin, buff, sizeof(lxb_char_t) * length);
str->length += length;
str->data[str->length] = '\0';
return data_begin;
}
lxb_char_t *
lexbor_str_append_before(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *buff, size_t length)
{
lxb_char_t *data_begin;
lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
mraw, (length + 1), NULL);
data_begin = &str->data[str->length];
memmove(&str->data[length], str->data, sizeof(lxb_char_t) * str->length);
memcpy(str->data, buff, sizeof(lxb_char_t) * length);
str->length += length;
str->data[str->length] = '\0';
return data_begin;
}
lxb_char_t *
lexbor_str_append_one(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t data)
{
lexbor_str_check_size_arg_m(str, lexbor_str_size(str), mraw, 2, NULL);
str->data[str->length] = data;
str->length += 1;
str->data[str->length] = '\0';
return &str->data[(str->length - 1)];
}
lxb_char_t *
lexbor_str_append_lowercase(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *data, size_t length)
{
size_t i;
lxb_char_t *data_begin;
lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
mraw, (length + 1), NULL);
data_begin = &str->data[str->length];
for (i = 0; i < length; i++) {
data_begin[i] = lexbor_str_res_map_lowercase[ data[i] ];
}
data_begin[i] = '\0';
str->length += length;
return data_begin;
}
lxb_char_t *
lexbor_str_append_with_rep_null_chars(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *buff, size_t length)
{
const lxb_char_t *pos, *res, *end;
size_t current_len = str->length;
lexbor_str_check_size_arg_m(str, lexbor_str_size(str),
mraw, (length + 1), NULL);
end = buff + length;
while (buff != end) {
pos = memchr(buff, '\0', sizeof(lxb_char_t) * (end - buff));
if (pos == NULL) {
break;
}
res = lexbor_str_append(str, mraw, buff, (pos - buff));
if (res == NULL) {
return NULL;
}
res = lexbor_str_append(str, mraw,
lexbor_str_res_ansi_replacement_character,
sizeof(lexbor_str_res_ansi_replacement_character) - 1);
if (res == NULL) {
return NULL;
}
buff = pos + 1;
}
if (buff != end) {
res = lexbor_str_append(str, mraw, buff, (end - buff));
if (res == NULL) {
return NULL;
}
}
return &str->data[current_len];
}
lxb_char_t *
lexbor_str_copy(lexbor_str_t *dest, const lexbor_str_t *target,
lexbor_mraw_t *mraw)
{
if (target->data == NULL) {
return NULL;
}
if (dest->data == NULL) {
lexbor_str_init(dest, mraw, target->length);
if (dest->data == NULL) {
return NULL;
}
}
return lexbor_str_append(dest, mraw, target->data, target->length);
}
void
lexbor_str_stay_only_whitespace(lexbor_str_t *target)
{
size_t i, pos = 0;
lxb_char_t *data = target->data;
for (i = 0; i < target->length; i++) {
if (lexbor_utils_whitespace(data[i], ==, ||)) {
data[pos] = data[i];
pos++;
}
}
target->length = pos;
}
void
lexbor_str_strip_collapse_whitespace(lexbor_str_t *target)
{
size_t i, offset, ws_i;
lxb_char_t *data = target->data;
if (target->length == 0) {
return;
}
if (lexbor_utils_whitespace(*data, ==, ||)) {
*data = 0x20;
}
for (i = 0, offset = 0, ws_i = 0; i < target->length; i++)
{
if (lexbor_utils_whitespace(data[i], ==, ||)) {
if (data[ws_i] != 0x20) {
data[offset] = 0x20;
ws_i = offset;
offset++;
}
}
else {
if (data[ws_i] == 0x20) {
ws_i = offset;
}
data[offset] = data[i];
offset++;
}
}
if (offset != i) {
if (offset != 0) {
if (data[offset - 1] == 0x20) {
offset--;
}
}
data[offset] = 0x00;
target->length = offset;
}
}
size_t
lexbor_str_crop_whitespace_from_begin(lexbor_str_t *target)
{
size_t i;
lxb_char_t *data = target->data;
for (i = 0; i < target->length; i++) {
if (lexbor_utils_whitespace(data[i], !=, &&)) {
break;
}
}
if (i != 0 && i != target->length) {
memmove(target->data, &target->data[i], (target->length - i));
}
target->length -= i;
return i;
}
size_t
lexbor_str_whitespace_from_begin(lexbor_str_t *target)
{
size_t i;
lxb_char_t *data = target->data;
for (i = 0; i < target->length; i++) {
if (lexbor_utils_whitespace(data[i], !=, &&)) {
break;
}
}
return i;
}
size_t
lexbor_str_whitespace_from_end(lexbor_str_t *target)
{
size_t i = target->length;
lxb_char_t *data = target->data;
while (i) {
i--;
if (lexbor_utils_whitespace(data[i], !=, &&)) {
return target->length - (i + 1);
}
}
return 0;
}
/*
* Data utils
* TODO: All functions need optimization.
*/
const lxb_char_t *
lexbor_str_data_ncasecmp_first(const lxb_char_t *first, const lxb_char_t *sec,
size_t sec_size)
{
size_t i;
for (i = 0; i < sec_size; i++) {
if (first[i] == '\0') {
return &first[i];
}
if (lexbor_str_res_map_lowercase[ first[i] ]
!= lexbor_str_res_map_lowercase[ sec[i] ])
{
return NULL;
}
}
return &first[i];
}
bool
lexbor_str_data_ncasecmp_end(const lxb_char_t *first, const lxb_char_t *sec,
size_t size)
{
while (size != 0) {
size--;
if (lexbor_str_res_map_lowercase[ first[size] ]
!= lexbor_str_res_map_lowercase[ sec[size] ])
{
return false;
}
}
return true;
}
bool
lexbor_str_data_ncasecmp_contain(const lxb_char_t *where, size_t where_size,
const lxb_char_t *what, size_t what_size)
{
for (size_t i = 0; what_size <= (where_size - i); i++) {
if(lexbor_str_data_ncasecmp(&where[i], what, what_size)) {
return true;
}
}
return false;
}
bool
lexbor_str_data_ncasecmp(const lxb_char_t *first, const lxb_char_t *sec,
size_t size)
{
for (size_t i = 0; i < size; i++) {
if (lexbor_str_res_map_lowercase[ first[i] ]
!= lexbor_str_res_map_lowercase[ sec[i] ])
{
return false;
}
}
return true;
}
bool
lexbor_str_data_nlocmp_right(const lxb_char_t *first, const lxb_char_t *sec,
size_t size)
{
for (size_t i = 0; i < size; i++) {
if (first[i] != lexbor_str_res_map_lowercase[ sec[i] ]) {
return false;
}
}
return true;
}
bool
lexbor_str_data_nupcmp_right(const lxb_char_t *first, const lxb_char_t *sec,
size_t size)
{
for (size_t i = 0; i < size; i++) {
if (first[i] != lexbor_str_res_map_uppercase[ sec[i] ]) {
return false;
}
}
return true;
}
bool
lexbor_str_data_casecmp(const lxb_char_t *first, const lxb_char_t *sec)
{
for (;;) {
if (lexbor_str_res_map_lowercase[*first]
!= lexbor_str_res_map_lowercase[*sec])
{
return false;
}
if (*first == '\0') {
return true;
}
first++;
sec++;
}
}
bool
lexbor_str_data_ncmp_end(const lxb_char_t *first, const lxb_char_t *sec,
size_t size)
{
while (size != 0) {
size--;
if (first[size] != sec[size]) {
return false;
}
}
return true;
}
bool
lexbor_str_data_ncmp_contain(const lxb_char_t *where, size_t where_size,
const lxb_char_t *what, size_t what_size)
{
for (size_t i = 0; what_size <= (where_size - i); i++) {
if(memcmp(&where[i], what, sizeof(lxb_char_t) * what_size) == 0) {
return true;
}
}
return false;
}
bool
lexbor_str_data_ncmp(const lxb_char_t *first, const lxb_char_t *sec,
size_t size)
{
return memcmp(first, sec, sizeof(lxb_char_t) * size) == 0;
}
bool
lexbor_str_data_cmp(const lxb_char_t *first, const lxb_char_t *sec)
{
for (;;) {
if (*first != *sec) {
return false;
}
if (*first == '\0') {
return true;
}
first++;
sec++;
}
}
bool
lexbor_str_data_cmp_ws(const lxb_char_t *first, const lxb_char_t *sec)
{
for (;;) {
if (*first != *sec) {
return false;
}
if (lexbor_utils_whitespace(*first, ==, ||) || *first == '\0') {
return true;
}
first++;
sec++;
}
}
void
lexbor_str_data_to_lowercase(lxb_char_t *to, const lxb_char_t *from, size_t len)
{
while (len) {
len--;
to[len] = lexbor_str_res_map_lowercase[ from[len] ];
}
}
void
lexbor_str_data_to_uppercase(lxb_char_t *to, const lxb_char_t *from, size_t len)
{
while (len) {
len--;
to[len] = lexbor_str_res_map_uppercase[ from[len] ];
}
}
const lxb_char_t *
lexbor_str_data_find_lowercase(const lxb_char_t *data, size_t len)
{
while (len) {
len--;
if (data[len] == lexbor_str_res_map_lowercase[ data[len] ]) {
return &data[len];
}
}
return NULL;
}
const lxb_char_t *
lexbor_str_data_find_uppercase(const lxb_char_t *data, size_t len)
{
while (len) {
len--;
if (data[len] == lexbor_str_res_map_uppercase[ data[len] ]) {
return &data[len];
}
}
return NULL;
}
/*
* No inline functions for ABI.
*/
lxb_char_t *
lexbor_str_data_noi(lexbor_str_t *str)
{
return lexbor_str_data(str);
}
size_t
lexbor_str_length_noi(lexbor_str_t *str)
{
return lexbor_str_length(str);
}
size_t
lexbor_str_size_noi(lexbor_str_t *str)
{
return lexbor_str_size(str);
}
void
lexbor_str_data_set_noi(lexbor_str_t *str, lxb_char_t *data)
{
lexbor_str_data_set(str, data);
}
lxb_char_t *
lexbor_str_length_set_noi(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t length)
{
return lexbor_str_length_set(str, mraw, length);
}

252
ext/dom/lexbor/lexbor/core/str.h Executable file
View file

@ -0,0 +1,252 @@
/*
* Copyright (C) 2018-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_STR_H
#define LEXBOR_STR_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/core/mraw.h"
#include "lexbor/core/utils.h"
#define lexbor_str_get(str, attr) str->attr
#define lexbor_str_set(str, attr) lexbor_str_get(str, attr)
#define lexbor_str_len(str) lexbor_str_get(str, length)
#define lexbor_str(p) {.data = (lxb_char_t *) (p), sizeof(p) - 1}
#define lexbor_str_check_size_arg_m(str, size, mraw, plus_len, return_fail) \
do { \
void *tmp; \
\
if (str->length > (SIZE_MAX - (plus_len))) \
return (return_fail); \
\
if ((str->length + (plus_len)) > (size)) { \
tmp = lexbor_mraw_realloc(mraw, str->data, \
(str->length + plus_len)); \
\
if (tmp == NULL) { \
return (return_fail); \
} \
\
str->data = (lxb_char_t *) tmp; \
} \
} \
while (0)
typedef struct {
lxb_char_t *data;
size_t length;
}
lexbor_str_t;
LXB_API lexbor_str_t *
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);
LXB_API void
lexbor_str_clean_all(lexbor_str_t *str);
LXB_API lexbor_str_t *
lexbor_str_destroy(lexbor_str_t *str, lexbor_mraw_t *mraw, bool destroy_obj);
LXB_API lxb_char_t *
lexbor_str_realloc(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t new_size);
LXB_API lxb_char_t *
lexbor_str_check_size(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t plus_len);
/* Append */
LXB_API lxb_char_t *
lexbor_str_append(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *data, size_t length);
LXB_API lxb_char_t *
lexbor_str_append_before(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *buff, size_t length);
LXB_API lxb_char_t *
lexbor_str_append_one(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t data);
LXB_API lxb_char_t *
lexbor_str_append_lowercase(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *data, size_t length);
LXB_API lxb_char_t *
lexbor_str_append_with_rep_null_chars(lexbor_str_t *str, lexbor_mraw_t *mraw,
const lxb_char_t *buff, size_t length);
/* Other functions */
LXB_API lxb_char_t *
lexbor_str_copy(lexbor_str_t *dest, const lexbor_str_t *target,
lexbor_mraw_t *mraw);
LXB_API void
lexbor_str_stay_only_whitespace(lexbor_str_t *target);
LXB_API void
lexbor_str_strip_collapse_whitespace(lexbor_str_t *target);
LXB_API size_t
lexbor_str_crop_whitespace_from_begin(lexbor_str_t *target);
LXB_API size_t
lexbor_str_whitespace_from_begin(lexbor_str_t *target);
LXB_API size_t
lexbor_str_whitespace_from_end(lexbor_str_t *target);
/* Data utils */
/*
* [in] first: must be null-terminated
* [in] sec: no matter what data
* [in] sec_size: size of the 'sec' buffer
*
* Function compare two lxb_char_t data until find '\0' in first arg.
* Successfully if the function returned a pointer starting with '\0',
* otherwise, if the data of the second buffer is insufficient function returned
* position in first buffer.
* If function returns NULL, the data are not equal.
*/
LXB_API const lxb_char_t *
lexbor_str_data_ncasecmp_first(const lxb_char_t *first, const lxb_char_t *sec,
size_t sec_size);
LXB_API bool
lexbor_str_data_ncasecmp_end(const lxb_char_t *first, const lxb_char_t *sec,
size_t size);
LXB_API bool
lexbor_str_data_ncasecmp_contain(const lxb_char_t *where, size_t where_size,
const lxb_char_t *what, size_t what_size);
LXB_API bool
lexbor_str_data_ncasecmp(const lxb_char_t *first, const lxb_char_t *sec,
size_t size);
LXB_API bool
lexbor_str_data_nlocmp_right(const lxb_char_t *first, const lxb_char_t *sec,
size_t size);
LXB_API bool
lexbor_str_data_nupcmp_right(const lxb_char_t *first, const lxb_char_t *sec,
size_t size);
LXB_API bool
lexbor_str_data_casecmp(const lxb_char_t *first, const lxb_char_t *sec);
LXB_API bool
lexbor_str_data_ncmp_end(const lxb_char_t *first, const lxb_char_t *sec,
size_t size);
LXB_API bool
lexbor_str_data_ncmp_contain(const lxb_char_t *where, size_t where_size,
const lxb_char_t *what, size_t what_size);
LXB_API bool
lexbor_str_data_ncmp(const lxb_char_t *first, const lxb_char_t *sec,
size_t size);
LXB_API bool
lexbor_str_data_cmp(const lxb_char_t *first, const lxb_char_t *sec);
LXB_API bool
lexbor_str_data_cmp_ws(const lxb_char_t *first, const lxb_char_t *sec);
LXB_API void
lexbor_str_data_to_lowercase(lxb_char_t *to, const lxb_char_t *from, size_t len);
LXB_API void
lexbor_str_data_to_uppercase(lxb_char_t *to, const lxb_char_t *from, size_t len);
LXB_API const lxb_char_t *
lexbor_str_data_find_lowercase(const lxb_char_t *data, size_t len);
LXB_API const lxb_char_t *
lexbor_str_data_find_uppercase(const lxb_char_t *data, size_t len);
/*
* Inline functions
*/
lxb_inline lxb_char_t *
lexbor_str_data(lexbor_str_t *str)
{
return str->data;
}
lxb_inline size_t
lexbor_str_length(lexbor_str_t *str)
{
return str->length;
}
lxb_inline size_t
lexbor_str_size(lexbor_str_t *str)
{
return lexbor_mraw_data_size(str->data);
}
lxb_inline void
lexbor_str_data_set(lexbor_str_t *str, lxb_char_t *data)
{
str->data = data;
}
lxb_inline lxb_char_t *
lexbor_str_length_set(lexbor_str_t *str, lexbor_mraw_t *mraw, size_t length)
{
if (length >= lexbor_str_size(str)) {
lxb_char_t *tmp;
tmp = lexbor_str_realloc(str, mraw, length + 1);
if (tmp == NULL) {
return NULL;
}
}
str->length = length;
str->data[length] = 0x00;
return str->data;
}
/*
* No inline functions for ABI.
*/
LXB_API lxb_char_t *
lexbor_str_data_noi(lexbor_str_t *str);
LXB_API size_t
lexbor_str_length_noi(lexbor_str_t *str);
LXB_API size_t
lexbor_str_size_noi(lexbor_str_t *str);
LXB_API void
lexbor_str_data_set_noi(lexbor_str_t *str, lxb_char_t *data);
LXB_API lxb_char_t *
lexbor_str_length_set_noi(lexbor_str_t *str, lexbor_mraw_t *mraw,
size_t length);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_STR_H */

420
ext/dom/lexbor/lexbor/core/str_res.h Executable file
View file

@ -0,0 +1,420 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_STR_RES_H
#define LEXBOR_STR_RES_H
#define LEXBOR_STR_RES_MAP_CHAR_OTHER '\00'
#define LEXBOR_STR_RES_MAP_CHAR_A_Z_a_z '\01'
#define LEXBOR_STR_RES_MAP_CHAR_WHITESPACE '\02'
#define LEXBOR_STR_RES_SLIP 0xFF
#endif /* LEXBOR_STR_RES_H */
#ifdef LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER
#ifndef LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER_ENABLED
#define LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER_ENABLED
static const lxb_char_t
lexbor_str_res_ansi_replacement_character[] = "\xEF\xBF\xBD";
#endif /* LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER_ENABLED */
#endif /* LEXBOR_STR_RES_ANSI_REPLACEMENT_CHARACTER */
#ifdef LEXBOR_STR_RES_MAP_NUM
#ifndef LEXBOR_STR_RES_MAP_NUM_ENABLED
#define LEXBOR_STR_RES_MAP_NUM_ENABLED
static const lxb_char_t lexbor_str_res_map_num[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x08, 0x09, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff
};
#endif /* LEXBOR_STR_RES_MAP_NUM_ENABLED */
#endif /* LEXBOR_STR_RES_MAP_NUM */
#ifdef LEXBOR_STR_RES_MAP_HEX
#ifndef LEXBOR_STR_RES_MAP_HEX_ENABLED
#define LEXBOR_STR_RES_MAP_HEX_ENABLED
static const lxb_char_t lexbor_str_res_map_hex[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x08, 0x09, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff
};
#endif /* LEXBOR_STR_RES_MAP_HEX_ENABLED */
#endif /* LEXBOR_STR_RES_MAP_HEX */
#ifdef LEXBOR_STR_RES_MAP_LOWERCASE
#ifndef LEXBOR_STR_RES_MAP_LOWERCASE_ENABLED
#define LEXBOR_STR_RES_MAP_LOWERCASE_ENABLED
static const lxb_char_t lexbor_str_res_map_lowercase[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c,
0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
0x3f, 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62,
0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74,
0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d,
0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86,
0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1,
0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc,
0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5,
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce,
0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0,
0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2,
0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
0xfc, 0xfd, 0xfe, 0xff
};
#endif /* LEXBOR_STR_RES_MAP_LOWERCASE_ENABLED */
#endif /* LEXBOR_STR_RES_MAP_LOWERCASE */
#ifdef LEXBOR_STR_RES_MAP_UPPERCASE
#ifndef LEXBOR_STR_RES_MAP_UPPERCASE_ENABLED
#define LEXBOR_STR_RES_MAP_UPPERCASE_ENABLED
static const lxb_char_t lexbor_str_res_map_uppercase[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c,
0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x41, 0x42,
0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54,
0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d,
0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86,
0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1,
0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc,
0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5,
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce,
0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0,
0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2,
0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
0xfc, 0xfd, 0xfe, 0xff
};
#endif /* LEXBOR_STR_RES_MAP_UPPERCASE_ENABLED */
#endif /* LEXBOR_STR_RES_MAP_UPPERCASE */
#ifdef LEXBOR_STR_RES_REPLACEMENT_CHARACTER
#ifndef LEXBOR_STR_RES_REPLACEMENT_CHARACTER_ENABLED
#define LEXBOR_STR_RES_REPLACEMENT_CHARACTER_ENABLED
static const size_t lexbor_str_res_replacement_character[] = {
65533, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80,
81, 82, 83, 84, 85, 86, 87, 88, 89,
90, 91, 92, 93, 94, 95, 96, 97, 98,
99, 100, 101, 102, 103, 104, 105, 106, 107,
108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 118, 119, 120, 121, 122, 123, 124, 125,
126, 127, 8364, 129, 8218, 402, 8222, 8230, 8224,
8225, 710, 8240, 352, 8249, 338, 141, 381, 143,
144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732,
8482, 353, 8250, 339, 157, 382, 376
};
#endif /* LEXBOR_STR_RES_REPLACEMENT_CHARACTER_ENABLED */
#endif /* LEXBOR_STR_RES_REPLACEMENT_CHARACTER */
#ifdef LEXBOR_STR_RES_ALPHANUMERIC_CHARACTER
#ifndef LEXBOR_STR_RES_ALPHANUMERIC_CHARACTER_ENABLED
#define LEXBOR_STR_RES_ALPHANUMERIC_CHARACTER_ENABLED
static const size_t lexbor_str_res_alphanumeric_character[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x08, 0x09, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a,
0x0b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x0d,
0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff
};
#endif /* LEXBOR_STR_RES_ALPHANUMERIC_CHARACTER_ENABLED */
#endif /* LEXBOR_STR_RES_ALPHANUMERIC_CHARACTER */
#ifdef LEXBOR_STR_RES_ALPHA_CHARACTER
#ifndef LEXBOR_STR_RES_ALPHA_CHARACTER_ENABLED
#define LEXBOR_STR_RES_ALPHA_CHARACTER_ENABLED
static const size_t lexbor_str_res_alpha_character[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a,
0x0b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x0d,
0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x0a, 0x0b, 0x0c, 0x0d, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff
};
#endif /* LEXBOR_STR_RES_ALPHA_CHARACTER_ENABLED */
#endif /* LEXBOR_STR_RES_ALPHA_CHARACTER */
#ifdef LEXBOR_TOKENIZER_CHARS_MAP
#ifndef LEXBOR_TOKENIZER_CHARS_MAP_ENABLED
#define LEXBOR_TOKENIZER_CHARS_MAP_ENABLED
static const unsigned char lexbor_tokenizer_chars_map[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x02, 0x02, 0xff, 0x02, 0x02, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0x02, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff
};
#endif /* LEXBOR_TOKENIZER_CHARS_MAP_ENABLED */
#endif /* LEXBOR_TOKENIZER_CHARS_MAP */
#ifdef LEXBOR_STR_RES_MAP_HEX_TO_CHAR
#ifndef LEXBOR_STR_RES_MAP_HEX_TO_CHAR_ENABLED
#define LEXBOR_STR_RES_MAP_HEX_TO_CHAR_ENABLED
static const lxb_char_t lexbor_str_res_map_hex_to_char[] = {
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x00
};
#endif /* LEXBOR_STR_RES_MAP_HEX_TO_CHAR_ENABLED */
#endif /* LEXBOR_STR_RES_MAP_HEX_TO_CHAR */
#ifdef LEXBOR_STR_RES_MAP_HEX_TO_CHAR_LOWERCASE
#ifndef LEXBOR_STR_RES_MAP_HEX_TO_CHAR_LOWERCASE_ENABLED
#define LEXBOR_STR_RES_MAP_HEX_TO_CHAR_LOWERCASE_ENABLED
static const lxb_char_t lexbor_str_res_map_hex_to_char_lowercase[] = {
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x00
};
#endif /* LEXBOR_STR_RES_MAP_HEX_TO_CHAR_LOWERCASE_ENABLED */
#endif /* LEXBOR_STR_RES_MAP_HEX_TO_CHAR_LOWERCASE */
#ifdef LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE
#ifndef LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_ENABLED
#define LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_ENABLED
static const char * lexbor_str_res_char_to_two_hex_value[257] = {
"00", "01", "02", "03", "04", "05", "06", "07",
"08", "09", "0A", "0B", "0C", "0D", "0E", "0F",
"10", "11", "12", "13", "14", "15", "16", "17",
"18", "19", "1A", "1B", "1C", "1D", "1E", "1F",
"20", "21", "22", "23", "24", "25", "26", "27",
"28", "29", "2A", "2B", "2C", "2D", "2E", "2F",
"30", "31", "32", "33", "34", "35", "36", "37",
"38", "39", "3A", "3B", "3C", "3D", "3E", "3F",
"40", "41", "42", "43", "44", "45", "46", "47",
"48", "49", "4A", "4B", "4C", "4D", "4E", "4F",
"50", "51", "52", "53", "54", "55", "56", "57",
"58", "59", "5A", "5B", "5C", "5D", "5E", "5F",
"60", "61", "62", "63", "64", "65", "66", "67",
"68", "69", "6A", "6B", "6C", "6D", "6E", "6F",
"70", "71", "72", "73", "74", "75", "76", "77",
"78", "79", "7A", "7B", "7C", "7D", "7E", "7F",
"80", "81", "82", "83", "84", "85", "86", "87",
"88", "89", "8A", "8B", "8C", "8D", "8E", "8F",
"90", "91", "92", "93", "94", "95", "96", "97",
"98", "99", "9A", "9B", "9C", "9D", "9E", "9F",
"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
"A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF",
"B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7",
"B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF",
"C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7",
"C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF",
"D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
"D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF",
"E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7",
"E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF",
"F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7",
"F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF",
NULL
};
#endif /* LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_ENABLED */
#endif /* LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE */
#ifdef LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_LOWERCASE
#ifndef LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_LOWERCASE_ENABLED
#define LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_LOWERCASE_ENABLED
static const char * lexbor_str_res_char_to_two_hex_value_lowercase[257] = {
"00", "01", "02", "03", "04", "05", "06", "07",
"08", "09", "0a", "0b", "0c", "0d", "0e", "0f",
"10", "11", "12", "13", "14", "15", "16", "17",
"18", "19", "1a", "1b", "1c", "1d", "1e", "1f",
"20", "21", "22", "23", "24", "25", "26", "27",
"28", "29", "2a", "2b", "2c", "2d", "2e", "2f",
"30", "31", "32", "33", "34", "35", "36", "37",
"38", "39", "3a", "3b", "3c", "3d", "3e", "3f",
"40", "41", "42", "43", "44", "45", "46", "47",
"48", "49", "4a", "4b", "4c", "4d", "4e", "4f",
"50", "51", "52", "53", "54", "55", "56", "57",
"58", "59", "5a", "5b", "5c", "5d", "5e", "5f",
"60", "61", "62", "63", "64", "65", "66", "67",
"68", "69", "6a", "6b", "6c", "6d", "6e", "6f",
"70", "71", "72", "73", "74", "75", "76", "77",
"78", "79", "7a", "7b", "7c", "7d", "7e", "7f",
"80", "81", "82", "83", "84", "85", "86", "87",
"88", "89", "8a", "8b", "8c", "8d", "8e", "8f",
"90", "91", "92", "93", "94", "95", "96", "97",
"98", "99", "9a", "9b", "9c", "9d", "9e", "9f",
"a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
"a8", "a9", "aa", "ab", "ac", "ad", "ae", "af",
"b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
"b8", "b9", "ba", "bb", "bc", "bd", "be", "bf",
"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7",
"c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf",
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"d8", "d9", "da", "db", "dc", "dd", "de", "df",
"e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7",
"e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef",
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
"f8", "f9", "fa", "fb", "fc", "fd", "fe", "ff",
NULL
};
#endif /* LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_LOWERCASE_ENABLED */
#endif /* LEXBOR_STR_RES_CHAR_TO_TWO_HEX_VALUE_LOWERCASE */

326
ext/dom/lexbor/lexbor/core/strtod.c Executable file
View file

@ -0,0 +1,326 @@
/*
* Copyright (C) Alexander Borisov
*
* Based on nxt_strtod.c from NGINX NJS project
*
* An internal strtod() implementation based upon V8 src/strtod.cc
* without bignum support.
*
* Copyright 2012 the V8 project authors. All rights reserved.
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file.
*/
#include <stdint.h>
#include <math.h>
#include "lexbor/core/diyfp.h"
#include "lexbor/core/strtod.h"
/*
* Max double: 1.7976931348623157 x 10^308
* Min non-zero double: 4.9406564584124654 x 10^-324
* Any x >= 10^309 is interpreted as +infinity.
* Any x <= 10^-324 is interpreted as 0.
* Note that 2.5e-324 (despite being smaller than the min double)
* will be read as non-zero (equal to the min non-zero double).
*/
#define LEXBOR_DECIMAL_POWER_MAX 309
#define LEXBOR_DECIMAL_POWER_MIN (-324)
#define LEXBOR_UINT64_MAX lexbor_uint64_hl(0xFFFFFFFF, 0xFFFFFFFF)
#define LEXBOR_UINT64_DECIMAL_DIGITS_MAX 19
#define LEXBOR_DENOM_LOG 3
#define LEXBOR_DENOM (1 << LEXBOR_DENOM_LOG)
static lexbor_diyfp_t
lexbor_strtod_diyfp_read(const lxb_char_t *start, size_t length,
int *remaining);
static double
lexbor_strtod_diyfp_strtod(const lxb_char_t *start, size_t length, int exp);
/*
* Reads digits from the buffer and converts them to a uint64.
* Reads in as many digits as fit into a uint64.
* When the string starts with "1844674407370955161" no further digit is read.
* Since 2^64 = 18446744073709551616 it would still be possible read another
* digit if it was less or equal than 6, but this would complicate the code.
*/
lxb_inline uint64_t
lexbor_strtod_read_uint64(const lxb_char_t *start, size_t length,
size_t *ndigits)
{
lxb_char_t d;
uint64_t value;
const lxb_char_t *p, *e;
value = 0;
p = start;
e = p + length;
while (p < e && value <= (UINT64_MAX / 10 - 1)) {
d = *p++ - '0';
value = 10 * value + d;
}
*ndigits = p - start;
return value;
}
/*
* Reads a nxt_diyfp_t from the buffer.
* The returned nxt_diyfp_t is not necessarily normalized.
* If remaining is zero then the returned nxt_diyfp_t is accurate.
* Otherwise it has been rounded and has error of at most 1/2 ulp.
*/
static lexbor_diyfp_t
lexbor_strtod_diyfp_read(const lxb_char_t *start, size_t length, int *remaining)
{
size_t read;
uint64_t significand;
significand = lexbor_strtod_read_uint64(start, length, &read);
/* Round the significand. */
if (length != read) {
if (start[read] >= '5') {
significand++;
}
}
*remaining = (int) (length - read);
return lexbor_diyfp(significand, 0);
}
/*
* Returns 10^exp as an exact nxt_diyfp_t.
* The given exp must be in the range [1; NXT_DECIMAL_EXPONENT_DIST[.
*/
lxb_inline lexbor_diyfp_t
lexbor_strtod_adjust_pow10(int exp)
{
switch (exp) {
case 1:
return lexbor_diyfp(lexbor_uint64_hl(0xa0000000, 00000000), -60);
case 2:
return lexbor_diyfp(lexbor_uint64_hl(0xc8000000, 00000000), -57);
case 3:
return lexbor_diyfp(lexbor_uint64_hl(0xfa000000, 00000000), -54);
case 4:
return lexbor_diyfp(lexbor_uint64_hl(0x9c400000, 00000000), -50);
case 5:
return lexbor_diyfp(lexbor_uint64_hl(0xc3500000, 00000000), -47);
case 6:
return lexbor_diyfp(lexbor_uint64_hl(0xf4240000, 00000000), -44);
case 7:
return lexbor_diyfp(lexbor_uint64_hl(0x98968000, 00000000), -40);
default:
return lexbor_diyfp(0, 0);
}
}
/*
* Returns the significand size for a given order of magnitude.
* If v = f*2^e with 2^p-1 <= f <= 2^p then p+e is v's order of magnitude.
* This function returns the number of significant binary digits v will have
* once its encoded into a double. In almost all cases this is equal to
* NXT_SIGNIFICAND_SIZE. The only exception are denormals. They start with
* leading zeroes and their effective significand-size is hence smaller.
*/
lxb_inline int
lexbor_strtod_diyfp_sgnd_size(int order)
{
if (order >= (LEXBOR_DBL_EXPONENT_DENORMAL + LEXBOR_SIGNIFICAND_SIZE)) {
return LEXBOR_SIGNIFICAND_SIZE;
}
if (order <= LEXBOR_DBL_EXPONENT_DENORMAL) {
return 0;
}
return order - LEXBOR_DBL_EXPONENT_DENORMAL;
}
/*
* Returns either the correct double or the double that is just below
* the correct double.
*/
static double
lexbor_strtod_diyfp_strtod(const lxb_char_t *start, size_t length, int exp)
{
int magnitude, prec_digits;
int remaining, dec_exp, adj_exp, orig_e, shift;
int64_t error;
uint64_t prec_bits, half_way;
lexbor_diyfp_t value, pow, adj_pow, rounded;
value = lexbor_strtod_diyfp_read(start, length, &remaining);
exp += remaining;
/*
* Since some digits may have been dropped the value is not accurate.
* If remaining is different than 0 than the error is at most .5 ulp
* (unit in the last place).
* Using a common denominator to avoid dealing with fractions.
*/
error = (remaining == 0 ? 0 : LEXBOR_DENOM / 2);
orig_e = value.exp;
value = lexbor_diyfp_normalize(value);
error <<= orig_e - value.exp;
if (exp < LEXBOR_DECIMAL_EXPONENT_MIN) {
return 0.0;
}
pow = lexbor_cached_power_dec(exp, &dec_exp);
if (dec_exp != exp) {
adj_exp = exp - dec_exp;
adj_pow = lexbor_strtod_adjust_pow10(exp - dec_exp);
value = lexbor_diyfp_mul(value, adj_pow);
if (LEXBOR_UINT64_DECIMAL_DIGITS_MAX - (int) length < adj_exp) {
/*
* The adjustment power is exact. There is hence only
* an error of 0.5.
*/
error += LEXBOR_DENOM / 2;
}
}
value = lexbor_diyfp_mul(value, pow);
/*
* The error introduced by a multiplication of a * b equals
* error_a + error_b + error_a * error_b / 2^64 + 0.5
* Substituting a with 'value' and b with 'pow':
* error_b = 0.5 (all cached powers have an error of less than 0.5 ulp),
* error_ab = 0 or 1 / NXT_DENOM > error_a * error_b / 2^64.
*/
error += LEXBOR_DENOM + (error != 0 ? 1 : 0);
orig_e = value.exp;
value = lexbor_diyfp_normalize(value);
error <<= orig_e - value.exp;
/*
* Check whether the double's significand changes when the error is added
* or subtracted.
*/
magnitude = LEXBOR_DIYFP_SIGNIFICAND_SIZE + value.exp;
prec_digits = LEXBOR_DIYFP_SIGNIFICAND_SIZE
- lexbor_strtod_diyfp_sgnd_size(magnitude);
if (prec_digits + LEXBOR_DENOM_LOG >= LEXBOR_DIYFP_SIGNIFICAND_SIZE) {
/*
* This can only happen for very small denormals. In this case the
* half-way multiplied by the denominator exceeds the range of uint64.
* Simply shift everything to the right.
*/
shift = prec_digits + LEXBOR_DENOM_LOG
- LEXBOR_DIYFP_SIGNIFICAND_SIZE + 1;
value = lexbor_diyfp_shift_right(value, shift);
/*
* Add 1 for the lost precision of error, and NXT_DENOM
* for the lost precision of value.significand.
*/
error = (error >> shift) + 1 + LEXBOR_DENOM;
prec_digits -= shift;
}
prec_bits = value.significand & (((uint64_t) 1 << prec_digits) - 1);
prec_bits *= LEXBOR_DENOM;
half_way = (uint64_t) 1 << (prec_digits - 1);
half_way *= LEXBOR_DENOM;
rounded = lexbor_diyfp_shift_right(value, prec_digits);
if (prec_bits >= half_way + error) {
rounded.significand++;
}
return lexbor_diyfp_2d(rounded);
}
double
lexbor_strtod_internal(const lxb_char_t *start, size_t length, int exp)
{
size_t left, right;
const lxb_char_t *p, *e, *b;
/* Trim leading zeroes. */
p = start;
e = p + length;
while (p < e) {
if (*p != '0') {
start = p;
break;
}
p++;
}
left = e - p;
/* Trim trailing zeroes. */
b = start;
p = b + left - 1;
while (p > b) {
if (*p != '0') {
break;
}
p--;
}
right = p - b + 1;
length = right;
if (length == 0) {
return 0.0;
}
exp += (int) (left - right);
if (exp + (int) length - 1 >= LEXBOR_DECIMAL_POWER_MAX) {
return INFINITY;
}
if (exp + (int) length <= LEXBOR_DECIMAL_POWER_MIN) {
return 0.0;
}
return lexbor_strtod_diyfp_strtod(start, length, exp);
}
#undef LEXBOR_DECIMAL_POWER_MAX
#undef LEXBOR_DECIMAL_POWER_MIN
#undef LEXBOR_UINT64_MAX
#undef LEXBOR_UINT64_DECIMAL_DIGITS_MAX
#undef LEXBOR_DENOM_LOG
#undef LEXBOR_DENOM

28
ext/dom/lexbor/lexbor/core/strtod.h Executable file
View file

@ -0,0 +1,28 @@
/*
* Copyright (C) Alexander Borisov
*
* Based on nxt_strtod.h from NGINX NJS project
*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) Nginx, Inc.
*/
#ifndef LEXBOR_STRTOD_H
#define LEXBOR_STRTOD_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
LXB_API double
lexbor_strtod_internal(const lxb_char_t *start, size_t length, int exp);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_STRTOD_H */

39
ext/dom/lexbor/lexbor/core/types.h Executable file
View file

@ -0,0 +1,39 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_TYPES_H
#define LEXBOR_TYPES_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.h>
/* Inline */
#ifdef _MSC_VER
#define lxb_inline static __forceinline
#else
#define lxb_inline static inline
#endif
/* Simple types */
typedef uint32_t lxb_codepoint_t;
typedef unsigned char lxb_char_t;
typedef unsigned int lxb_status_t;
/* Callbacks */
typedef lxb_status_t (*lexbor_callback_f)(const lxb_char_t *buffer,
size_t size, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_TYPES_H */

43
ext/dom/lexbor/lexbor/core/utils.c Executable file
View file

@ -0,0 +1,43 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/core/utils.h"
size_t
lexbor_utils_power(size_t t, size_t k)
{
size_t res = 1;
while (k) {
if (k & 1) {
res *= t;
}
t *= t;
k >>= 1;
}
return res;
}
size_t
lexbor_utils_hash_hash(const lxb_char_t *key, size_t key_size)
{
size_t hash, i;
for (hash = i = 0; i < key_size; i++) {
hash += key[i];
hash += (hash << 10);
hash ^= (hash >> 6);
}
hash += (hash << 3);
hash ^= (hash >> 11);
hash += (hash << 15);
return hash;
}

36
ext/dom/lexbor/lexbor/core/utils.h Executable file
View file

@ -0,0 +1,36 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_UTILS_H
#define LEXBOR_UTILS_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#define lexbor_utils_whitespace(onechar, action, logic) \
(onechar action ' ' logic \
onechar action '\t' logic \
onechar action '\n' logic \
onechar action '\f' logic \
onechar action '\r')
LXB_API size_t
lexbor_utils_power(size_t t, size_t k);
LXB_API size_t
lexbor_utils_hash_hash(const lxb_char_t *key, size_t key_size);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_UTILS_H */

134
ext/dom/lexbor/lexbor/css/at_rule.h Normal file
View file

@ -0,0 +1,134 @@
/*
* Copyright (C) 2021-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_AT_RULE_H
#define LXB_CSS_AT_RULE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
#include "lexbor/css/syntax/syntax.h"
#include "lexbor/css/at_rule/const.h"
typedef struct {
lxb_css_at_rule_type_t type;
lexbor_str_t prelude;
lexbor_str_t block;
}
lxb_css_at_rule__undef_t;
typedef struct {
lexbor_str_t name;
lexbor_str_t prelude;
lexbor_str_t block;
}
lxb_css_at_rule__custom_t;
typedef struct {
uintptr_t reserved;
}
lxb_css_at_rule_media_t;
typedef struct {
uintptr_t reserved;
}
lxb_css_at_rule_namespace_t;
LXB_API const lxb_css_entry_data_t *
lxb_css_at_rule_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_entry_data_t *
lxb_css_at_rule_by_id(uintptr_t id);
LXB_API void *
lxb_css_at_rule_destroy(lxb_css_memory_t *memory, void *value,
lxb_css_at_rule_type_t type, bool self_destroy);
LXB_API lxb_status_t
lxb_css_at_rule_serialize(const void *style, lxb_css_at_rule_type_t type,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_at_rule_serialize_str(const void *style, lxb_css_at_rule_type_t type,
lexbor_mraw_t *mraw, lexbor_str_t *str);
LXB_API lxb_status_t
lxb_css_at_rule_serialize_name(const void *style, lxb_css_at_rule_type_t type,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_at_rule_serialize_name_str(const void *style, lxb_css_at_rule_type_t type,
lexbor_mraw_t *mraw, lexbor_str_t *str);
/* _undef. */
LXB_API void *
lxb_css_at_rule__undef_create(lxb_css_memory_t *memory);
LXB_API void *
lxb_css_at_rule__undef_destroy(lxb_css_memory_t *memory,
void *style, bool self_destroy);
LXB_API lxb_status_t
lxb_css_at_rule__undef_make(lxb_css_parser_t *parser,
lxb_css_at_rule__undef_t *undef,
const lxb_css_syntax_at_rule_offset_t *at_rule);
LXB_API lxb_status_t
lxb_css_at_rule__undef_serialize(const void *style, lexbor_serialize_cb_f cb,
void *ctx);
LXB_API lxb_status_t
lxb_css_at_rule__undef_serialize_name(const void *at, lexbor_serialize_cb_f cb,
void *ctx);
/* _custom. */
LXB_API void *
lxb_css_at_rule__custom_create(lxb_css_memory_t *memory);
LXB_API void *
lxb_css_at_rule__custom_destroy(lxb_css_memory_t *memory,
void *style, bool self_destroy);
LXB_API lxb_status_t
lxb_css_at_rule__custom_make(lxb_css_parser_t *parser,
lxb_css_at_rule__custom_t *custom,
const lxb_css_syntax_at_rule_offset_t *at_rule);
LXB_API lxb_status_t
lxb_css_at_rule__custom_serialize(const void *style, lexbor_serialize_cb_f cb,
void *ctx);
LXB_API lxb_status_t
lxb_css_at_rule__custom_serialize_name(const void *at, lexbor_serialize_cb_f cb,
void *ctx);
/* Media. */
LXB_API void *
lxb_css_at_rule_media_create(lxb_css_memory_t *memory);
LXB_API void *
lxb_css_at_rule_media_destroy(lxb_css_memory_t *memory,
void *style, bool self_destroy);
LXB_API lxb_status_t
lxb_css_at_rule_media_serialize(const void *style, lexbor_serialize_cb_f cb,
void *ctx);
/* Namespace. */
LXB_API void *
lxb_css_at_rule_namespace_create(lxb_css_memory_t *memory);
LXB_API void *
lxb_css_at_rule_namespace_destroy(lxb_css_memory_t *memory,
void *style, bool self_destroy);
LXB_API lxb_status_t
lxb_css_at_rule_namespace_serialize(const void *style, lexbor_serialize_cb_f cb,
void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_AT_RULE_H */

31
ext/dom/lexbor/lexbor/css/at_rule/const.h Normal file
View file

@ -0,0 +1,31 @@
/*
* Copyright (C) 2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/names.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_AT_RULE_CONST_H
#define LXB_CSS_AT_RULE_CONST_H
#include "lexbor/css/value/const.h"
enum {
LXB_CSS_AT_RULE__UNDEF = 0x0000,
LXB_CSS_AT_RULE__CUSTOM = 0x0001,
LXB_CSS_AT_RULE_MEDIA = 0x0002,
LXB_CSS_AT_RULE_NAMESPACE = 0x0003,
LXB_CSS_AT_RULE__LAST_ENTRY = 0x0004
};
typedef uintptr_t lxb_css_at_rule_type_t;
#endif /* LXB_CSS_AT_RULE_CONST_H */

46
ext/dom/lexbor/lexbor/css/at_rule/res.h Normal file
View file

@ -0,0 +1,46 @@
/*
* Copyright (C) 2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/names.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_AT_RULE_RES_H
#define LXB_CSS_AT_RULE_RES_H
#include "lexbor/core/shs.h"
#include "lexbor/css/at_rule/const.h"
static const lxb_css_entry_data_t lxb_css_at_rule_data[LXB_CSS_AT_RULE__LAST_ENTRY] =
{
{(lxb_char_t *) "#undef", 6, LXB_CSS_AT_RULE__UNDEF, lxb_css_at_rule_state__undef,
lxb_css_at_rule__undef_create, lxb_css_at_rule__undef_destroy, lxb_css_at_rule__undef_serialize, (void *) (uintptr_t) LXB_CSS_AT_RULE__UNDEF},
{(lxb_char_t *) "#сustom", 7, LXB_CSS_AT_RULE__CUSTOM, lxb_css_at_rule_state__custom,
lxb_css_at_rule__custom_create, lxb_css_at_rule__custom_destroy, lxb_css_at_rule__custom_serialize, (void *) (uintptr_t) LXB_CSS_AT_RULE__CUSTOM},
{(lxb_char_t *) "media", 5, LXB_CSS_AT_RULE_MEDIA, lxb_css_at_rule_state_media,
lxb_css_at_rule_media_create, lxb_css_at_rule_media_destroy, lxb_css_at_rule_media_serialize,
NULL},
{(lxb_char_t *) "namespace", 9, LXB_CSS_AT_RULE_NAMESPACE, lxb_css_at_rule_state_namespace,
lxb_css_at_rule_namespace_create, lxb_css_at_rule_namespace_destroy, lxb_css_at_rule_namespace_serialize,
NULL}
};
static const lexbor_shs_entry_t lxb_css_at_rule_shs[6] =
{
{NULL, NULL, 5, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"media", (void *) &lxb_css_at_rule_data[LXB_CSS_AT_RULE_MEDIA], 5, 0},
{NULL, NULL, 0, 0},
{"namespace", (void *) &lxb_css_at_rule_data[LXB_CSS_AT_RULE_NAMESPACE], 9, 0}
};
#endif /* LXB_CSS_AT_RULE_RES_H */

36
ext/dom/lexbor/lexbor/css/at_rule/state.h Normal file
View file

@ -0,0 +1,36 @@
/*
* Copyright (C) 2021-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_AT_RULE_STATE_H
#define LXB_CSS_AT_RULE_STATE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
LXB_API bool
lxb_css_at_rule_state__undef(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_at_rule_state__custom(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_at_rule_state_media(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_at_rule_state_namespace(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_AT_RULE_STATE_H */

119
ext/dom/lexbor/lexbor/css/base.h Normal file
View file

@ -0,0 +1,119 @@
/*
* Copyright (C) 2019-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_BASE_H
#define LEXBOR_CSS_BASE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/core/mraw.h"
#include "lexbor/core/str.h"
#define LXB_CSS_VERSION_MAJOR 1
#define LXB_CSS_VERSION_MINOR 1
#define LXB_CSS_VERSION_PATCH 0
#define LXB_CSS_VERSION_STRING \
LEXBOR_STRINGIZE(LXB_CSS_VERSION_MAJOR) "." \
LEXBOR_STRINGIZE(LXB_CSS_VERSION_MINOR) "." \
LEXBOR_STRINGIZE(LXB_CSS_VERSION_PATCH)
typedef struct lxb_css_memory {
lexbor_dobject_t *objs;
lexbor_mraw_t *mraw;
lexbor_mraw_t *tree;
size_t ref_count;
}
lxb_css_memory_t;
typedef uint32_t lxb_css_type_t;
typedef struct lxb_css_parser lxb_css_parser_t;
typedef struct lxb_css_parser_state lxb_css_parser_state_t;
typedef struct lxb_css_parser_error lxb_css_parser_error_t;
typedef struct lxb_css_syntax_tokenizer lxb_css_syntax_tokenizer_t;
typedef struct lxb_css_syntax_token lxb_css_syntax_token_t;
typedef bool
(*lxb_css_parser_state_f)(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
typedef void *
(*lxb_css_style_create_f)(lxb_css_memory_t *memory);
typedef lxb_status_t
(*lxb_css_style_serialize_f)(const void *style, lexbor_serialize_cb_f cb,
void *ctx);
typedef void *
(*lxb_css_style_destroy_f)(lxb_css_memory_t *memory,
void *style, bool self_destroy);
/* StyleSheet tree structures. */
typedef struct lxb_css_stylesheet lxb_css_stylesheet_t;
typedef struct lxb_css_rule_list lxb_css_rule_list_t;
typedef struct lxb_css_rule_style lxb_css_rule_style_t;
typedef struct lxb_css_rule_bad_style lxb_css_rule_bad_style_t;
typedef struct lxb_css_rule_declaration_list lxb_css_rule_declaration_list_t;
typedef struct lxb_css_rule_declaration lxb_css_rule_declaration_t;
typedef struct lxb_css_rule_at lxb_css_rule_at_t;
typedef struct {
lxb_char_t *name;
size_t length;
uintptr_t unique;
lxb_css_parser_state_f state;
lxb_css_style_create_f create;
lxb_css_style_destroy_f destroy;
lxb_css_style_serialize_f serialize;
void *initial;
}
lxb_css_entry_data_t;
typedef struct {
lxb_char_t *name;
size_t length;
uintptr_t unique;
}
lxb_css_data_t;
LXB_API lxb_css_memory_t *
lxb_css_memory_create(void);
LXB_API lxb_status_t
lxb_css_memory_init(lxb_css_memory_t *memory, size_t prepare_count);
LXB_API void
lxb_css_memory_clean(lxb_css_memory_t *memory);
LXB_API lxb_css_memory_t *
lxb_css_memory_destroy(lxb_css_memory_t *memory, bool self_destroy);
LXB_API lxb_css_memory_t *
lxb_css_memory_ref_inc(lxb_css_memory_t *memory);
LXB_API void
lxb_css_memory_ref_dec(lxb_css_memory_t *memory);
LXB_API lxb_css_memory_t *
lxb_css_memory_ref_dec_destroy(lxb_css_memory_t *memory);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_BASE_H */

52
ext/dom/lexbor/lexbor/css/css.h Normal file
View file

@ -0,0 +1,52 @@
/*
* Copyright (C) 2020-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_H
#define LXB_CSS_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
#include "lexbor/css/log.h"
#include "lexbor/css/parser.h"
#include "lexbor/css/stylesheet.h"
#include "lexbor/css/property.h"
#include "lexbor/css/value.h"
#include "lexbor/css/at_rule.h"
#include "lexbor/css/rule.h"
#include "lexbor/css/unit.h"
#include "lexbor/css/state.h"
#include "lexbor/css/declaration.h"
#include "lexbor/css/syntax/tokenizer/error.h"
#include "lexbor/css/syntax/tokenizer.h"
#include "lexbor/css/syntax/token.h"
#include "lexbor/css/syntax/parser.h"
#include "lexbor/css/syntax/anb.h"
#include "lexbor/css/selectors/selectors.h"
#include "lexbor/css/selectors/selector.h"
#include "lexbor/css/selectors/state.h"
#include "lexbor/css/selectors/pseudo.h"
LXB_API lxb_status_t
lxb_css_make_data(lxb_css_parser_t *parser, lexbor_str_t *str,
uintptr_t begin, uintptr_t end);
LXB_API lxb_char_t *
lxb_css_serialize_char_handler(const void *style, lxb_css_style_serialize_f cb,
size_t *out_length);
LXB_API lxb_status_t
lxb_css_serialize_str_handler(const void *style, lexbor_str_t *str,
lexbor_mraw_t *mraw, lxb_css_style_serialize_f cb);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_H */

38
ext/dom/lexbor/lexbor/css/declaration.h Normal file
View file

@ -0,0 +1,38 @@
/*
* Copyright (C) 2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_DECLARATION_H
#define LXB_CSS_DECLARATION_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/css.h"
#include "lexbor/core/mraw.h"
LXB_API lxb_status_t
lxb_css_declaration_list_prepare(lxb_css_parser_t *parser,
lxb_css_memory_t *mem);
LXB_API lxb_css_rule_declaration_list_t *
lxb_css_declaration_list_process(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API void
lxb_css_declaration_list_finish(lxb_css_parser_t *parser);
LXB_API lxb_css_rule_declaration_list_t *
lxb_css_declaration_list_parse(lxb_css_parser_t *parser, lxb_css_memory_t *mem,
const lxb_char_t *data, size_t length);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_DECLARATION_H */

103
ext/dom/lexbor/lexbor/css/log.h Normal file
View file

@ -0,0 +1,103 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_LOG_H
#define LEXBOR_CSS_LOG_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/mraw.h"
#include "lexbor/core/str.h"
#include "lexbor/core/array_obj.h"
#include "lexbor/css/base.h"
typedef enum {
LXB_CSS_LOG_INFO = 0,
LXB_CSS_LOG_WARNING,
LXB_CSS_LOG_ERROR,
LXB_CSS_LOG_SYNTAX_ERROR
}
lxb_css_log_type_t;
typedef struct {
lexbor_str_t text;
lxb_css_log_type_t type;
}
lxb_css_log_message_t;
typedef struct {
lexbor_array_obj_t messages;
lexbor_mraw_t *mraw;
bool self_mraw;
}
lxb_css_log_t;
LXB_API lxb_css_log_t *
lxb_css_log_create(void);
LXB_API lxb_status_t
lxb_css_log_init(lxb_css_log_t *log, lexbor_mraw_t *mraw);
LXB_API void
lxb_css_log_clean(lxb_css_log_t *log);
LXB_API lxb_css_log_t *
lxb_css_log_destroy(lxb_css_log_t *log, bool self_destroy);
LXB_API lxb_css_log_message_t *
lxb_css_log_append(lxb_css_log_t *log, lxb_css_log_type_t type,
const lxb_char_t *str, size_t length);
LXB_API lxb_css_log_message_t *
lxb_css_log_push(lxb_css_log_t *log, lxb_css_log_type_t type, size_t length);
LXB_API lxb_css_log_message_t *
lxb_css_log_format(lxb_css_log_t *log, lxb_css_log_type_t type,
const char *format, ...);
LXB_API lxb_css_log_message_t *
lxb_css_log_not_supported(lxb_css_log_t *log,
const char *module_name, const char *description);
LXB_API const lxb_char_t *
lxb_css_log_type_by_id(lxb_css_log_type_t type, size_t *out_length);
LXB_API lxb_status_t
lxb_css_log_serialize(lxb_css_log_t *log, lexbor_serialize_cb_f cb, void *ctx,
const lxb_char_t *indent, size_t indent_length);
LXB_API lxb_char_t *
lxb_css_log_serialize_char(lxb_css_log_t *log, size_t *out_length,
const lxb_char_t *indent, size_t indent_length);
LXB_API lxb_status_t
lxb_css_log_message_serialize(lxb_css_log_message_t *msg,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_char_t *
lxb_css_log_message_serialize_char(lxb_css_log_message_t *msg,
size_t *out_length);
/*
* Inline functions
*/
lxb_inline size_t
lxb_css_log_length(lxb_css_log_t *log)
{
return lexbor_array_obj_length(&log->messages);
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_LOG_H */

517
ext/dom/lexbor/lexbor/css/parser.h Normal file
View file

@ -0,0 +1,517 @@
/*
* Copyright (C) 2021-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_PARSER_H
#define LEXBOR_CSS_PARSER_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/log.h"
#include "lexbor/css/stylesheet.h"
#include "lexbor/css/syntax/parser.h"
#include "lexbor/css/selectors/selectors.h"
#define lxb_css_parser_token_m(parser, token) \
do { \
token = lxb_css_syntax_parser_token(parser); \
if (token == NULL) { \
return lxb_css_parser_fail((parser), (parser)->tkz->status); \
} \
} \
while (false)
#define lxb_css_parser_token_next_m(parser, token) \
do { \
token = lxb_css_syntax_token_next((parser)->tkz); \
if (token == NULL) { \
return lxb_css_parser_fail((parser), (parser)->tkz->status); \
} \
} \
while (false)
#define lxb_css_parser_token_wo_ws_m(parser, token) \
do { \
token = lxb_css_syntax_parser_token(parser); \
if (token == NULL) { \
return lxb_css_parser_fail((parser), (parser)->tkz->status); \
} \
\
if (token->type == LXB_CSS_SYNTAX_TOKEN_WHITESPACE) { \
lxb_css_syntax_parser_consume(parser); \
token = lxb_css_syntax_parser_token(parser); \
if (token == NULL) { \
return lxb_css_parser_fail((parser), (parser)->tkz->status); \
} \
} \
} \
while (false)
#define lxb_css_parser_token_status_m(parser, token) \
do { \
if ((token = lxb_css_syntax_parser_token(parser)) == NULL) { \
return parser->tkz->status; \
} \
} \
while (false)
#define lxb_css_parser_token_status_next_m(parser, token) \
do { \
token = lxb_css_syntax_token_next((parser)->tkz); \
if (token == NULL) { \
return parser->tkz->status; \
} \
} \
while (false)
#define lxb_css_parser_token_status_wo_ws_m(parser, token) \
do { \
if ((token = lxb_css_syntax_parser_token(parser)) == NULL) { \
return parser->tkz->status; \
} \
\
if (token->type == LXB_CSS_SYNTAX_TOKEN_WHITESPACE) { \
lxb_css_syntax_parser_consume(parser); \
if ((token = lxb_css_syntax_parser_token(parser)) == NULL) { \
return parser->tkz->status; \
} \
} \
} \
while (false)
#define lxb_css_parser_string_dup_m(parser, token, _str, mraw) \
do { \
if (lxb_css_syntax_token_string_dup(lxb_css_syntax_token_string(token),\
(_str), (mraw)) != LXB_STATUS_OK) \
{ \
return lxb_css_parser_fail((parser), \
LXB_STATUS_ERROR_MEMORY_ALLOCATION); \
} \
} \
while (false)
enum {
LXB_CSS_SYNTAX_PARSER_ERROR_UNDEF = 0x0000,
/* eof-in-at-rule */
LXB_CSS_SYNTAX_PARSER_ERROR_EOINATRU,
/* eof-in-qualified-rule */
LXB_CSS_SYNTAX_PARSER_ERROR_EOINQURU,
/* eof-in-simple-block */
LXB_CSS_SYNTAX_PARSER_ERROR_EOINSIBL,
/* eof-in-function */
LXB_CSS_SYNTAX_PARSER_ERROR_EOINFU,
/* eof-before-parse-rule */
LXB_CSS_SYNTAX_PARSER_ERROR_EOBEPARU,
/* unexpected-token-after-parse-rule */
LXB_CSS_SYNTAX_PARSER_ERROR_UNTOAFPARU,
/* eof-before-parse-component-value */
LXB_CSS_SYNTAX_PARSER_ERROR_EOBEPACOVA,
/* unexpected-token-after-parse-component-value */
LXB_CSS_SYNTAX_PARSER_ERROR_UNTOAFPACOVA,
/* unexpected-token-in-declaration */
LXB_CSS_SYNTAX_PARSER_ERROR_UNTOINDE,
};
typedef enum {
LXB_CSS_PARSER_CLEAN = 0,
LXB_CSS_PARSER_RUN,
LXB_CSS_PARSER_STOP,
LXB_CSS_PARSER_END
}
lxb_css_parser_stage_t;
struct lxb_css_parser {
lxb_css_parser_state_f block;
void *context;
/* Modules */
lxb_css_syntax_tokenizer_t *tkz;
lxb_css_selectors_t *selectors;
lxb_css_selectors_t *old_selectors;
/* Memory for all structures. */
lxb_css_memory_t *memory;
lxb_css_memory_t *old_memory;
/* Syntax parse rules. */
lxb_css_syntax_rule_t *rules_begin;
lxb_css_syntax_rule_t *rules_end;
lxb_css_syntax_rule_t *rules;
/* States */
lxb_css_parser_state_t *states_begin;
lxb_css_parser_state_t *states_end;
lxb_css_parser_state_t *states;
/* Types */
lxb_css_syntax_token_type_t *types_begin;
lxb_css_syntax_token_type_t *types_end;
lxb_css_syntax_token_type_t *types_pos;
lxb_css_syntax_tokenizer_chunk_f chunk_cb;
void *chunk_ctx;
const lxb_char_t *pos;
uintptr_t offset;
lexbor_str_t str;
size_t str_size;
lxb_css_log_t *log;
lxb_css_parser_stage_t stage;
bool loop;
bool fake_null;
bool my_tkz;
bool receive_endings;
lxb_status_t status;
};
struct lxb_css_parser_state {
lxb_css_parser_state_f state;
void *context;
bool root;
};
struct lxb_css_parser_error {
lexbor_str_t message;
};
LXB_API lxb_css_parser_t *
lxb_css_parser_create(void);
LXB_API lxb_status_t
lxb_css_parser_init(lxb_css_parser_t *parser, lxb_css_syntax_tokenizer_t *tkz);
LXB_API void
lxb_css_parser_clean(lxb_css_parser_t *parser);
LXB_API void
lxb_css_parser_erase(lxb_css_parser_t *parser);
LXB_API lxb_css_parser_t *
lxb_css_parser_destroy(lxb_css_parser_t *parser, bool self_destroy);
LXB_API lxb_css_parser_state_t *
lxb_css_parser_states_push(lxb_css_parser_t *parser,
lxb_css_parser_state_f state,
void *context, bool stop);
LXB_API lxb_css_parser_state_t *
lxb_css_parser_states_next(lxb_css_parser_t *parser,
lxb_css_parser_state_f next,
lxb_css_parser_state_f back, void *ctx, bool root);
LXB_API lxb_status_t
lxb_css_parser_types_push(lxb_css_parser_t *parser,
lxb_css_syntax_token_type_t type);
LXB_API bool
lxb_css_parser_stop(lxb_css_parser_t *parser);
LXB_API bool
lxb_css_parser_fail(lxb_css_parser_t *parser, lxb_status_t status);
LXB_API bool
lxb_css_parser_unexpected(lxb_css_parser_t *parser);
LXB_API bool
lxb_css_parser_success(lxb_css_parser_t *parser);
LXB_API bool
lxb_css_parser_failed(lxb_css_parser_t *parser);
LXB_API lxb_status_t
lxb_css_parser_unexpected_status(lxb_css_parser_t *parser);
LXB_API bool
lxb_css_parser_unexpected_data(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token);
LXB_API lxb_status_t
lxb_css_parser_unexpected_data_status(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token);
LXB_API bool
lxb_css_parser_memory_fail(lxb_css_parser_t *parser);
lxb_status_t
lxb_css_parser_memory_fail_status(lxb_css_parser_t *parser);
/*
* Inline functions
*/
lxb_inline lxb_status_t
lxb_css_parser_status(lxb_css_parser_t *parser)
{
return parser->status;
}
lxb_inline lxb_css_memory_t *
lxb_css_parser_memory(lxb_css_parser_t *parser)
{
return parser->memory;
}
lxb_inline void
lxb_css_parser_memory_set(lxb_css_parser_t *parser, lxb_css_memory_t *memory)
{
parser->memory = memory;
}
lxb_inline lxb_css_selectors_t *
lxb_css_parser_selectors(lxb_css_parser_t *parser)
{
return parser->selectors;
}
lxb_inline void
lxb_css_parser_selectors_set(lxb_css_parser_t *parser,
lxb_css_selectors_t *selectors)
{
parser->selectors = selectors;
}
lxb_inline bool
lxb_css_parser_is_running(lxb_css_parser_t *parser)
{
return parser->stage == LXB_CSS_PARSER_RUN;
}
lxb_inline bool
lxb_css_parser_status_is_unexpected_data(lxb_css_parser_t *parser)
{
return parser->status == LXB_STATUS_ERROR_UNEXPECTED_DATA;
}
lxb_inline void
lxb_css_parser_failed_set(lxb_css_parser_t *parser, bool is)
{
parser->rules->failed = is;
}
lxb_inline void
lxb_css_parser_failed_set_by_id(lxb_css_parser_t *parser, int idx, bool is)
{
lxb_css_syntax_rule_t *rules = parser->rules + idx;
if (rules > parser->rules_begin && rules < parser->rules_end) {
rules->failed = is;
}
}
lxb_inline bool
lxb_css_parser_is_failed(lxb_css_parser_t *parser)
{
return parser->rules->failed;
}
lxb_inline void
lxb_css_parser_set_ok(lxb_css_parser_t *parser)
{
parser->rules->failed = false;
parser->status = LXB_STATUS_OK;
}
lxb_inline const lxb_char_t *
lxb_css_parser_buffer(lxb_css_parser_t *parser, size_t *length)
{
if (length != NULL) {
*length = parser->tkz->in_end - parser->tkz->in_begin;
}
return parser->tkz->in_begin;
}
lxb_inline void
lxb_css_parser_buffer_set(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length)
{
lxb_css_syntax_tokenizer_buffer_set(parser->tkz, data, length);
}
lxb_inline lxb_css_parser_state_f
lxb_css_parser_state(lxb_css_parser_t *parser)
{
return parser->rules->state;
}
lxb_inline void
lxb_css_parser_state_set(lxb_css_parser_t *parser, lxb_css_parser_state_f state)
{
parser->rules->state = state;
}
lxb_inline void
lxb_css_parser_state_block_set(lxb_css_parser_t *parser,
lxb_css_parser_state_f state)
{
parser->block = state;
}
lxb_inline void
lxb_css_parser_state_value_set(lxb_css_parser_t *parser,
lxb_css_parser_state_f state)
{
lxb_css_parser_state_block_set(parser, state);
}
lxb_inline void *
lxb_css_parser_context(lxb_css_parser_t *parser)
{
return parser->context;
}
lxb_inline void
lxb_css_parser_context_set(lxb_css_parser_t *parser, void *context)
{
parser->context = context;
}
lxb_inline lxb_css_syntax_rule_t *
lxb_css_parser_current_rule(lxb_css_parser_t *parser)
{
return parser->rules;
}
lxb_inline size_t
lxb_css_parser_rule_deep(lxb_css_parser_t *parser)
{
return parser->rules->deep;
}
lxb_inline lxb_css_parser_state_t *
lxb_css_parser_states_pop(lxb_css_parser_t *parser)
{
return parser->states--;
}
lxb_inline lxb_css_parser_state_t *
lxb_css_parser_states_to_root(lxb_css_parser_t *parser)
{
lxb_css_parser_state_t *entry = parser->states;
while (!entry->root) {
entry--;
}
parser->states = entry;
return entry;
}
lxb_inline bool
lxb_css_parser_states_set_back(lxb_css_parser_t *parser)
{
const lxb_css_parser_state_t *entry = parser->states;
lxb_css_syntax_rule_t *rules = parser->rules;
rules->state = entry->state;
rules->context = entry->context;
return true;
}
lxb_inline void
lxb_css_parser_states_change_back(lxb_css_parser_t *parser,
lxb_css_parser_state_f state)
{
parser->rules->state_back = state;
}
lxb_inline void
lxb_css_parser_states_clean(lxb_css_parser_t *parser)
{
parser->states = parser->states_begin;
}
lxb_inline lxb_css_parser_state_t *
lxb_css_parser_states_current(lxb_css_parser_t *parser)
{
return parser->states;
}
lxb_inline void
lxb_css_parser_states_set(lxb_css_parser_state_t *states,
lxb_css_parser_state_f state, void *context)
{
states->state = state;
states->context = context;
}
lxb_inline void
lxb_css_parser_states_up(lxb_css_parser_t *parser)
{
parser->states++;
}
lxb_inline void
lxb_css_parser_states_down(lxb_css_parser_t *parser)
{
parser->states--;
}
lxb_inline lxb_css_log_t *
lxb_css_parser_log(lxb_css_parser_t *parser)
{
return parser->log;
}
lxb_inline void
lxb_css_parser_offset_set(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token)
{
if (parser->pos == NULL) {
if (token == NULL) {
parser->pos = parser->tkz->in_begin;
parser->offset = 0;
}
else {
parser->pos = lxb_css_syntax_token_base(token)->begin
+ lxb_css_syntax_token_base(token)->length;
parser->offset = token->offset + lxb_css_syntax_token_base(token)->length;
}
}
}
lxb_inline const lxb_css_syntax_list_rules_offset_t *
lxb_css_parser_list_rules_offset(lxb_css_parser_t *parser)
{
return &parser->rules->u.list_rules;
}
lxb_inline const lxb_css_syntax_at_rule_offset_t *
lxb_css_parser_at_rule_offset(lxb_css_parser_t *parser)
{
return &parser->rules->u.at_rule;
}
lxb_inline const lxb_css_syntax_qualified_offset_t *
lxb_css_parser_qualified_rule_offset(lxb_css_parser_t *parser)
{
return &parser->rules->u.qualified;
}
lxb_inline const lxb_css_syntax_declarations_offset_t *
lxb_css_parser_declarations_offset(lxb_css_parser_t *parser)
{
return &parser->rules->u.declarations;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_PARSER_H */

1754
ext/dom/lexbor/lexbor/css/property.h Normal file
View file

File diff suppressed because it is too large Load diff

1180
ext/dom/lexbor/lexbor/css/property/const.h Normal file
View file

File diff suppressed because it is too large Load diff

524
ext/dom/lexbor/lexbor/css/property/res.h Normal file
View file

@ -0,0 +1,524 @@
/*
* Copyright (C) 2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/names.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_PROPERTY_RES_H
#define LXB_CSS_PROPERTY_RES_H
#include "lexbor/core/shs.h"
#include "lexbor/css/property/const.h"
static const lxb_css_entry_data_t lxb_css_property_data[LXB_CSS_PROPERTY__LAST_ENTRY] =
{
{(lxb_char_t *) "#undef", 6, LXB_CSS_PROPERTY__UNDEF, lxb_css_property_state__undef,
lxb_css_property__undef_create, lxb_css_property__undef_destroy, lxb_css_property__undef_serialize, (void *) (uintptr_t) LXB_CSS_PROPERTY__UNDEF},
{(lxb_char_t *) "#сustom", 7, LXB_CSS_PROPERTY__CUSTOM, lxb_css_property_state__custom,
lxb_css_property__custom_create, lxb_css_property__custom_destroy, lxb_css_property__custom_serialize, (void *) (uintptr_t) LXB_CSS_PROPERTY__CUSTOM},
{(lxb_char_t *) "align-content", 13, LXB_CSS_PROPERTY_ALIGN_CONTENT, lxb_css_property_state_align_content,
lxb_css_property_align_content_create, lxb_css_property_align_content_destroy, lxb_css_property_align_content_serialize,
&(lxb_css_property_align_content_t) {.type = LXB_CSS_ALIGN_CONTENT_STRETCH}},
{(lxb_char_t *) "align-items", 11, LXB_CSS_PROPERTY_ALIGN_ITEMS, lxb_css_property_state_align_items,
lxb_css_property_align_items_create, lxb_css_property_align_items_destroy, lxb_css_property_align_items_serialize,
&(lxb_css_property_align_items_t) {.type = LXB_CSS_ALIGN_ITEMS_STRETCH}},
{(lxb_char_t *) "align-self", 10, LXB_CSS_PROPERTY_ALIGN_SELF, lxb_css_property_state_align_self,
lxb_css_property_align_self_create, lxb_css_property_align_self_destroy, lxb_css_property_align_self_serialize,
&(lxb_css_property_align_self_t) {.type = LXB_CSS_ALIGN_SELF_AUTO}},
{(lxb_char_t *) "alignment-baseline", 18, LXB_CSS_PROPERTY_ALIGNMENT_BASELINE, lxb_css_property_state_alignment_baseline,
lxb_css_property_alignment_baseline_create, lxb_css_property_alignment_baseline_destroy, lxb_css_property_alignment_baseline_serialize,
&(lxb_css_property_alignment_baseline_t) {.type = LXB_CSS_ALIGNMENT_BASELINE_BASELINE}},
{(lxb_char_t *) "background-color", 16, LXB_CSS_PROPERTY_BACKGROUND_COLOR, lxb_css_property_state_background_color,
lxb_css_property_background_color_create, lxb_css_property_background_color_destroy, lxb_css_property_background_color_serialize,
&(lxb_css_property_background_color_t) {.type = LXB_CSS_COLOR_TRANSPARENT}},
{(lxb_char_t *) "baseline-shift", 14, LXB_CSS_PROPERTY_BASELINE_SHIFT, lxb_css_property_state_baseline_shift,
lxb_css_property_baseline_shift_create, lxb_css_property_baseline_shift_destroy, lxb_css_property_baseline_shift_serialize,
&(lxb_css_property_baseline_shift_t) {.type = LXB_CSS_VALUE__NUMBER, .u = {.length = {.num = 0, .is_float = false, .unit = LXB_CSS_UNIT__UNDEF}}}},
{(lxb_char_t *) "baseline-source", 15, LXB_CSS_PROPERTY_BASELINE_SOURCE, lxb_css_property_state_baseline_source,
lxb_css_property_baseline_source_create, lxb_css_property_baseline_source_destroy, lxb_css_property_baseline_source_serialize,
&(lxb_css_property_baseline_source_t) {.type = LXB_CSS_BASELINE_SOURCE_AUTO}},
{(lxb_char_t *) "border", 6, LXB_CSS_PROPERTY_BORDER, lxb_css_property_state_border,
lxb_css_property_border_create, lxb_css_property_border_destroy, lxb_css_property_border_serialize,
&(lxb_css_property_border_t) {.style = LXB_CSS_BORDER_NONE, .width = {.type = LXB_CSS_BORDER_MEDIUM}, .color = {.type = LXB_CSS_COLOR_CURRENTCOLOR}}},
{(lxb_char_t *) "border-bottom", 13, LXB_CSS_PROPERTY_BORDER_BOTTOM, lxb_css_property_state_border_bottom,
lxb_css_property_border_bottom_create, lxb_css_property_border_bottom_destroy, lxb_css_property_border_bottom_serialize,
&(lxb_css_property_border_bottom_t) {.style = LXB_CSS_BORDER_NONE, .width = {.type = LXB_CSS_BORDER_MEDIUM}, .color = {.type = LXB_CSS_COLOR_CURRENTCOLOR}}},
{(lxb_char_t *) "border-bottom-color", 19, LXB_CSS_PROPERTY_BORDER_BOTTOM_COLOR, lxb_css_property_state_border_bottom_color,
lxb_css_property_border_bottom_color_create, lxb_css_property_border_bottom_color_destroy, lxb_css_property_border_bottom_color_serialize,
&(lxb_css_property_border_bottom_color_t) {.type = LXB_CSS_COLOR_CURRENTCOLOR}},
{(lxb_char_t *) "border-left", 11, LXB_CSS_PROPERTY_BORDER_LEFT, lxb_css_property_state_border_left,
lxb_css_property_border_left_create, lxb_css_property_border_left_destroy, lxb_css_property_border_left_serialize,
&(lxb_css_property_border_left_t) {.style = LXB_CSS_BORDER_NONE, .width = {.type = LXB_CSS_BORDER_MEDIUM}, .color = {.type = LXB_CSS_COLOR_CURRENTCOLOR}}},
{(lxb_char_t *) "border-left-color", 17, LXB_CSS_PROPERTY_BORDER_LEFT_COLOR, lxb_css_property_state_border_left_color,
lxb_css_property_border_left_color_create, lxb_css_property_border_left_color_destroy, lxb_css_property_border_left_color_serialize,
&(lxb_css_property_border_left_color_t) {.type = LXB_CSS_COLOR_CURRENTCOLOR}},
{(lxb_char_t *) "border-right", 12, LXB_CSS_PROPERTY_BORDER_RIGHT, lxb_css_property_state_border_right,
lxb_css_property_border_right_create, lxb_css_property_border_right_destroy, lxb_css_property_border_right_serialize,
&(lxb_css_property_border_right_t) {.style = LXB_CSS_BORDER_NONE, .width = {.type = LXB_CSS_BORDER_MEDIUM}, .color = {.type = LXB_CSS_COLOR_CURRENTCOLOR}}},
{(lxb_char_t *) "border-right-color", 18, LXB_CSS_PROPERTY_BORDER_RIGHT_COLOR, lxb_css_property_state_border_right_color,
lxb_css_property_border_right_color_create, lxb_css_property_border_right_color_destroy, lxb_css_property_border_right_color_serialize,
&(lxb_css_property_border_right_color_t) {.type = LXB_CSS_COLOR_CURRENTCOLOR}},
{(lxb_char_t *) "border-top", 10, LXB_CSS_PROPERTY_BORDER_TOP, lxb_css_property_state_border_top,
lxb_css_property_border_top_create, lxb_css_property_border_top_destroy, lxb_css_property_border_top_serialize,
&(lxb_css_property_border_top_t) {.style = LXB_CSS_BORDER_NONE, .width = {.type = LXB_CSS_BORDER_MEDIUM}, .color = {.type = LXB_CSS_COLOR_CURRENTCOLOR}}},
{(lxb_char_t *) "border-top-color", 16, LXB_CSS_PROPERTY_BORDER_TOP_COLOR, lxb_css_property_state_border_top_color,
lxb_css_property_border_top_color_create, lxb_css_property_border_top_color_destroy, lxb_css_property_border_top_color_serialize,
&(lxb_css_property_border_top_color_t) {.type = LXB_CSS_COLOR_CURRENTCOLOR}},
{(lxb_char_t *) "bottom", 6, LXB_CSS_PROPERTY_BOTTOM, lxb_css_property_state_bottom,
lxb_css_property_bottom_create, lxb_css_property_bottom_destroy, lxb_css_property_bottom_serialize,
&(lxb_css_property_bottom_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "box-sizing", 10, LXB_CSS_PROPERTY_BOX_SIZING, lxb_css_property_state_box_sizing,
lxb_css_property_box_sizing_create, lxb_css_property_box_sizing_destroy, lxb_css_property_box_sizing_serialize,
&(lxb_css_property_box_sizing_t) {.type = LXB_CSS_BOX_SIZING_CONTENT_BOX}},
{(lxb_char_t *) "clear", 5, LXB_CSS_PROPERTY_CLEAR, lxb_css_property_state_clear,
lxb_css_property_clear_create, lxb_css_property_clear_destroy, lxb_css_property_clear_serialize,
&(lxb_css_property_clear_t) {.type = LXB_CSS_CLEAR_NONE}},
{(lxb_char_t *) "color", 5, LXB_CSS_PROPERTY_COLOR, lxb_css_property_state_color,
lxb_css_property_color_create, lxb_css_property_color_destroy, lxb_css_property_color_serialize,
&(lxb_css_value_color_t) {.type = LXB_CSS_COLOR_CURRENTCOLOR}},
{(lxb_char_t *) "direction", 9, LXB_CSS_PROPERTY_DIRECTION, lxb_css_property_state_direction,
lxb_css_property_direction_create, lxb_css_property_direction_destroy, lxb_css_property_direction_serialize,
&(lxb_css_property_direction_t) {.type = LXB_CSS_DIRECTION_LTR}},
{(lxb_char_t *) "display", 7, LXB_CSS_PROPERTY_DISPLAY, lxb_css_property_state_display,
lxb_css_property_display_create, lxb_css_property_display_destroy, lxb_css_property_display_serialize,
&(lxb_css_property_display_t) {.a = LXB_CSS_DISPLAY_INLINE, .b = LXB_CSS_PROPERTY__UNDEF, .c = LXB_CSS_PROPERTY__UNDEF}},
{(lxb_char_t *) "dominant-baseline", 17, LXB_CSS_PROPERTY_DOMINANT_BASELINE, lxb_css_property_state_dominant_baseline,
lxb_css_property_dominant_baseline_create, lxb_css_property_dominant_baseline_destroy, lxb_css_property_dominant_baseline_serialize,
&(lxb_css_property_dominant_baseline_t) {.type = LXB_CSS_DOMINANT_BASELINE_AUTO}},
{(lxb_char_t *) "flex", 4, LXB_CSS_PROPERTY_FLEX, lxb_css_property_state_flex,
lxb_css_property_flex_create, lxb_css_property_flex_destroy, lxb_css_property_flex_serialize,
&(lxb_css_property_flex_t) {.type = LXB_CSS_VALUE__UNDEF, .grow = {.type = LXB_CSS_FLEX_GROW__NUMBER, .number = {.num = 0, .is_float = false}}, .shrink = {.type = LXB_CSS_FLEX_SHRINK__NUMBER, .number = {.num = 1, .is_float = false}}, .basis = {.type = LXB_CSS_WIDTH_AUTO, .u.length = {.num = 0, .is_float = false}}}},
{(lxb_char_t *) "flex-basis", 10, LXB_CSS_PROPERTY_FLEX_BASIS, lxb_css_property_state_flex_basis,
lxb_css_property_flex_basis_create, lxb_css_property_flex_basis_destroy, lxb_css_property_flex_basis_serialize,
&(lxb_css_property_flex_basis_t) {.type = LXB_CSS_WIDTH_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "flex-direction", 14, LXB_CSS_PROPERTY_FLEX_DIRECTION, lxb_css_property_state_flex_direction,
lxb_css_property_flex_direction_create, lxb_css_property_flex_direction_destroy, lxb_css_property_flex_direction_serialize,
&(lxb_css_property_flex_direction_t) {.type = LXB_CSS_FLEX_DIRECTION_ROW}},
{(lxb_char_t *) "flex-flow", 9, LXB_CSS_PROPERTY_FLEX_FLOW, lxb_css_property_state_flex_flow,
lxb_css_property_flex_flow_create, lxb_css_property_flex_flow_destroy, lxb_css_property_flex_flow_serialize,
&(lxb_css_property_flex_flow_t) {.type_direction = LXB_CSS_FLEX_DIRECTION_ROW, .wrap = LXB_CSS_FLEX_WRAP_NOWRAP}},
{(lxb_char_t *) "flex-grow", 9, LXB_CSS_PROPERTY_FLEX_GROW, lxb_css_property_state_flex_grow,
lxb_css_property_flex_grow_create, lxb_css_property_flex_grow_destroy, lxb_css_property_flex_grow_serialize,
&(lxb_css_property_flex_grow_t) {.type = LXB_CSS_FLEX_GROW__NUMBER, .number = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "flex-shrink", 11, LXB_CSS_PROPERTY_FLEX_SHRINK, lxb_css_property_state_flex_shrink,
lxb_css_property_flex_shrink_create, lxb_css_property_flex_shrink_destroy, lxb_css_property_flex_shrink_serialize,
&(lxb_css_property_flex_shrink_t) {.type = LXB_CSS_FLEX_SHRINK__NUMBER, .number = {.num = 1, .is_float = false}}},
{(lxb_char_t *) "flex-wrap", 9, LXB_CSS_PROPERTY_FLEX_WRAP, lxb_css_property_state_flex_wrap,
lxb_css_property_flex_wrap_create, lxb_css_property_flex_wrap_destroy, lxb_css_property_flex_wrap_serialize,
&(lxb_css_property_flex_wrap_t) {.type = LXB_CSS_FLEX_WRAP_NOWRAP}},
{(lxb_char_t *) "float", 5, LXB_CSS_PROPERTY_FLOAT, lxb_css_property_state_float,
lxb_css_property_float_create, lxb_css_property_float_destroy, lxb_css_property_float_serialize,
&(lxb_css_property_float_t) {.type = LXB_CSS_FLOAT_NONE}},
{(lxb_char_t *) "float-defer", 11, LXB_CSS_PROPERTY_FLOAT_DEFER, lxb_css_property_state_float_defer,
lxb_css_property_float_defer_create, lxb_css_property_float_defer_destroy, lxb_css_property_float_defer_serialize,
&(lxb_css_property_float_defer_t) {.type = LXB_CSS_FLOAT_DEFER_NONE}},
{(lxb_char_t *) "float-offset", 12, LXB_CSS_PROPERTY_FLOAT_OFFSET, lxb_css_property_state_float_offset,
lxb_css_property_float_offset_create, lxb_css_property_float_offset_destroy, lxb_css_property_float_offset_serialize,
&(lxb_css_property_float_offset_t) {.type = LXB_CSS_VALUE__NUMBER, .u = {.length = {.num = 0, .is_float = false, .unit = LXB_CSS_UNIT__UNDEF}}}},
{(lxb_char_t *) "float-reference", 15, LXB_CSS_PROPERTY_FLOAT_REFERENCE, lxb_css_property_state_float_reference,
lxb_css_property_float_reference_create, lxb_css_property_float_reference_destroy, lxb_css_property_float_reference_serialize,
&(lxb_css_property_float_reference_t) {.type = LXB_CSS_FLOAT_REFERENCE_INLINE}},
{(lxb_char_t *) "font-family", 11, LXB_CSS_PROPERTY_FONT_FAMILY, lxb_css_property_state_font_family,
lxb_css_property_font_family_create, lxb_css_property_font_family_destroy, lxb_css_property_font_family_serialize,
NULL},
{(lxb_char_t *) "font-size", 9, LXB_CSS_PROPERTY_FONT_SIZE, lxb_css_property_state_font_size,
lxb_css_property_font_size_create, lxb_css_property_font_size_destroy, lxb_css_property_font_size_serialize,
&(lxb_css_property_font_size_t) {.type = LXB_CSS_FONT_SIZE_MEDIUM}},
{(lxb_char_t *) "font-stretch", 12, LXB_CSS_PROPERTY_FONT_STRETCH, lxb_css_property_state_font_stretch,
lxb_css_property_font_stretch_create, lxb_css_property_font_stretch_destroy, lxb_css_property_font_stretch_serialize,
&(lxb_css_property_font_stretch_t) {.type = LXB_CSS_FONT_STRETCH_NORMAL}},
{(lxb_char_t *) "font-style", 10, LXB_CSS_PROPERTY_FONT_STYLE, lxb_css_property_state_font_style,
lxb_css_property_font_style_create, lxb_css_property_font_style_destroy, lxb_css_property_font_style_serialize,
&(lxb_css_property_font_style_t) {.type = LXB_CSS_FONT_STYLE_NORMAL}},
{(lxb_char_t *) "font-weight", 11, LXB_CSS_PROPERTY_FONT_WEIGHT, lxb_css_property_state_font_weight,
lxb_css_property_font_weight_create, lxb_css_property_font_weight_destroy, lxb_css_property_font_weight_serialize,
&(lxb_css_property_font_weight_t) {.type = LXB_CSS_FONT_WEIGHT_NORMAL}},
{(lxb_char_t *) "hanging-punctuation", 19, LXB_CSS_PROPERTY_HANGING_PUNCTUATION, lxb_css_property_state_hanging_punctuation,
lxb_css_property_hanging_punctuation_create, lxb_css_property_hanging_punctuation_destroy, lxb_css_property_hanging_punctuation_serialize,
&(lxb_css_property_hanging_punctuation_t) {.type_first = LXB_CSS_HANGING_PUNCTUATION_NONE}},
{(lxb_char_t *) "height", 6, LXB_CSS_PROPERTY_HEIGHT, lxb_css_property_state_height,
lxb_css_property_height_create, lxb_css_property_height_destroy, lxb_css_property_height_serialize,
&(lxb_css_property_height_t) {.type = LXB_CSS_HEIGHT_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "hyphens", 7, LXB_CSS_PROPERTY_HYPHENS, lxb_css_property_state_hyphens,
lxb_css_property_hyphens_create, lxb_css_property_hyphens_destroy, lxb_css_property_hyphens_serialize,
&(lxb_css_property_hyphens_t) {.type = LXB_CSS_HYPHENS_MANUAL}},
{(lxb_char_t *) "inset-block-end", 15, LXB_CSS_PROPERTY_INSET_BLOCK_END, lxb_css_property_state_inset_block_end,
lxb_css_property_inset_block_end_create, lxb_css_property_inset_block_end_destroy, lxb_css_property_inset_block_end_serialize,
&(lxb_css_property_inset_block_end_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "inset-block-start", 17, LXB_CSS_PROPERTY_INSET_BLOCK_START, lxb_css_property_state_inset_block_start,
lxb_css_property_inset_block_start_create, lxb_css_property_inset_block_start_destroy, lxb_css_property_inset_block_start_serialize,
&(lxb_css_property_inset_block_start_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "inset-inline-end", 16, LXB_CSS_PROPERTY_INSET_INLINE_END, lxb_css_property_state_inset_inline_end,
lxb_css_property_inset_inline_end_create, lxb_css_property_inset_inline_end_destroy, lxb_css_property_inset_inline_end_serialize,
&(lxb_css_property_inset_inline_end_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "inset-inline-start", 18, LXB_CSS_PROPERTY_INSET_INLINE_START, lxb_css_property_state_inset_inline_start,
lxb_css_property_inset_inline_start_create, lxb_css_property_inset_inline_start_destroy, lxb_css_property_inset_inline_start_serialize,
&(lxb_css_property_inset_inline_start_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "justify-content", 15, LXB_CSS_PROPERTY_JUSTIFY_CONTENT, lxb_css_property_state_justify_content,
lxb_css_property_justify_content_create, lxb_css_property_justify_content_destroy, lxb_css_property_justify_content_serialize,
&(lxb_css_property_justify_content_t) {.type = LXB_CSS_JUSTIFY_CONTENT_FLEX_START}},
{(lxb_char_t *) "left", 4, LXB_CSS_PROPERTY_LEFT, lxb_css_property_state_left,
lxb_css_property_left_create, lxb_css_property_left_destroy, lxb_css_property_left_serialize,
&(lxb_css_property_left_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "letter-spacing", 14, LXB_CSS_PROPERTY_LETTER_SPACING, lxb_css_property_state_letter_spacing,
lxb_css_property_letter_spacing_create, lxb_css_property_letter_spacing_destroy, lxb_css_property_letter_spacing_serialize,
&(lxb_css_property_letter_spacing_t) {.type = LXB_CSS_LETTER_SPACING_NORMAL}},
{(lxb_char_t *) "line-break", 10, LXB_CSS_PROPERTY_LINE_BREAK, lxb_css_property_state_line_break,
lxb_css_property_line_break_create, lxb_css_property_line_break_destroy, lxb_css_property_line_break_serialize,
&(lxb_css_property_line_break_t) {.type = LXB_CSS_LINE_BREAK_AUTO}},
{(lxb_char_t *) "line-height", 11, LXB_CSS_PROPERTY_LINE_HEIGHT, lxb_css_property_state_line_height,
lxb_css_property_line_height_create, lxb_css_property_line_height_destroy, lxb_css_property_line_height_serialize,
&(lxb_css_property_line_height_t) {.type = LXB_CSS_LINE_HEIGHT_NORMAL}},
{(lxb_char_t *) "margin", 6, LXB_CSS_PROPERTY_MARGIN, lxb_css_property_state_margin,
lxb_css_property_margin_create, lxb_css_property_margin_destroy, lxb_css_property_margin_serialize,
&(lxb_css_property_margin_t) {.top = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}, .right = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}, .bottom = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}, .left = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}}},
{(lxb_char_t *) "margin-bottom", 13, LXB_CSS_PROPERTY_MARGIN_BOTTOM, lxb_css_property_state_margin_bottom,
lxb_css_property_margin_bottom_create, lxb_css_property_margin_bottom_destroy, lxb_css_property_margin_bottom_serialize,
&(lxb_css_property_margin_bottom_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "margin-left", 11, LXB_CSS_PROPERTY_MARGIN_LEFT, lxb_css_property_state_margin_left,
lxb_css_property_margin_left_create, lxb_css_property_margin_left_destroy, lxb_css_property_margin_left_serialize,
&(lxb_css_property_margin_left_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "margin-right", 12, LXB_CSS_PROPERTY_MARGIN_RIGHT, lxb_css_property_state_margin_right,
lxb_css_property_margin_right_create, lxb_css_property_margin_right_destroy, lxb_css_property_margin_right_serialize,
&(lxb_css_property_margin_right_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "margin-top", 10, LXB_CSS_PROPERTY_MARGIN_TOP, lxb_css_property_state_margin_top,
lxb_css_property_margin_top_create, lxb_css_property_margin_top_destroy, lxb_css_property_margin_top_serialize,
&(lxb_css_property_margin_top_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "max-height", 10, LXB_CSS_PROPERTY_MAX_HEIGHT, lxb_css_property_state_max_height,
lxb_css_property_max_height_create, lxb_css_property_max_height_destroy, lxb_css_property_max_height_serialize,
&(lxb_css_property_max_height_t) {.type = LXB_CSS_MAX_HEIGHT_NONE, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "max-width", 9, LXB_CSS_PROPERTY_MAX_WIDTH, lxb_css_property_state_max_width,
lxb_css_property_max_width_create, lxb_css_property_max_width_destroy, lxb_css_property_max_width_serialize,
&(lxb_css_property_max_width_t) {.type = LXB_CSS_MAX_WIDTH_NONE, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "min-height", 10, LXB_CSS_PROPERTY_MIN_HEIGHT, lxb_css_property_state_min_height,
lxb_css_property_min_height_create, lxb_css_property_min_height_destroy, lxb_css_property_min_height_serialize,
&(lxb_css_property_min_height_t) {.type = LXB_CSS_MIN_HEIGHT_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "min-width", 9, LXB_CSS_PROPERTY_MIN_WIDTH, lxb_css_property_state_min_width,
lxb_css_property_min_width_create, lxb_css_property_min_width_destroy, lxb_css_property_min_width_serialize,
&(lxb_css_property_min_width_t) {.type = LXB_CSS_MIN_WIDTH_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "opacity", 7, LXB_CSS_PROPERTY_OPACITY, lxb_css_property_state_opacity,
lxb_css_property_opacity_create, lxb_css_property_opacity_destroy, lxb_css_property_opacity_serialize,
&(lxb_css_property_opacity_t) {.type = LXB_CSS_OPACITY__NUMBER, .u = {.number = {.num = 1, .is_float = false}}}},
{(lxb_char_t *) "order", 5, LXB_CSS_PROPERTY_ORDER, lxb_css_property_state_order,
lxb_css_property_order_create, lxb_css_property_order_destroy, lxb_css_property_order_serialize,
&(lxb_css_property_order_t) {.type = LXB_CSS_ORDER__INTEGER, .integer = {.num = 0}}},
{(lxb_char_t *) "overflow-block", 14, LXB_CSS_PROPERTY_OVERFLOW_BLOCK, lxb_css_property_state_overflow_block,
lxb_css_property_overflow_block_create, lxb_css_property_overflow_block_destroy, lxb_css_property_overflow_block_serialize,
&(lxb_css_property_overflow_block_t) {.type = LXB_CSS_OVERFLOW_BLOCK_VISIBLE}},
{(lxb_char_t *) "overflow-inline", 15, LXB_CSS_PROPERTY_OVERFLOW_INLINE, lxb_css_property_state_overflow_inline,
lxb_css_property_overflow_inline_create, lxb_css_property_overflow_inline_destroy, lxb_css_property_overflow_inline_serialize,
&(lxb_css_property_overflow_inline_t) {.type = LXB_CSS_OVERFLOW_INLINE_VISIBLE}},
{(lxb_char_t *) "overflow-wrap", 13, LXB_CSS_PROPERTY_OVERFLOW_WRAP, lxb_css_property_state_overflow_wrap,
lxb_css_property_overflow_wrap_create, lxb_css_property_overflow_wrap_destroy, lxb_css_property_overflow_wrap_serialize,
&(lxb_css_property_overflow_wrap_t) {.type = LXB_CSS_OVERFLOW_WRAP_NORMAL}},
{(lxb_char_t *) "overflow-x", 10, LXB_CSS_PROPERTY_OVERFLOW_X, lxb_css_property_state_overflow_x,
lxb_css_property_overflow_x_create, lxb_css_property_overflow_x_destroy, lxb_css_property_overflow_x_serialize,
&(lxb_css_property_overflow_x_t) {.type = LXB_CSS_OVERFLOW_X_VISIBLE}},
{(lxb_char_t *) "overflow-y", 10, LXB_CSS_PROPERTY_OVERFLOW_Y, lxb_css_property_state_overflow_y,
lxb_css_property_overflow_y_create, lxb_css_property_overflow_y_destroy, lxb_css_property_overflow_y_serialize,
&(lxb_css_property_overflow_y_t) {.type = LXB_CSS_OVERFLOW_Y_VISIBLE}},
{(lxb_char_t *) "padding", 7, LXB_CSS_PROPERTY_PADDING, lxb_css_property_state_padding,
lxb_css_property_padding_create, lxb_css_property_padding_destroy, lxb_css_property_padding_serialize,
&(lxb_css_property_padding_t) {.top = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}, .right = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}, .bottom = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}, .left = {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}}},
{(lxb_char_t *) "padding-bottom", 14, LXB_CSS_PROPERTY_PADDING_BOTTOM, lxb_css_property_state_padding_bottom,
lxb_css_property_padding_bottom_create, lxb_css_property_padding_bottom_destroy, lxb_css_property_padding_bottom_serialize,
&(lxb_css_property_padding_bottom_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "padding-left", 12, LXB_CSS_PROPERTY_PADDING_LEFT, lxb_css_property_state_padding_left,
lxb_css_property_padding_left_create, lxb_css_property_padding_left_destroy, lxb_css_property_padding_left_serialize,
&(lxb_css_property_padding_left_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "padding-right", 13, LXB_CSS_PROPERTY_PADDING_RIGHT, lxb_css_property_state_padding_right,
lxb_css_property_padding_right_create, lxb_css_property_padding_right_destroy, lxb_css_property_padding_right_serialize,
&(lxb_css_property_padding_right_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "padding-top", 11, LXB_CSS_PROPERTY_PADDING_TOP, lxb_css_property_state_padding_top,
lxb_css_property_padding_top_create, lxb_css_property_padding_top_destroy, lxb_css_property_padding_top_serialize,
&(lxb_css_property_padding_top_t) {.type = LXB_CSS_VALUE__LENGTH, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "position", 8, LXB_CSS_PROPERTY_POSITION, lxb_css_property_state_position,
lxb_css_property_position_create, lxb_css_property_position_destroy, lxb_css_property_position_serialize,
&(lxb_css_property_position_t) {.type = LXB_CSS_POSITION_STATIC}},
{(lxb_char_t *) "right", 5, LXB_CSS_PROPERTY_RIGHT, lxb_css_property_state_right,
lxb_css_property_right_create, lxb_css_property_right_destroy, lxb_css_property_right_serialize,
&(lxb_css_property_right_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "tab-size", 8, LXB_CSS_PROPERTY_TAB_SIZE, lxb_css_property_state_tab_size,
lxb_css_property_tab_size_create, lxb_css_property_tab_size_destroy, lxb_css_property_tab_size_serialize,
&(lxb_css_property_tab_size_t) {.type = LXB_CSS_VALUE__NUMBER, .u = {.number = {.num = 8, .is_float = false}}}},
{(lxb_char_t *) "text-align", 10, LXB_CSS_PROPERTY_TEXT_ALIGN, lxb_css_property_state_text_align,
lxb_css_property_text_align_create, lxb_css_property_text_align_destroy, lxb_css_property_text_align_serialize,
&(lxb_css_property_text_align_t) {.type = LXB_CSS_TEXT_ALIGN_START}},
{(lxb_char_t *) "text-align-all", 14, LXB_CSS_PROPERTY_TEXT_ALIGN_ALL, lxb_css_property_state_text_align_all,
lxb_css_property_text_align_all_create, lxb_css_property_text_align_all_destroy, lxb_css_property_text_align_all_serialize,
&(lxb_css_property_text_align_all_t) {.type = LXB_CSS_TEXT_ALIGN_ALL_START}},
{(lxb_char_t *) "text-align-last", 15, LXB_CSS_PROPERTY_TEXT_ALIGN_LAST, lxb_css_property_state_text_align_last,
lxb_css_property_text_align_last_create, lxb_css_property_text_align_last_destroy, lxb_css_property_text_align_last_serialize,
&(lxb_css_property_text_align_last_t) {.type = LXB_CSS_TEXT_ALIGN_LAST_AUTO}},
{(lxb_char_t *) "text-combine-upright", 20, LXB_CSS_PROPERTY_TEXT_COMBINE_UPRIGHT, lxb_css_property_state_text_combine_upright,
lxb_css_property_text_combine_upright_create, lxb_css_property_text_combine_upright_destroy, lxb_css_property_text_combine_upright_serialize,
&(lxb_css_property_text_combine_upright_t) {.type = LXB_CSS_TEXT_COMBINE_UPRIGHT_NONE}},
{(lxb_char_t *) "text-decoration", 15, LXB_CSS_PROPERTY_TEXT_DECORATION, lxb_css_property_state_text_decoration,
lxb_css_property_text_decoration_create, lxb_css_property_text_decoration_destroy, lxb_css_property_text_decoration_serialize,
&(lxb_css_property_text_decoration_t) {.line = {.type = LXB_CSS_TEXT_DECORATION_LINE_NONE}, .style = {.type = LXB_CSS_TEXT_DECORATION_STYLE_SOLID}, .color = {.type = LXB_CSS_COLOR_CURRENTCOLOR}}},
{(lxb_char_t *) "text-decoration-color", 21, LXB_CSS_PROPERTY_TEXT_DECORATION_COLOR, lxb_css_property_state_text_decoration_color,
lxb_css_property_text_decoration_color_create, lxb_css_property_text_decoration_color_destroy, lxb_css_property_text_decoration_color_serialize,
&(lxb_css_property_text_decoration_color_t) {.type = LXB_CSS_COLOR_CURRENTCOLOR}},
{(lxb_char_t *) "text-decoration-line", 20, LXB_CSS_PROPERTY_TEXT_DECORATION_LINE, lxb_css_property_state_text_decoration_line,
lxb_css_property_text_decoration_line_create, lxb_css_property_text_decoration_line_destroy, lxb_css_property_text_decoration_line_serialize,
&(lxb_css_property_text_decoration_line_t) {.type = LXB_CSS_TEXT_DECORATION_LINE_NONE}},
{(lxb_char_t *) "text-decoration-style", 21, LXB_CSS_PROPERTY_TEXT_DECORATION_STYLE, lxb_css_property_state_text_decoration_style,
lxb_css_property_text_decoration_style_create, lxb_css_property_text_decoration_style_destroy, lxb_css_property_text_decoration_style_serialize,
&(lxb_css_property_text_decoration_style_t) {.type = LXB_CSS_TEXT_DECORATION_STYLE_SOLID}},
{(lxb_char_t *) "text-indent", 11, LXB_CSS_PROPERTY_TEXT_INDENT, lxb_css_property_state_text_indent,
lxb_css_property_text_indent_create, lxb_css_property_text_indent_destroy, lxb_css_property_text_indent_serialize,
&(lxb_css_property_text_indent_t) {.length = {.type = LXB_CSS_VALUE__LENGTH, .u = {.length = {.num = 0, .is_float = false, .unit = LXB_CSS_UNIT__UNDEF}}}}},
{(lxb_char_t *) "text-justify", 12, LXB_CSS_PROPERTY_TEXT_JUSTIFY, lxb_css_property_state_text_justify,
lxb_css_property_text_justify_create, lxb_css_property_text_justify_destroy, lxb_css_property_text_justify_serialize,
&(lxb_css_property_text_justify_t) {.type = LXB_CSS_TEXT_JUSTIFY_AUTO}},
{(lxb_char_t *) "text-orientation", 16, LXB_CSS_PROPERTY_TEXT_ORIENTATION, lxb_css_property_state_text_orientation,
lxb_css_property_text_orientation_create, lxb_css_property_text_orientation_destroy, lxb_css_property_text_orientation_serialize,
&(lxb_css_property_text_orientation_t) {.type = LXB_CSS_TEXT_ORIENTATION_MIXED}},
{(lxb_char_t *) "text-overflow", 13, LXB_CSS_PROPERTY_TEXT_OVERFLOW, lxb_css_property_state_text_overflow,
lxb_css_property_text_overflow_create, lxb_css_property_text_overflow_destroy, lxb_css_property_text_overflow_serialize,
&(lxb_css_property_text_overflow_t) {.type = LXB_CSS_TEXT_OVERFLOW_CLIP}},
{(lxb_char_t *) "text-transform", 14, LXB_CSS_PROPERTY_TEXT_TRANSFORM, lxb_css_property_state_text_transform,
lxb_css_property_text_transform_create, lxb_css_property_text_transform_destroy, lxb_css_property_text_transform_serialize,
&(lxb_css_property_text_transform_t) {.type_case = LXB_CSS_TEXT_TRANSFORM_NONE, .full_width = LXB_CSS_PROPERTY__UNDEF, .full_size_kana = LXB_CSS_PROPERTY__UNDEF}},
{(lxb_char_t *) "top", 3, LXB_CSS_PROPERTY_TOP, lxb_css_property_state_top,
lxb_css_property_top_create, lxb_css_property_top_destroy, lxb_css_property_top_serialize,
&(lxb_css_property_top_t) {.type = LXB_CSS_VALUE_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "unicode-bidi", 12, LXB_CSS_PROPERTY_UNICODE_BIDI, lxb_css_property_state_unicode_bidi,
lxb_css_property_unicode_bidi_create, lxb_css_property_unicode_bidi_destroy, lxb_css_property_unicode_bidi_serialize,
&(lxb_css_property_unicode_bidi_t) {.type = LXB_CSS_UNICODE_BIDI_NORMAL}},
{(lxb_char_t *) "vertical-align", 14, LXB_CSS_PROPERTY_VERTICAL_ALIGN, lxb_css_property_state_vertical_align,
lxb_css_property_vertical_align_create, lxb_css_property_vertical_align_destroy, lxb_css_property_vertical_align_serialize,
&(lxb_css_property_vertical_align_t) {.type = LXB_CSS_ALIGNMENT_BASELINE_BASELINE}},
{(lxb_char_t *) "visibility", 10, LXB_CSS_PROPERTY_VISIBILITY, lxb_css_property_state_visibility,
lxb_css_property_visibility_create, lxb_css_property_visibility_destroy, lxb_css_property_visibility_serialize,
&(lxb_css_property_visibility_t) {.type = LXB_CSS_VISIBILITY_VISIBLE}},
{(lxb_char_t *) "white-space", 11, LXB_CSS_PROPERTY_WHITE_SPACE, lxb_css_property_state_white_space,
lxb_css_property_white_space_create, lxb_css_property_white_space_destroy, lxb_css_property_white_space_serialize,
&(lxb_css_property_white_space_t) {.type = LXB_CSS_WHITE_SPACE_NORMAL}},
{(lxb_char_t *) "width", 5, LXB_CSS_PROPERTY_WIDTH, lxb_css_property_state_width,
lxb_css_property_width_create, lxb_css_property_width_destroy, lxb_css_property_width_serialize,
&(lxb_css_property_width_t) {.type = LXB_CSS_WIDTH_AUTO, .u.length = {.num = 0, .is_float = false}}},
{(lxb_char_t *) "word-break", 10, LXB_CSS_PROPERTY_WORD_BREAK, lxb_css_property_state_word_break,
lxb_css_property_word_break_create, lxb_css_property_word_break_destroy, lxb_css_property_word_break_serialize,
&(lxb_css_property_word_break_t) {.type = LXB_CSS_WORD_BREAK_NORMAL}},
{(lxb_char_t *) "word-spacing", 12, LXB_CSS_PROPERTY_WORD_SPACING, lxb_css_property_state_word_spacing,
lxb_css_property_word_spacing_create, lxb_css_property_word_spacing_destroy, lxb_css_property_word_spacing_serialize,
&(lxb_css_property_word_spacing_t) {.type = LXB_CSS_WORD_SPACING_NORMAL}},
{(lxb_char_t *) "word-wrap", 9, LXB_CSS_PROPERTY_WORD_WRAP, lxb_css_property_state_word_wrap,
lxb_css_property_word_wrap_create, lxb_css_property_word_wrap_destroy, lxb_css_property_word_wrap_serialize,
&(lxb_css_property_word_wrap_t) {.type = LXB_CSS_WORD_WRAP_NORMAL}},
{(lxb_char_t *) "wrap-flow", 9, LXB_CSS_PROPERTY_WRAP_FLOW, lxb_css_property_state_wrap_flow,
lxb_css_property_wrap_flow_create, lxb_css_property_wrap_flow_destroy, lxb_css_property_wrap_flow_serialize,
&(lxb_css_property_wrap_flow_t) {.type = LXB_CSS_WRAP_FLOW_AUTO}},
{(lxb_char_t *) "wrap-through", 12, LXB_CSS_PROPERTY_WRAP_THROUGH, lxb_css_property_state_wrap_through,
lxb_css_property_wrap_through_create, lxb_css_property_wrap_through_destroy, lxb_css_property_wrap_through_serialize,
&(lxb_css_property_wrap_through_t) {.type = LXB_CSS_WRAP_THROUGH_WRAP}},
{(lxb_char_t *) "writing-mode", 12, LXB_CSS_PROPERTY_WRITING_MODE, lxb_css_property_state_writing_mode,
lxb_css_property_writing_mode_create, lxb_css_property_writing_mode_destroy, lxb_css_property_writing_mode_serialize,
&(lxb_css_property_writing_mode_t) {.type = LXB_CSS_WRITING_MODE_HORIZONTAL_TB}},
{(lxb_char_t *) "z-index", 7, LXB_CSS_PROPERTY_Z_INDEX, lxb_css_property_state_z_index,
lxb_css_property_z_index_create, lxb_css_property_z_index_destroy, lxb_css_property_z_index_serialize,
&(lxb_css_property_z_index_t) {.type = LXB_CSS_Z_INDEX_AUTO}}
};
static const lexbor_shs_entry_t lxb_css_property_shs[187] =
{
{NULL, NULL, 186, 0},
{"wrap-through", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WRAP_THROUGH], 12, 0},
{"width", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WIDTH], 5, 0},
{"color", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_COLOR], 5, 0},
{"text-overflow", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_OVERFLOW], 13, 0},
{"text-combine-upright", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_COMBINE_UPRIGHT], 20, 0},
{"direction", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_DIRECTION], 9, 0},
{"baseline-source", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BASELINE_SOURCE], 15, 0},
{"min-width", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MIN_WIDTH], 9, 0},
{"wrap-flow", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WRAP_FLOW], 9, 1},
{"align-content", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_ALIGN_CONTENT], 13, 0},
{"padding-left", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_PADDING_LEFT], 12, 0},
{"right", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_RIGHT], 5, 0},
{"font-stretch", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FONT_STRETCH], 12, 0},
{"flex-grow", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLEX_GROW], 9, 0},
{"border-top-color", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_TOP_COLOR], 16, 0},
{"border-left-color", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_LEFT_COLOR], 17, 0},
{"overflow-x", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_OVERFLOW_X], 10, 0},
{"clear", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_CLEAR], 5, 3},
{"padding-top", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_PADDING_TOP], 11, 0},
{"word-wrap", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WORD_WRAP], 9, 0},
{"border-top", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_TOP], 10, 0},
{"font-style", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FONT_STYLE], 10, 0},
{"text-transform", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_TRANSFORM], 14, 0},
{"white-space", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WHITE_SPACE], 11, 0},
{"padding-bottom", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_PADDING_BOTTOM], 14, 0},
{"vertical-align", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_VERTICAL_ALIGN], 14, 0},
{"visibility", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_VISIBILITY], 10, 0},
{"min-height", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MIN_HEIGHT], 10, 0},
{"inset-inline-start", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_INSET_INLINE_START], 18, 0},
{"flex-shrink", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLEX_SHRINK], 11, 7},
{NULL, NULL, 0, 0},
{"overflow-wrap", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_OVERFLOW_WRAP], 13, 0},
{"letter-spacing", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_LETTER_SPACING], 14, 0},
{NULL, NULL, 0, 0},
{"bottom", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BOTTOM], 6, 0},
{"max-width", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MAX_WIDTH], 9, 8},
{NULL, NULL, 0, 0},
{"dominant-baseline", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_DOMINANT_BASELINE], 17, 0},
{"margin-top", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MARGIN_TOP], 10, 11},
{"padding-right", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_PADDING_RIGHT], 13, 0},
{NULL, NULL, 0, 0},
{"border-bottom", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_BOTTOM], 13, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"text-align-all", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_ALIGN_ALL], 14, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"font-family", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FONT_FAMILY], 11, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"flex", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLEX], 4, 0},
{"alignment-baseline", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_ALIGNMENT_BASELINE], 18, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"opacity", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_OPACITY], 7, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"overflow-y", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_OVERFLOW_Y], 10, 0},
{NULL, NULL, 0, 0},
{"text-decoration-color", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_DECORATION_COLOR], 21, 0},
{"left", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_LEFT], 4, 0},
{"hyphens", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_HYPHENS], 7, 0},
{"border", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER], 6, 13},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"flex-flow", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLEX_FLOW], 9, 14},
{NULL, NULL, 0, 0},
{"line-height", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_LINE_HEIGHT], 11, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"box-sizing", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BOX_SIZING], 10, 0},
{NULL, NULL, 0, 0},
{"background-color", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BACKGROUND_COLOR], 16, 15},
{"display", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_DISPLAY], 7, 16},
{"border-right-color", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_RIGHT_COLOR], 18, 0},
{"border-bottom-color", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_BOTTOM_COLOR], 19, 0},
{"margin", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MARGIN], 6, 0},
{"word-break", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WORD_BREAK], 10, 19},
{NULL, NULL, 0, 0},
{"padding", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_PADDING], 7, 0},
{"align-items", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_ALIGN_ITEMS], 11, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"justify-content", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_JUSTIFY_CONTENT], 15, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"height", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_HEIGHT], 6, 0},
{"inset-block-end", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_INSET_BLOCK_END], 15, 0},
{"inset-inline-end", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_INSET_INLINE_END], 16, 0},
{NULL, NULL, 0, 0},
{"overflow-inline", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_OVERFLOW_INLINE], 15, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"font-size", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FONT_SIZE], 9, 0},
{"position", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_POSITION], 8, 22},
{"float", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLOAT], 5, 0},
{NULL, NULL, 0, 0},
{"top", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TOP], 3, 0},
{NULL, NULL, 0, 0},
{"float-reference", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLOAT_REFERENCE], 15, 0},
{NULL, NULL, 0, 0},
{"font-weight", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FONT_WEIGHT], 11, 0},
{"float-offset", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLOAT_OFFSET], 12, 23},
{NULL, NULL, 0, 0},
{"margin-bottom", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MARGIN_BOTTOM], 13, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"order", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_ORDER], 5, 0},
{NULL, NULL, 0, 0},
{"z-index", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_Z_INDEX], 7, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"flex-basis", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLEX_BASIS], 10, 24},
{"writing-mode", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WRITING_MODE], 12, 0},
{NULL, NULL, 0, 0},
{"border-left", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_LEFT], 11, 0},
{"border-right", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BORDER_RIGHT], 12, 0},
{"hanging-punctuation", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_HANGING_PUNCTUATION], 19, 0},
{"baseline-shift", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_BASELINE_SHIFT], 14, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"text-justify", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_JUSTIFY], 12, 26},
{"float-defer", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLOAT_DEFER], 11, 0},
{"max-height", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MAX_HEIGHT], 10, 28},
{"margin-left", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MARGIN_LEFT], 11, 0},
{"margin-right", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_MARGIN_RIGHT], 12, 0},
{"unicode-bidi", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_UNICODE_BIDI], 12, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"tab-size", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TAB_SIZE], 8, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"flex-wrap", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLEX_WRAP], 9, 0},
{"align-self", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_ALIGN_SELF], 10, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"text-decoration-line", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_DECORATION_LINE], 20, 0},
{"text-decoration-style", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_DECORATION_STYLE], 21, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"inset-block-start", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_INSET_BLOCK_START], 17, 0},
{"text-align", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_ALIGN], 10, 29},
{"word-spacing", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_WORD_SPACING], 12, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"text-decoration", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_DECORATION], 15, 0},
{"text-orientation", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_ORIENTATION], 16, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"overflow-block", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_OVERFLOW_BLOCK], 14, 0},
{NULL, NULL, 0, 0},
{"text-indent", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_INDENT], 11, 0},
{"flex-direction", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_FLEX_DIRECTION], 14, 0},
{NULL, NULL, 0, 0},
{"line-break", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_LINE_BREAK], 10, 0},
{"text-align-last", (void *) &lxb_css_property_data[LXB_CSS_PROPERTY_TEXT_ALIGN_LAST], 15, 0}
};
#endif /* LXB_CSS_PROPERTY_RES_H */

330
ext/dom/lexbor/lexbor/css/property/state.h Normal file
View file

@ -0,0 +1,330 @@
/*
* Copyright (C) 2021-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_PROPERTY_STATE_H
#define LXB_CSS_PROPERTY_STATE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
LXB_API bool
lxb_css_property_state__undef(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state__custom(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_display(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_order(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_visibility(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_width(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_height(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_box_sizing(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_min_width(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_min_height(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_max_width(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_max_height(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_margin(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_margin_top(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_margin_right(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_margin_bottom(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_margin_left(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_padding(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_padding_top(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_padding_right(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_padding_bottom(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_padding_left(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_top(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_right(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_bottom(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_left(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_top_color(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_right_color(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_bottom_color(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_border_left_color(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_background_color(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_color(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_opacity(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_position(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_top(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_right(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_bottom(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_left(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_inset_block_start(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_inset_inline_start(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_inset_block_end(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_inset_inline_end(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_transform(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_align(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_align_all(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_align_last(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_justify(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_indent(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_white_space(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_tab_size(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_word_break(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_line_break(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_hyphens(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_overflow_wrap(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_word_wrap(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_word_spacing(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_letter_spacing(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_hanging_punctuation(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_font_family(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_font_weight(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_font_stretch(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_font_style(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_font_size(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_float_reference(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_float(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_clear(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_float_defer(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_float_offset(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_wrap_flow(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_wrap_through(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_flex_direction(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_flex_wrap(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_flex_flow(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_flex(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_flex_grow(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_flex_shrink(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_flex_basis(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_justify_content(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_align_items(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_align_self(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_align_content(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_z_index(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_direction(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_unicode_bidi(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_writing_mode(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_orientation(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_combine_upright(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_overflow_x(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_overflow_y(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_overflow_block(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_overflow_inline(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_overflow(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_decoration_line(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_decoration_style(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_decoration_color(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_text_decoration(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_dominant_baseline(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_vertical_align(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_baseline_source(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_alignment_baseline(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_baseline_shift(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_property_state_line_height(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_PROPERTY_STATE_H */

433
ext/dom/lexbor/lexbor/css/rule.h Normal file
View file

@ -0,0 +1,433 @@
/*
* Copyright (C) 2021-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_RULE_H
#define LXB_CSS_RULE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
#include "lexbor/css/at_rule.h"
#include "lexbor/css/property.h"
#include "lexbor/css/selectors/selectors.h"
#define lxb_css_rule(rule) ((lxb_css_rule_t *) (rule))
#define lxb_css_rule_list(rule) ((lxb_css_rule_list_t *) (rule))
#define lxb_css_rule_at(rule) ((lxb_css_rule_at_t *) (rule))
#define lxb_css_rule_style(rule) ((lxb_css_rule_style_t *) (rule))
#define lxb_css_rule_bad_style(rule) ((lxb_css_rule_bad_style_t *) (rule))
#define lxb_css_rule_declaration_list(rule) ((lxb_css_rule_declaration_list_t *) (rule))
#define lxb_css_rule_declaration(rule) ((lxb_css_rule_declaration_t *) (rule))
typedef enum {
LXB_CSS_RULE_UNDEF = 0,
LXB_CSS_RULE_STYLESHEET,
LXB_CSS_RULE_LIST,
LXB_CSS_RULE_AT_RULE,
LXB_CSS_RULE_STYLE,
LXB_CSS_RULE_BAD_STYLE,
LXB_CSS_RULE_DECLARATION_LIST,
LXB_CSS_RULE_DECLARATION
}
lxb_css_rule_type_t;
typedef struct lxb_css_rule lxb_css_rule_t;
struct lxb_css_rule {
lxb_css_rule_type_t type;
lxb_css_rule_t *next;
lxb_css_rule_t *prev;
lxb_css_rule_t *parent;
const lxb_char_t *begin;
const lxb_char_t *end;
lxb_css_memory_t *memory;
size_t ref_count;
};
struct lxb_css_rule_list {
lxb_css_rule_t rule;
lxb_css_rule_t *first;
lxb_css_rule_t *last;
};
struct lxb_css_rule_at {
lxb_css_rule_t rule;
uintptr_t type;
union {
lxb_css_at_rule__undef_t *undef;
lxb_css_at_rule__custom_t *custom;
lxb_css_at_rule_media_t *media;
lxb_css_at_rule_namespace_t *ns;
void *user;
} u;
};
struct lxb_css_rule_style {
lxb_css_rule_t rule;
lxb_css_selector_list_t *selector;
lxb_css_rule_declaration_list_t *declarations;
};
struct lxb_css_rule_bad_style {
lxb_css_rule_t rule;
lexbor_str_t selectors;
lxb_css_rule_declaration_list_t *declarations;
};
struct lxb_css_rule_declaration_list {
lxb_css_rule_t rule;
lxb_css_rule_t *first;
lxb_css_rule_t *last;
size_t count;
};
struct lxb_css_rule_declaration {
lxb_css_rule_t rule;
uintptr_t type;
union {
lxb_css_property__undef_t *undef;
lxb_css_property__custom_t *custom;
lxb_css_property_display_t *display;
lxb_css_property_order_t *order;
lxb_css_property_visibility_t *visibility;
lxb_css_property_width_t *width;
lxb_css_property_height_t *height;
lxb_css_property_box_sizing_t *box_sizing;
lxb_css_property_margin_t *margin;
lxb_css_property_margin_top_t *margin_top;
lxb_css_property_margin_right_t *margin_right;
lxb_css_property_margin_bottom_t *margin_bottom;
lxb_css_property_margin_left_t *margin_left;
lxb_css_property_padding_t *padding;
lxb_css_property_padding_top_t *padding_top;
lxb_css_property_padding_right_t *padding_right;
lxb_css_property_padding_bottom_t *padding_bottom;
lxb_css_property_padding_left_t *padding_left;
lxb_css_property_border_t *border;
lxb_css_property_border_top_t *border_top;
lxb_css_property_border_right_t *border_right;
lxb_css_property_border_bottom_t *border_bottom;
lxb_css_property_border_left_t *border_left;
lxb_css_property_border_top_color_t *border_top_color;
lxb_css_property_border_right_color_t *border_right_color;
lxb_css_property_border_bottom_color_t *border_bottom_color;
lxb_css_property_border_left_color_t *border_left_color;
lxb_css_property_background_color_t *background_color;
lxb_css_property_color_t *color;
lxb_css_property_opacity_t *opacity;
lxb_css_property_position_t *position;
lxb_css_property_top_t *top;
lxb_css_property_right_t *right;
lxb_css_property_bottom_t *bottom;
lxb_css_property_left_t *left;
lxb_css_property_inset_block_start_t *inset_block_start;
lxb_css_property_inset_inline_start_t *inset_inline_start;
lxb_css_property_inset_block_end_t *inset_block_end;
lxb_css_property_inset_inline_end_t *inset_inline_end;
lxb_css_property_text_transform_t *text_transform;
lxb_css_property_text_align_t *text_align;
lxb_css_property_text_align_all_t *text_align_all;
lxb_css_property_text_align_last_t *text_align_last;
lxb_css_property_text_justify_t *text_justify;
lxb_css_property_text_indent_t *text_indent;
lxb_css_property_white_space_t *white_space;
lxb_css_property_tab_size_t *tab_size;
lxb_css_property_word_break_t *word_break;
lxb_css_property_line_break_t *line_break;
lxb_css_property_hyphens_t *hyphens;
lxb_css_property_overflow_wrap_t *overflow_wrap;
lxb_css_property_word_wrap_t *word_wrap;
lxb_css_property_word_spacing_t *word_spacing;
lxb_css_property_letter_spacing_t *letter_spacing;
lxb_css_property_hanging_punctuation_t *hanging_punctuation;
lxb_css_property_font_family_t *font_family;
lxb_css_property_font_weight_t *font_weight;
lxb_css_property_font_stretch_t *font_stretch;
lxb_css_property_font_style_t *font_style;
lxb_css_property_font_size_t *font_size;
lxb_css_property_float_reference_t *float_reference;
lxb_css_property_float_t *floatp;
lxb_css_property_clear_t *clear;
lxb_css_property_float_defer_t *float_defer;
lxb_css_property_float_offset_t *float_offset;
lxb_css_property_wrap_flow_t *wrap_flow;
lxb_css_property_wrap_through_t *wrap_through;
lxb_css_property_flex_direction_t *flex_direction;
lxb_css_property_flex_wrap_t *flex_wrap;
lxb_css_property_flex_flow_t *flex_flow;
lxb_css_property_flex_t *flex;
lxb_css_property_flex_grow_t *flex_grow;
lxb_css_property_flex_shrink_t *flex_shrink;
lxb_css_property_flex_basis_t *flex_basis;
lxb_css_property_justify_content_t *justify_content;
lxb_css_property_align_items_t *align_items;
lxb_css_property_align_self_t *align_self;
lxb_css_property_align_content_t *align_content;
lxb_css_property_dominant_baseline_t *dominant_baseline;
lxb_css_property_vertical_align_t *vertical_align;
lxb_css_property_baseline_source_t *baseline_source;
lxb_css_property_alignment_baseline_t *alignment_baseline;
lxb_css_property_baseline_shift_t *baseline_shift;
lxb_css_property_line_height_t *line_height;
lxb_css_property_z_index_t *z_index;
lxb_css_property_direction_t *direction;
lxb_css_property_unicode_bidi_t *unicode_bidi;
lxb_css_property_writing_mode_t *writing_mode;
lxb_css_property_text_orientation_t *text_orientation;
lxb_css_property_text_combine_upright_t *text_combine_upright;
lxb_css_property_overflow_x_t *overflow_x;
lxb_css_property_overflow_y_t *overflow_y;
lxb_css_property_overflow_block_t *overflow_block;
lxb_css_property_overflow_inline_t *overflow_inline;
lxb_css_property_text_overflow_t *text_overflow;
lxb_css_property_text_decoration_line_t *text_decoration_line;
lxb_css_property_text_decoration_style_t *text_decoration_style;
lxb_css_property_text_decoration_color_t *text_decoration_color;
lxb_css_property_text_decoration_t *text_decoration;
void *user;
} u;
bool important;
};
LXB_API void *
lxb_css_rule_destroy(lxb_css_rule_t *node, bool self_destroy);
LXB_API lxb_status_t
lxb_css_rule_serialize(const lxb_css_rule_t *rule,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_rule_serialize_chain(const lxb_css_rule_t *rule,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_css_rule_list_t *
lxb_css_rule_list_destroy(lxb_css_rule_list_t *list, bool self_destroy);
LXB_API lxb_status_t
lxb_css_rule_list_serialize(const lxb_css_rule_list_t *list,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_css_rule_at_t *
lxb_css_rule_at_destroy(lxb_css_rule_at_t *at, bool self_destroy);
LXB_API lxb_status_t
lxb_css_rule_at_serialize(const lxb_css_rule_at_t *at, lexbor_serialize_cb_f cb,
void *ctx);
LXB_API lxb_status_t
lxb_css_rule_at_serialize_name(const lxb_css_rule_at_t *at, lexbor_serialize_cb_f cb,
void *ctx);
LXB_API lxb_css_rule_style_t *
lxb_css_rule_style_destroy(lxb_css_rule_style_t *style, bool self_destroy);
LXB_API lxb_status_t
lxb_css_rule_style_serialize(const lxb_css_rule_style_t *style,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_css_rule_bad_style_t *
lxb_css_rule_bad_style_destroy(lxb_css_rule_bad_style_t *bad, bool self_destroy);
LXB_API lxb_status_t
lxb_css_rule_bad_style_serialize(const lxb_css_rule_bad_style_t *bad,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_css_rule_declaration_list_t *
lxb_css_rule_declaration_list_destroy(lxb_css_rule_declaration_list_t *list,
bool self_destroy);
LXB_API lxb_status_t
lxb_css_rule_declaration_list_serialize(const lxb_css_rule_declaration_list_t *list,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_css_rule_declaration_t *
lxb_css_rule_declaration_destroy(lxb_css_rule_declaration_t *declr,
bool self_destroy);
LXB_API lxb_status_t
lxb_css_rule_declaration_serialize(const lxb_css_rule_declaration_t *declaration,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_rule_declaration_serialize_name(const lxb_css_rule_declaration_t *declr,
lexbor_serialize_cb_f cb, void *ctx);
/*
* Inline functions
*/
lxb_inline void
lxb_css_rule_insert_next(lxb_css_rule_t *root, lxb_css_rule_t *rule)
{
if (root->next != NULL) {
rule->next = root->next;
}
root->next = rule;
rule->prev = root;
}
lxb_inline lxb_css_rule_t *
lxb_css_rule_create(lxb_css_memory_t *memory, size_t size,
lxb_css_rule_type_t type)
{
lxb_css_rule_t *rule;
rule = (lxb_css_rule_t *) lexbor_mraw_calloc(memory->tree, size);
if (rule== NULL) {
return NULL;
}
rule->type = type;
rule->memory = memory;
return rule;
}
lxb_inline lxb_css_rule_list_t *
lxb_css_rule_list_create(lxb_css_memory_t *memory)
{
return (lxb_css_rule_list_t *) lxb_css_rule_create(memory,
sizeof(lxb_css_rule_list_t),
LXB_CSS_RULE_LIST);
}
lxb_inline size_t
lxb_css_rule_ref_count(lxb_css_rule_t *rule)
{
return rule->ref_count;
}
lxb_inline lxb_status_t
lxb_css_rule_ref_inc(lxb_css_rule_t *rule)
{
if (SIZE_MAX - rule->ref_count == 0) {
return LXB_STATUS_ERROR_OVERFLOW;
}
rule->ref_count++;
return LXB_STATUS_OK;
}
lxb_inline void
lxb_css_rule_ref_dec(lxb_css_rule_t *rule)
{
if (rule->ref_count > 0) {
rule->ref_count--;
}
}
lxb_inline void
lxb_css_rule_ref_dec_destroy(lxb_css_rule_t *rule)
{
if (rule->ref_count > 0) {
rule->ref_count--;
}
if (rule->ref_count == 0) {
#if 0
(void) lxb_css_rule_destroy(rule, true);
#endif
}
}
lxb_inline void
lxb_css_rule_list_append(lxb_css_rule_list_t *list, lxb_css_rule_t *rule)
{
if (list->first == NULL) {
list->first = rule;
}
else {
lxb_css_rule_insert_next(list->last, rule);
}
list->last = rule;
rule->parent = lxb_css_rule(list);
(void) lxb_css_rule_ref_inc(rule);
}
lxb_inline lxb_css_rule_at_t *
lxb_css_rule_at_create(lxb_css_memory_t *memory)
{
return (lxb_css_rule_at_t *)
lxb_css_rule_create(memory, sizeof(lxb_css_rule_at_t),
LXB_CSS_RULE_AT_RULE);
}
lxb_inline lxb_css_rule_style_t *
lxb_css_rule_style_create(lxb_css_memory_t *memory)
{
return (lxb_css_rule_style_t *)
lxb_css_rule_create(memory, sizeof(lxb_css_rule_style_t),
LXB_CSS_RULE_STYLE);
}
lxb_inline lxb_css_rule_bad_style_t *
lxb_css_rule_bad_style_create(lxb_css_memory_t *memory)
{
return (lxb_css_rule_bad_style_t *)
lxb_css_rule_create(memory, sizeof(lxb_css_rule_bad_style_t),
LXB_CSS_RULE_BAD_STYLE);
}
lxb_inline lxb_css_rule_declaration_list_t *
lxb_css_rule_declaration_list_create(lxb_css_memory_t *memory)
{
return (lxb_css_rule_declaration_list_t *)
lxb_css_rule_create(memory, sizeof(lxb_css_rule_declaration_list_t),
LXB_CSS_RULE_DECLARATION_LIST);
}
lxb_inline void
lxb_css_rule_declaration_list_append(lxb_css_rule_declaration_list_t *list,
lxb_css_rule_t *rule)
{
if (list->first == NULL) {
list->first = rule;
}
else {
lxb_css_rule_insert_next(list->last, rule);
}
list->last = rule;
rule->parent = lxb_css_rule(list);
(void) lxb_css_rule_ref_inc(rule);
list->count++;
}
lxb_inline lxb_css_rule_declaration_t *
lxb_css_rule_declaration_create(lxb_css_memory_t *memory)
{
return (lxb_css_rule_declaration_t *)
lxb_css_rule_create(memory, sizeof(lxb_css_rule_declaration_t),
LXB_CSS_RULE_DECLARATION);
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_RULE_H */

47
ext/dom/lexbor/lexbor/css/selectors/base.h Normal file
View file

@ -0,0 +1,47 @@
/*
* Copyright (C) 2021-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SELECTORS_BASE_H
#define LEXBOR_CSS_SELECTORS_BASE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#define LXB_CSS_SELECTORS_VERSION_MAJOR 1
#define LXB_CSS_SELECTORS_VERSION_MINOR 0
#define LXB_CSS_SELECTORS_VERSION_PATCH 0
#define LXB_CSS_SELECTORS_VERSION_STRING \
LEXBOR_STRINGIZE(LXB_CSS_SELECTORS_VERSION_MAJOR) "." \
LEXBOR_STRINGIZE(LXB_CSS_SELECTORS_VERSION_MINOR) "." \
LEXBOR_STRINGIZE(LXB_CSS_SELECTORS_VERSION_PATCH)
#define lxb_css_selector_serialize_write(data, length) \
do { \
(status) = cb((lxb_char_t *) (data), (length), (ctx)); \
if ((status) != LXB_STATUS_OK) { \
return (status); \
} \
} \
while (false)
typedef struct lxb_css_selectors lxb_css_selectors_t;
typedef struct lxb_css_selector lxb_css_selector_t;
typedef struct lxb_css_selector_list lxb_css_selector_list_t;
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SELECTORS_BASE_H */

70
ext/dom/lexbor/lexbor/css/selectors/pseudo.h Normal file
View file

@ -0,0 +1,70 @@
/*
* Copyright (C) 2020-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SELECTORS_PSEUDO_H
#define LEXBOR_CSS_SELECTORS_PSEUDO_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
#include "lexbor/css/syntax/parser.h"
#include "lexbor/css/selectors/base.h"
typedef struct {
lxb_char_t *name;
size_t length;
unsigned id;
bool empty;
lxb_css_selector_combinator_t combinator;
const lxb_css_syntax_cb_function_t cb;
bool forgiving;
bool comma;
}
lxb_css_selectors_pseudo_data_func_t;
typedef struct {
lxb_char_t *name;
size_t length;
unsigned id;
}
lxb_css_selectors_pseudo_data_t;
LXB_API const lxb_css_selectors_pseudo_data_t *
lxb_css_selector_pseudo_class_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_selectors_pseudo_data_func_t *
lxb_css_selector_pseudo_class_function_by_name(const lxb_char_t *name,
size_t length);
LXB_API const lxb_css_selectors_pseudo_data_func_t *
lxb_css_selector_pseudo_class_function_by_id(unsigned id);
LXB_API const lxb_css_selectors_pseudo_data_t *
lxb_css_selector_pseudo_element_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_selectors_pseudo_data_func_t *
lxb_css_selector_pseudo_element_function_by_name(const lxb_char_t *name,
size_t length);
LXB_API const lxb_css_selectors_pseudo_data_func_t *
lxb_css_selector_pseudo_element_function_by_id(unsigned id);
LXB_API const lxb_css_selectors_pseudo_data_func_t *
lxb_css_selector_pseudo_function_by_id(unsigned id, bool is_class);
LXB_API bool
lxb_css_selector_pseudo_function_can_empty(unsigned id, bool is_class);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SELECTORS_PSEUDO_H */

109
ext/dom/lexbor/lexbor/css/selectors/pseudo_const.h Normal file
View file

@ -0,0 +1,109 @@
/*
* Copyright (C) 2020-2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/selectors/pseudo.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_SELECTOS_PSEUDO_CONST_H
#define LXB_CSS_SELECTOS_PSEUDO_CONST_H
typedef enum {
LXB_CSS_SELECTOR_PSEUDO_CLASS__UNDEF = 0x0000,
LXB_CSS_SELECTOR_PSEUDO_CLASS_ACTIVE = 0x0001,
LXB_CSS_SELECTOR_PSEUDO_CLASS_ANY_LINK = 0x0002,
LXB_CSS_SELECTOR_PSEUDO_CLASS_BLANK = 0x0003,
LXB_CSS_SELECTOR_PSEUDO_CLASS_CHECKED = 0x0004,
LXB_CSS_SELECTOR_PSEUDO_CLASS_CURRENT = 0x0005,
LXB_CSS_SELECTOR_PSEUDO_CLASS_DEFAULT = 0x0006,
LXB_CSS_SELECTOR_PSEUDO_CLASS_DISABLED = 0x0007,
LXB_CSS_SELECTOR_PSEUDO_CLASS_EMPTY = 0x0008,
LXB_CSS_SELECTOR_PSEUDO_CLASS_ENABLED = 0x0009,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FIRST_CHILD = 0x000a,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FIRST_OF_TYPE = 0x000b,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS = 0x000c,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS_VISIBLE = 0x000d,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS_WITHIN = 0x000e,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FULLSCREEN = 0x000f,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUTURE = 0x0010,
LXB_CSS_SELECTOR_PSEUDO_CLASS_HOVER = 0x0011,
LXB_CSS_SELECTOR_PSEUDO_CLASS_IN_RANGE = 0x0012,
LXB_CSS_SELECTOR_PSEUDO_CLASS_INDETERMINATE = 0x0013,
LXB_CSS_SELECTOR_PSEUDO_CLASS_INVALID = 0x0014,
LXB_CSS_SELECTOR_PSEUDO_CLASS_LAST_CHILD = 0x0015,
LXB_CSS_SELECTOR_PSEUDO_CLASS_LAST_OF_TYPE = 0x0016,
LXB_CSS_SELECTOR_PSEUDO_CLASS_LINK = 0x0017,
LXB_CSS_SELECTOR_PSEUDO_CLASS_LOCAL_LINK = 0x0018,
LXB_CSS_SELECTOR_PSEUDO_CLASS_ONLY_CHILD = 0x0019,
LXB_CSS_SELECTOR_PSEUDO_CLASS_ONLY_OF_TYPE = 0x001a,
LXB_CSS_SELECTOR_PSEUDO_CLASS_OPTIONAL = 0x001b,
LXB_CSS_SELECTOR_PSEUDO_CLASS_OUT_OF_RANGE = 0x001c,
LXB_CSS_SELECTOR_PSEUDO_CLASS_PAST = 0x001d,
LXB_CSS_SELECTOR_PSEUDO_CLASS_PLACEHOLDER_SHOWN = 0x001e,
LXB_CSS_SELECTOR_PSEUDO_CLASS_READ_ONLY = 0x001f,
LXB_CSS_SELECTOR_PSEUDO_CLASS_READ_WRITE = 0x0020,
LXB_CSS_SELECTOR_PSEUDO_CLASS_REQUIRED = 0x0021,
LXB_CSS_SELECTOR_PSEUDO_CLASS_ROOT = 0x0022,
LXB_CSS_SELECTOR_PSEUDO_CLASS_SCOPE = 0x0023,
LXB_CSS_SELECTOR_PSEUDO_CLASS_TARGET = 0x0024,
LXB_CSS_SELECTOR_PSEUDO_CLASS_TARGET_WITHIN = 0x0025,
LXB_CSS_SELECTOR_PSEUDO_CLASS_USER_INVALID = 0x0026,
LXB_CSS_SELECTOR_PSEUDO_CLASS_VALID = 0x0027,
LXB_CSS_SELECTOR_PSEUDO_CLASS_VISITED = 0x0028,
LXB_CSS_SELECTOR_PSEUDO_CLASS_WARNING = 0x0029,
LXB_CSS_SELECTOR_PSEUDO_CLASS__LAST_ENTRY = 0x002a
}
lxb_css_selector_pseudo_class_id_t;
typedef enum {
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION__UNDEF = 0x0000,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_CURRENT = 0x0001,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_DIR = 0x0002,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_HAS = 0x0003,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_IS = 0x0004,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_LANG = 0x0005,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NOT = 0x0006,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_CHILD = 0x0007,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_COL = 0x0008,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_CHILD = 0x0009,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_COL = 0x000a,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_OF_TYPE = 0x000b,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_OF_TYPE = 0x000c,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_WHERE = 0x000d,
LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION__LAST_ENTRY = 0x000e
}
lxb_css_selector_pseudo_class_function_id_t;
typedef enum {
LXB_CSS_SELECTOR_PSEUDO_ELEMENT__UNDEF = 0x0000,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_AFTER = 0x0001,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BACKDROP = 0x0002,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BEFORE = 0x0003,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FIRST_LETTER = 0x0004,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FIRST_LINE = 0x0005,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_GRAMMAR_ERROR = 0x0006,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_INACTIVE_SELECTION = 0x0007,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_MARKER = 0x0008,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_PLACEHOLDER = 0x0009,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SELECTION = 0x000a,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SPELLING_ERROR = 0x000b,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TARGET_TEXT = 0x000c,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT__LAST_ENTRY = 0x000d
}
lxb_css_selector_pseudo_element_id_t;
typedef enum {
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FUNCTION__UNDEF = 0x0000,
LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FUNCTION__LAST_ENTRY = 0x0001
}
lxb_css_selector_pseudo_element_function_id_t;
#endif /* LXB_CSS_SELECTOS_PSEUDO_CONST_H */

317
ext/dom/lexbor/lexbor/css/selectors/pseudo_res.h Normal file
View file

@ -0,0 +1,317 @@
/*
* Copyright (C) 2020-2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/selectors/pseudo.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_SELECTOS_PSEUDO_RES_H
#define LXB_CSS_SELECTOS_PSEUDO_RES_H
#include "lexbor/core/shs.h"
#include "lexbor/css/selectors/pseudo_const.h"
static const lxb_css_selectors_pseudo_data_t lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS__LAST_ENTRY] =
{
{(lxb_char_t *) "#undef", 6, LXB_CSS_SELECTOR_PSEUDO_CLASS__UNDEF},
{(lxb_char_t *) "active", 6, LXB_CSS_SELECTOR_PSEUDO_CLASS_ACTIVE},
{(lxb_char_t *) "any-link", 8, LXB_CSS_SELECTOR_PSEUDO_CLASS_ANY_LINK},
{(lxb_char_t *) "blank", 5, LXB_CSS_SELECTOR_PSEUDO_CLASS_BLANK},
{(lxb_char_t *) "checked", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_CHECKED},
{(lxb_char_t *) "current", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_CURRENT},
{(lxb_char_t *) "default", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_DEFAULT},
{(lxb_char_t *) "disabled", 8, LXB_CSS_SELECTOR_PSEUDO_CLASS_DISABLED},
{(lxb_char_t *) "empty", 5, LXB_CSS_SELECTOR_PSEUDO_CLASS_EMPTY},
{(lxb_char_t *) "enabled", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_ENABLED},
{(lxb_char_t *) "first-child", 11, LXB_CSS_SELECTOR_PSEUDO_CLASS_FIRST_CHILD},
{(lxb_char_t *) "first-of-type", 13, LXB_CSS_SELECTOR_PSEUDO_CLASS_FIRST_OF_TYPE},
{(lxb_char_t *) "focus", 5, LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS},
{(lxb_char_t *) "focus-visible", 13, LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS_VISIBLE},
{(lxb_char_t *) "focus-within", 12, LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS_WITHIN},
{(lxb_char_t *) "fullscreen", 10, LXB_CSS_SELECTOR_PSEUDO_CLASS_FULLSCREEN},
{(lxb_char_t *) "future", 6, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUTURE},
{(lxb_char_t *) "hover", 5, LXB_CSS_SELECTOR_PSEUDO_CLASS_HOVER},
{(lxb_char_t *) "in-range", 8, LXB_CSS_SELECTOR_PSEUDO_CLASS_IN_RANGE},
{(lxb_char_t *) "indeterminate", 13, LXB_CSS_SELECTOR_PSEUDO_CLASS_INDETERMINATE},
{(lxb_char_t *) "invalid", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_INVALID},
{(lxb_char_t *) "last-child", 10, LXB_CSS_SELECTOR_PSEUDO_CLASS_LAST_CHILD},
{(lxb_char_t *) "last-of-type", 12, LXB_CSS_SELECTOR_PSEUDO_CLASS_LAST_OF_TYPE},
{(lxb_char_t *) "link", 4, LXB_CSS_SELECTOR_PSEUDO_CLASS_LINK},
{(lxb_char_t *) "local-link", 10, LXB_CSS_SELECTOR_PSEUDO_CLASS_LOCAL_LINK},
{(lxb_char_t *) "only-child", 10, LXB_CSS_SELECTOR_PSEUDO_CLASS_ONLY_CHILD},
{(lxb_char_t *) "only-of-type", 12, LXB_CSS_SELECTOR_PSEUDO_CLASS_ONLY_OF_TYPE},
{(lxb_char_t *) "optional", 8, LXB_CSS_SELECTOR_PSEUDO_CLASS_OPTIONAL},
{(lxb_char_t *) "out-of-range", 12, LXB_CSS_SELECTOR_PSEUDO_CLASS_OUT_OF_RANGE},
{(lxb_char_t *) "past", 4, LXB_CSS_SELECTOR_PSEUDO_CLASS_PAST},
{(lxb_char_t *) "placeholder-shown", 17, LXB_CSS_SELECTOR_PSEUDO_CLASS_PLACEHOLDER_SHOWN},
{(lxb_char_t *) "read-only", 9, LXB_CSS_SELECTOR_PSEUDO_CLASS_READ_ONLY},
{(lxb_char_t *) "read-write", 10, LXB_CSS_SELECTOR_PSEUDO_CLASS_READ_WRITE},
{(lxb_char_t *) "required", 8, LXB_CSS_SELECTOR_PSEUDO_CLASS_REQUIRED},
{(lxb_char_t *) "root", 4, LXB_CSS_SELECTOR_PSEUDO_CLASS_ROOT},
{(lxb_char_t *) "scope", 5, LXB_CSS_SELECTOR_PSEUDO_CLASS_SCOPE},
{(lxb_char_t *) "target", 6, LXB_CSS_SELECTOR_PSEUDO_CLASS_TARGET},
{(lxb_char_t *) "target-within", 13, LXB_CSS_SELECTOR_PSEUDO_CLASS_TARGET_WITHIN},
{(lxb_char_t *) "user-invalid", 12, LXB_CSS_SELECTOR_PSEUDO_CLASS_USER_INVALID},
{(lxb_char_t *) "valid", 5, LXB_CSS_SELECTOR_PSEUDO_CLASS_VALID},
{(lxb_char_t *) "visited", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_VISITED},
{(lxb_char_t *) "warning", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_WARNING}
};
static const lxb_css_selectors_pseudo_data_func_t lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION__LAST_ENTRY] =
{
{(lxb_char_t *) "#undef", 6, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION__UNDEF,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function__undef, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false},
{(lxb_char_t *) "current", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_CURRENT,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_current, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, true},
{(lxb_char_t *) "dir", 3, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_DIR,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_dir, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false},
{(lxb_char_t *) "has", 3, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_HAS,
false, LXB_CSS_SELECTOR_COMBINATOR_DESCENDANT,
{.state = lxb_css_selectors_state_pseudo_class_function_has, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_forgiving_relative}, true, true},
{(lxb_char_t *) "is", 2, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_IS,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_is, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_forgiving}, true, true},
{(lxb_char_t *) "lang", 4, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_LANG,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_lang, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false},
{(lxb_char_t *) "not", 3, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NOT,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_not, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, true},
{(lxb_char_t *) "nth-child", 9, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_CHILD,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_nth_child, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, true},
{(lxb_char_t *) "nth-col", 7, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_COL,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_nth_col, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false},
{(lxb_char_t *) "nth-last-child", 14, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_CHILD,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_nth_last_child, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, true},
{(lxb_char_t *) "nth-last-col", 12, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_COL,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_nth_last_col, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false},
{(lxb_char_t *) "nth-last-of-type", 16, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_OF_TYPE,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_nth_last_of_type, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false},
{(lxb_char_t *) "nth-of-type", 11, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_OF_TYPE,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_nth_of_type, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false},
{(lxb_char_t *) "where", 5, LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_WHERE,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_class_function_where, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_forgiving}, true, true}
};
static const lxb_css_selectors_pseudo_data_t lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT__LAST_ENTRY] =
{
{(lxb_char_t *) "#undef", 6, LXB_CSS_SELECTOR_PSEUDO_ELEMENT__UNDEF},
{(lxb_char_t *) "after", 5, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_AFTER},
{(lxb_char_t *) "backdrop", 8, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BACKDROP},
{(lxb_char_t *) "before", 6, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BEFORE},
{(lxb_char_t *) "first-letter", 12, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FIRST_LETTER},
{(lxb_char_t *) "first-line", 10, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FIRST_LINE},
{(lxb_char_t *) "grammar-error", 13, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_GRAMMAR_ERROR},
{(lxb_char_t *) "inactive-selection", 18, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_INACTIVE_SELECTION},
{(lxb_char_t *) "marker", 6, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_MARKER},
{(lxb_char_t *) "placeholder", 11, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_PLACEHOLDER},
{(lxb_char_t *) "selection", 9, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SELECTION},
{(lxb_char_t *) "spelling-error", 14, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SPELLING_ERROR},
{(lxb_char_t *) "target-text", 11, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TARGET_TEXT}
};
static const lxb_css_selectors_pseudo_data_func_t lxb_css_selectors_pseudo_data_pseudo_element_function[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FUNCTION__LAST_ENTRY] =
{
{(lxb_char_t *) "#undef", 6, LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FUNCTION__UNDEF,
false, LXB_CSS_SELECTOR_COMBINATOR_CLOSE,
{.state = lxb_css_selectors_state_pseudo_element_function__undef, .block = NULL,
.failed = lxb_css_state_failed, .end = lxb_css_selectors_state_function_end}, false, false}
};
static const lexbor_shs_entry_t lxb_css_selectors_pseudo_class_shs[79] =
{
{NULL, NULL, 78, 0},
{"focus-visible", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS_VISIBLE], 13, 0},
{"first-of-type", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_FIRST_OF_TYPE], 13, 1},
{"in-range", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_IN_RANGE], 8, 0},
{"out-of-range", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_OUT_OF_RANGE], 12, 0},
{"read-write", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_READ_WRITE], 10, 0},
{"hover", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_HOVER], 5, 3},
{"enabled", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_ENABLED], 7, 0},
{"fullscreen", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_FULLSCREEN], 10, 0},
{"placeholder-shown", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_PLACEHOLDER_SHOWN], 17, 0},
{"target-within", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_TARGET_WITHIN], 13, 0},
{"indeterminate", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_INDETERMINATE], 13, 0},
{"local-link", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_LOCAL_LINK], 10, 0},
{"user-invalid", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_USER_INVALID], 12, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"past", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_PAST], 4, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"only-of-type", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_ONLY_OF_TYPE], 12, 4},
{"only-child", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_ONLY_CHILD], 10, 5},
{"focus", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS], 5, 7},
{NULL, NULL, 0, 0},
{"any-link", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_ANY_LINK], 8, 0},
{NULL, NULL, 0, 0},
{"valid", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_VALID], 5, 0},
{NULL, NULL, 0, 0},
{"visited", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_VISITED], 7, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"root", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_ROOT], 4, 8},
{NULL, NULL, 0, 0},
{"focus-within", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_FOCUS_WITHIN], 12, 0},
{"checked", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_CHECKED], 7, 9},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"active", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_ACTIVE], 6, 0},
{"last-of-type", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_LAST_OF_TYPE], 12, 0},
{NULL, NULL, 0, 0},
{"target", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_TARGET], 6, 0},
{"read-only", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_READ_ONLY], 9, 10},
{NULL, NULL, 0, 0},
{"first-child", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_FIRST_CHILD], 11, 0},
{"disabled", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_DISABLED], 8, 0},
{NULL, NULL, 0, 0},
{"required", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_REQUIRED], 8, 0},
{NULL, NULL, 0, 0},
{"link", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_LINK], 4, 0},
{NULL, NULL, 0, 0},
{"empty", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_EMPTY], 5, 0},
{"invalid", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_INVALID], 7, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"scope", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_SCOPE], 5, 12},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"blank", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_BLANK], 5, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"warning", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_WARNING], 7, 0},
{"default", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_DEFAULT], 7, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"future", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUTURE], 6, 0},
{"current", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_CURRENT], 7, 0},
{"optional", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_OPTIONAL], 8, 0},
{NULL, NULL, 0, 0},
{"last-child", (void *) &lxb_css_selectors_pseudo_data_pseudo_class[LXB_CSS_SELECTOR_PSEUDO_CLASS_LAST_CHILD], 10, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_selectors_pseudo_class_function_shs[39] =
{
{NULL, NULL, 38, 0},
{NULL, NULL, 0, 0},
{"current", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_CURRENT], 7, 0},
{NULL, NULL, 0, 0},
{"dir", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_DIR], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"is", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_IS], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"nth-child", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_CHILD], 9, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"nth-last-child", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_CHILD], 14, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"where", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_WHERE], 5, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"nth-col", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_COL], 7, 0},
{"lang", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_LANG], 4, 0},
{"has", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_HAS], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"nth-last-col", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_COL], 12, 0},
{"nth-of-type", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_OF_TYPE], 11, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"not", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NOT], 3, 0},
{"nth-last-of-type", (void *) &lxb_css_selectors_pseudo_data_pseudo_class_function[LXB_CSS_SELECTOR_PSEUDO_CLASS_FUNCTION_NTH_LAST_OF_TYPE], 16, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_selectors_pseudo_element_shs[24] =
{
{NULL, NULL, 23, 0},
{NULL, NULL, 0, 0},
{"inactive-selection", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_INACTIVE_SELECTION], 18, 0},
{"placeholder", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_PLACEHOLDER], 11, 0},
{"after", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_AFTER], 5, 0},
{"first-letter", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FIRST_LETTER], 12, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"grammar-error", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_GRAMMAR_ERROR], 13, 0},
{"before", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BEFORE], 6, 0},
{"selection", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SELECTION], 9, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"target-text", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_TARGET_TEXT], 11, 0},
{"first-line", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_FIRST_LINE], 10, 0},
{"spelling-error", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_SPELLING_ERROR], 14, 0},
{"backdrop", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_BACKDROP], 8, 0},
{"marker", (void *) &lxb_css_selectors_pseudo_data_pseudo_element[LXB_CSS_SELECTOR_PSEUDO_ELEMENT_MARKER], 6, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_selectors_pseudo_element_function_shs[6] =
{
{NULL, NULL, 5, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}
};
#endif /* LXB_CSS_SELECTOS_PSEUDO_RES_H */

85
ext/dom/lexbor/lexbor/css/selectors/pseudo_state.h Normal file
View file

@ -0,0 +1,85 @@
/*
* Copyright (C) 2020-2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SELECTORS_PSEUDO_STATE_H
#define LEXBOR_CSS_SELECTORS_PSEUDO_STATE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
#include "lexbor/css/parser.h"
#include "lexbor/css/syntax/parser.h"
#include "lexbor/css/selectors/base.h"
LXB_API bool
lxb_css_selectors_state_pseudo_class_function__undef(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_current(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_dir(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_has(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_is(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_lang(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_not(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_nth_child(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_nth_col(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_nth_last_child(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_nth_last_col(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_nth_last_of_type(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_nth_of_type(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_class_function_where(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_pseudo_element_function__undef(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SELECTORS_PSEUDO_STATE_H */

258
ext/dom/lexbor/lexbor/css/selectors/selector.h Normal file
View file

@ -0,0 +1,258 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SELECTORS_SELECTOR_H
#define LEXBOR_CSS_SELECTORS_SELECTOR_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/str.h"
#include "lexbor/css/selectors/base.h"
#include "lexbor/css/syntax/anb.h"
typedef enum {
LXB_CSS_SELECTOR_TYPE__UNDEF = 0x00,
LXB_CSS_SELECTOR_TYPE_ANY,
LXB_CSS_SELECTOR_TYPE_ELEMENT, /* div, tag name <div> */
LXB_CSS_SELECTOR_TYPE_ID, /* #hash */
LXB_CSS_SELECTOR_TYPE_CLASS, /* .class */
LXB_CSS_SELECTOR_TYPE_ATTRIBUTE, /* [key=val], <... key="val"> */
LXB_CSS_SELECTOR_TYPE_PSEUDO_CLASS, /* :pseudo */
LXB_CSS_SELECTOR_TYPE_PSEUDO_CLASS_FUNCTION, /* :function(...) */
LXB_CSS_SELECTOR_TYPE_PSEUDO_ELEMENT, /* ::pseudo */
LXB_CSS_SELECTOR_TYPE_PSEUDO_ELEMENT_FUNCTION, /* ::function(...) */
LXB_CSS_SELECTOR_TYPE__LAST_ENTRY
}
lxb_css_selector_type_t;
typedef enum {
LXB_CSS_SELECTOR_COMBINATOR_DESCENDANT = 0x00, /* WHITESPACE */
LXB_CSS_SELECTOR_COMBINATOR_CLOSE, /* two compound selectors [key=val].foo */
LXB_CSS_SELECTOR_COMBINATOR_CHILD, /* '>' */
LXB_CSS_SELECTOR_COMBINATOR_SIBLING, /* '+' */
LXB_CSS_SELECTOR_COMBINATOR_FOLLOWING, /* '~' */
LXB_CSS_SELECTOR_COMBINATOR_CELL, /* '||' */
LXB_CSS_SELECTOR_COMBINATOR__LAST_ENTRY
}
lxb_css_selector_combinator_t;
typedef enum {
LXB_CSS_SELECTOR_MATCH_EQUAL = 0x00, /* = */
LXB_CSS_SELECTOR_MATCH_INCLUDE, /* ~= */
LXB_CSS_SELECTOR_MATCH_DASH, /* |= */
LXB_CSS_SELECTOR_MATCH_PREFIX, /* ^= */
LXB_CSS_SELECTOR_MATCH_SUFFIX, /* $= */
LXB_CSS_SELECTOR_MATCH_SUBSTRING, /* *= */
LXB_CSS_SELECTOR_MATCH__LAST_ENTRY
}
lxb_css_selector_match_t;
typedef enum {
LXB_CSS_SELECTOR_MODIFIER_UNSET = 0x00,
LXB_CSS_SELECTOR_MODIFIER_I,
LXB_CSS_SELECTOR_MODIFIER_S,
LXB_CSS_SELECTOR_MODIFIER__LAST_ENTRY
}
lxb_css_selector_modifier_t;
typedef struct {
lxb_css_selector_match_t match;
lxb_css_selector_modifier_t modifier;
lexbor_str_t value;
}
lxb_css_selector_attribute_t;
typedef struct {
unsigned type;
void *data;
}
lxb_css_selector_pseudo_t;
typedef struct {
lxb_css_syntax_anb_t anb;
lxb_css_selector_list_t *of;
}
lxb_css_selector_anb_of_t;
struct lxb_css_selector {
lxb_css_selector_type_t type;
lxb_css_selector_combinator_t combinator;
lexbor_str_t name;
lexbor_str_t ns;
union lxb_css_selector_u {
lxb_css_selector_attribute_t attribute;
lxb_css_selector_pseudo_t pseudo;
}
u;
lxb_css_selector_t *next;
lxb_css_selector_t *prev;
lxb_css_selector_list_t *list;
};
/*
* I S A B C
* 1 bit | 1 bit | 9 bit | 9 bit | 9 bit
*/
typedef uint32_t lxb_css_selector_specificity_t;
#define LXB_CSS_SELECTOR_SPECIFICITY_MASK_N(sp, n) \
((sp) & ~((((uint32_t) 1 << 9) - 1) << (n)))
#define LXB_CSS_SELECTOR_SPECIFICITY_MASK \
((((uint32_t) 1 << 31) - 1) << (9))
#define lxb_css_selector_sp_i(sp) ((sp) >> 28)
#define lxb_css_selector_sp_s(sp) \
(((sp) >> 27) & ~((((uint32_t) 1 << 31) - 1) << (1)))
#define lxb_css_selector_sp_a(sp) \
(((sp) >> 18) & ~LXB_CSS_SELECTOR_SPECIFICITY_MASK)
#define lxb_css_selector_sp_b(sp) \
(((sp) >> 9) & ~LXB_CSS_SELECTOR_SPECIFICITY_MASK)
#define lxb_css_selector_sp_c(sp) \
((sp) & ~LXB_CSS_SELECTOR_SPECIFICITY_MASK)
#define lxb_css_selector_sp_set_i(sp, num) \
sp = (LXB_CSS_SELECTOR_SPECIFICITY_MASK_N((sp), 28) | ((num) << 28))
#define lxb_css_selector_sp_set_s(sp, num) \
sp = (LXB_CSS_SELECTOR_SPECIFICITY_MASK_N((sp), 27) | ((num) << 27))
#define lxb_css_selector_sp_set_a(sp, num) \
sp = (LXB_CSS_SELECTOR_SPECIFICITY_MASK_N((sp), 18) | ((num) << 18))
#define lxb_css_selector_sp_set_b(sp, num) \
sp = (LXB_CSS_SELECTOR_SPECIFICITY_MASK_N((sp), 9) | ((num) << 9))
#define lxb_css_selector_sp_set_c(sp, num) \
sp = (LXB_CSS_SELECTOR_SPECIFICITY_MASK_N((sp), 0) | (num))
#define lxb_css_selector_sp_add_s(sp, num) \
(lxb_css_selector_sp_set_s((sp), lxb_css_selector_sp_s(sp) + num))
#define lxb_css_selector_sp_add_a(sp, num) \
(lxb_css_selector_sp_set_a((sp), lxb_css_selector_sp_a(sp) + num))
#define lxb_css_selector_sp_add_b(sp, num) \
(lxb_css_selector_sp_set_b((sp), lxb_css_selector_sp_b(sp) + num))
#define lxb_css_selector_sp_add_c(sp, num) \
(lxb_css_selector_sp_set_c((sp), lxb_css_selector_sp_c(sp) + num))
#define lxb_css_selector_sp_up_i(num) (num | (1 << 28))
#define lxb_css_selector_sp_up_s(num) (num | (1 << 27))
#define LXB_CSS_SELECTOR_SP_S_MAX ((1 << 28) - 1)
#define LXB_CSS_SELECTOR_SP_A_MAX ((1 << 27) - 1)
#define LXB_CSS_SELECTOR_SP_B_MAX ((1 << 18) - 1)
#define LXB_CSS_SELECTOR_SP_C_MAX ((1 << 9) - 1)
struct lxb_css_selector_list {
lxb_css_selector_t *first;
lxb_css_selector_t *last;
lxb_css_selector_t *parent;
lxb_css_selector_list_t *next;
lxb_css_selector_list_t *prev;
lxb_css_memory_t *memory;
lxb_css_selector_specificity_t specificity;
};
LXB_API lxb_css_selector_t *
lxb_css_selector_create(lxb_css_selector_list_t *list);
LXB_API void
lxb_css_selector_destroy(lxb_css_selector_t *selector);
LXB_API void
lxb_css_selector_destroy_chain(lxb_css_selector_t *selector);
LXB_API void
lxb_css_selector_remove(lxb_css_selector_t *selector);
LXB_API lxb_css_selector_list_t *
lxb_css_selector_list_create(lxb_css_memory_t *mem);
LXB_API void
lxb_css_selector_list_remove(lxb_css_selector_list_t *list);
LXB_API void
lxb_css_selector_list_selectors_remove(lxb_css_selectors_t *selectors,
lxb_css_selector_list_t *list);
LXB_API void
lxb_css_selector_list_destroy(lxb_css_selector_list_t *list);
LXB_API void
lxb_css_selector_list_destroy_chain(lxb_css_selector_list_t *list);
LXB_API void
lxb_css_selector_list_destroy_memory(lxb_css_selector_list_t *list);
LXB_API lxb_status_t
lxb_css_selector_serialize(lxb_css_selector_t *selector,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_selector_serialize_chain(lxb_css_selector_t *selector,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_char_t *
lxb_css_selector_serialize_chain_char(lxb_css_selector_t *selector,
size_t *out_length);
LXB_API lxb_status_t
lxb_css_selector_serialize_list(lxb_css_selector_list_t *list,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_selector_serialize_list_chain(lxb_css_selector_list_t *list,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_char_t *
lxb_css_selector_serialize_list_chain_char(lxb_css_selector_list_t *list,
size_t *out_length);
LXB_API lxb_status_t
lxb_css_selector_serialize_anb_of(lxb_css_selector_anb_of_t *anbof,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_char_t *
lxb_css_selector_combinator(lxb_css_selector_t *selector, size_t *out_length);
LXB_API void
lxb_css_selector_list_append(lxb_css_selector_list_t *list,
lxb_css_selector_t *selector);
LXB_API void
lxb_css_selector_list_append_next(lxb_css_selector_list_t *dist,
lxb_css_selector_list_t *src);
LXB_API void
lxb_css_selector_append_next(lxb_css_selector_t *dist, lxb_css_selector_t *src);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SELECTORS_SELECTOR_H */

123
ext/dom/lexbor/lexbor/css/selectors/selectors.h Normal file
View file

@ -0,0 +1,123 @@
/*
* Copyright (C) 2020-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SELECTORS_H
#define LEXBOR_CSS_SELECTORS_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/dobject.h"
#include "lexbor/css/base.h"
#include "lexbor/css/syntax/parser.h"
#include "lexbor/css/syntax/syntax.h"
#include "lexbor/css/selectors/base.h"
#include "lexbor/css/selectors/selector.h"
#include "lexbor/css/selectors/pseudo_const.h"
struct lxb_css_selectors {
lxb_css_selector_list_t *list;
lxb_css_selector_list_t *list_last;
lxb_css_selector_t *parent;
lxb_css_selector_combinator_t combinator;
lxb_css_selector_combinator_t comb_default;
uintptr_t error;
bool status;
bool err_in_function;
bool failed;
};
LXB_API lxb_css_selectors_t *
lxb_css_selectors_create(void);
LXB_API lxb_status_t
lxb_css_selectors_init(lxb_css_selectors_t *selectors);
LXB_API void
lxb_css_selectors_clean(lxb_css_selectors_t *selectors);
LXB_API lxb_css_selectors_t *
lxb_css_selectors_destroy(lxb_css_selectors_t *selectors, bool self_destroy);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_complex_list(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_compound_list(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_simple_list(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_relative_list(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_complex(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_compound(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_simple(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_css_selector_list_t *
lxb_css_selectors_parse_relative(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
/*
* Inline functions
*/
lxb_inline void
lxb_css_selectors_append_next(lxb_css_selectors_t *selectors,
lxb_css_selector_t *selector)
{
if (selectors->list_last->last != NULL) {
lxb_css_selector_append_next(selectors->list_last->last, selector);
}
else {
selectors->list_last->first = selector;
}
selectors->list_last->last = selector;
}
lxb_inline void
lxb_css_selectors_list_append_next(lxb_css_selectors_t *selectors,
lxb_css_selector_list_t *list)
{
if (selectors->list_last != NULL) {
lxb_css_selector_list_append_next(selectors->list_last, list);
}
else {
selectors->list = list;
}
selectors->list_last = list;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SELECTORS_H */

86
ext/dom/lexbor/lexbor/css/selectors/state.h Normal file
View file

@ -0,0 +1,86 @@
/*
* Copyright (C) 2020 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SELECTORS_STATE_H
#define LEXBOR_CSS_SELECTORS_STATE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/parser.h"
#include "lexbor/css/selectors/base.h"
LXB_API bool
lxb_css_selectors_state_complex_list(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx);
LXB_API bool
lxb_css_selectors_state_compound_list(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx);
LXB_API bool
lxb_css_selectors_state_simple_list(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx);
LXB_API bool
lxb_css_selectors_state_relative_list(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx);
LXB_API bool
lxb_css_selectors_state_relative(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx);
LXB_API bool
lxb_css_selectors_state_complex(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_compound(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_selectors_state_simple(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API lxb_status_t
lxb_css_selectors_state_function_end(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx, bool failed);
LXB_API lxb_status_t
lxb_css_selectors_state_function_forgiving(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx, bool failed);
LXB_API lxb_status_t
lxb_css_selectors_state_function_forgiving_relative(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx, bool failed);
lxb_inline bool
lxb_css_selectors_state_fail(lxb_css_parser_t *parser)
{
parser->status = LXB_STATUS_ERROR_UNEXPECTED_DATA;
(void) lxb_css_parser_states_pop(parser);
return false;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SELECTORS_STATE_H */

34
ext/dom/lexbor/lexbor/css/state.h Normal file
View file

@ -0,0 +1,34 @@
/*
* Copyright (C) 2021-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_STATE_H
#define LXB_CSS_STATE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
LXB_API bool
lxb_css_state_success(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_state_failed(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
LXB_API bool
lxb_css_state_stop(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_STATE_H */

54
ext/dom/lexbor/lexbor/css/stylesheet.h Normal file
View file

@ -0,0 +1,54 @@
/*
* Copyright (C) 2020-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_STYLESHEET_H
#define LXB_CSS_STYLESHEET_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/rule.h"
#include "lexbor/core/mraw.h"
#include "lexbor/css/at_rule.h"
#include "lexbor/css/syntax/tokenizer.h"
#include "lexbor/css/selectors/base.h"
struct lxb_css_stylesheet {
lxb_css_rule_t *root;
lxb_css_memory_t *memory;
void *element; /* lxb_html_style_element_t * */
};
LXB_API lxb_css_stylesheet_t *
lxb_css_stylesheet_create(lxb_css_memory_t *memory);
LXB_API lxb_css_stylesheet_t *
lxb_css_stylesheet_destroy(lxb_css_stylesheet_t *sst, bool destroy_memory);
LXB_API lxb_css_stylesheet_t *
lxb_css_stylesheet_parse(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_status_t
lxb_css_stylesheet_prepare(lxb_css_parser_t *parser, lxb_css_memory_t *memory,
lxb_css_selectors_t *selectors);
LXB_API lxb_css_stylesheet_t *
lxb_css_stylesheet_process(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API void
lxb_css_stylesheet_finish(lxb_css_parser_t *parser);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_STYLESHEET_H */

46
ext/dom/lexbor/lexbor/css/syntax/anb.h Normal file
View file

@ -0,0 +1,46 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_ANB_H
#define LEXBOR_CSS_SYNTAX_ANB_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/syntax/token.h"
typedef struct {
long a;
long b;
}
lxb_css_syntax_anb_t;
LXB_API lxb_css_syntax_anb_t
lxb_css_syntax_anb_parse(lxb_css_parser_t *parser,
const lxb_char_t *data, size_t length);
LXB_API lxb_status_t
lxb_css_syntax_anb_handler(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_syntax_anb_t *anb);
LXB_API lxb_status_t
lxb_css_syntax_anb_serialize(lxb_css_syntax_anb_t *anb,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_char_t *
lxb_css_syntax_anb_serialize_char(lxb_css_syntax_anb_t *anb,
size_t *out_length);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_ANB_H */

33
ext/dom/lexbor/lexbor/css/syntax/base.h Normal file
View file

@ -0,0 +1,33 @@
/*
* Copyright (C) 2018-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_BASE_H
#define LEXBOR_CSS_SYNTAX_BASE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/css/base.h"
#define LXB_CSS_SYNTAX_VERSION_MAJOR 1
#define LXB_CSS_SYNTAX_VERSION_MINOR 1
#define LXB_CSS_SYNTAX_VERSION_PATCH 0
#define LXB_CSS_SYNTAX_VERSION_STRING \
LEXBOR_STRINGIZE(LXB_CSS_SYNTAX_VERSION_MAJOR) "." \
LEXBOR_STRINGIZE(LXB_CSS_SYNTAX_VERSION_MINOR) "." \
LEXBOR_STRINGIZE(LXB_CSS_SYNTAX_VERSION_PATCH)
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_BASE_H */

107
ext/dom/lexbor/lexbor/css/syntax/parser.h Normal file
View file

@ -0,0 +1,107 @@
/*
* Copyright (C) 2020-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_PARSER_H
#define LEXBOR_CSS_SYNTAX_PARSER_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
#include "lexbor/css/at_rule.h"
LXB_API lxb_status_t
lxb_css_syntax_parser_run(lxb_css_parser_t *parser);
LXB_API const lxb_css_syntax_token_t *
lxb_css_syntax_parser_token(lxb_css_parser_t *parser);
LXB_API const lxb_css_syntax_token_t *
lxb_css_syntax_parser_token_wo_ws(lxb_css_parser_t *parser);
LXB_API void
lxb_css_syntax_parser_consume(lxb_css_parser_t *parser);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_list_rules_push(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_list_rules_t *list_rules,
void *ctx, bool top_level,
lxb_css_syntax_token_type_t stop);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_at_rule_push(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_at_rule_t *at_rule,
void *ctx, lxb_css_syntax_token_type_t stop);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_qualified_push(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_qualified_rule_t *qualified,
void *ctx, lxb_css_syntax_token_type_t stop);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_declarations_push(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_declarations_t *declarations,
void *ctx, lxb_css_syntax_token_type_t stop);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_components_push(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_components_t *comp,
void *ctx, lxb_css_syntax_token_type_t stop);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_function_push(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_function_t *func,
void *ctx);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_block_push(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_block_t *block,
void *ctx);
LXB_API lxb_css_syntax_rule_t *
lxb_css_syntax_parser_pipe_push(lxb_css_parser_t *parser,
lxb_css_parser_state_f state_back,
const lxb_css_syntax_cb_pipe_t *pipe,
void *ctx, lxb_css_syntax_token_type_t stop);
LXB_API lxb_status_t
lxb_css_syntax_parser_tkz_cb(lxb_css_syntax_tokenizer_t *tkz,
const lxb_char_t **data, const lxb_char_t **end,
void *ctx);
LXB_API const lxb_css_syntax_token_t *
lxb_css_syntax_parser_start_block(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_syntax_rule_t *rule);
LXB_API const lxb_css_syntax_token_t *
lxb_css_syntax_parser_end(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_syntax_rule_t *rule);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_PARSER_H */

48
ext/dom/lexbor/lexbor/css/syntax/res.h Normal file
View file

@ -0,0 +1,48 @@
/*
* Copyright (C) 2018-2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_RES_H
#define LEXBOR_CSS_SYNTAX_RES_H
#ifdef LXB_CSS_SYNTAX_RES_NAME_MAP
#ifndef LXB_CSS_SYNTAX_RES_NAME_MAP_ENABLED
#define LXB_CSS_SYNTAX_RES_NAME_MAP_ENABLED
#define LXB_CSS_SYNTAX_RES_NAME_START 0x01
static const lxb_char_t lxb_css_syntax_res_name_map[256] =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01
};
#endif /* LXB_CSS_SYNTAX_RES_NAME_MAP_ENABLED */
#endif /* LXB_CSS_SYNTAX_RES_NAME_MAP */
#endif /* LEXBOR_CSS_SYNTAX_RES_H */

128
ext/dom/lexbor/lexbor/css/syntax/state.h Normal file
View file

@ -0,0 +1,128 @@
/*
* Copyright (C) 2018-2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_STATE_H
#define LEXBOR_CSS_SYNTAX_STATE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/syntax/base.h"
#include "lexbor/css/syntax/tokenizer.h"
const lxb_char_t *
lxb_css_syntax_state_delim(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_comment(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_whitespace(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_string(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_hash(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_lparenthesis(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_rparenthesis(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_plus(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_plus_process(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_comma(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_minus(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_minus_process(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_full_stop(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_colon(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_semicolon(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_less_sign(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_at(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_ls_bracket(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_rsolidus(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_rs_bracket(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_lc_bracket(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_rc_bracket(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_consume_before_numeric(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_ident_like_begin(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
const lxb_char_t *
lxb_css_syntax_state_ident_like_not_url_begin(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_STATE_H */

273
ext/dom/lexbor/lexbor/css/syntax/state_res.h Normal file
View file

@ -0,0 +1,273 @@
/*
* Copyright (C) 2018-2020 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_STATE_RES_H
#define LEXBOR_CSS_SYNTAX_STATE_RES_H
static const lxb_css_syntax_tokenizer_state_f
lxb_css_syntax_state_res_map[256] =
{
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x00; 'NUL'; NULL */
lxb_css_syntax_state_delim, /* 0x01; 'SOH'; Start of Heading */
lxb_css_syntax_state_delim, /* 0x02; 'STX'; Start of text */
lxb_css_syntax_state_delim, /* 0x03; 'ETX'; End of text */
lxb_css_syntax_state_delim, /* 0x04; 'EOT'; End of Transmission */
lxb_css_syntax_state_delim, /* 0x05; 'ENQ'; Enquiry */
lxb_css_syntax_state_delim, /* 0x06; 'ACK'; Acknowledge */
lxb_css_syntax_state_delim, /* 0x07; 'BEL'; Bell */
lxb_css_syntax_state_delim, /* 0x08; 'BS'; Backspace */
lxb_css_syntax_state_whitespace, /* 0x09; 'TAB'; Horizontal Tab */
lxb_css_syntax_state_whitespace, /* 0x0A; 'LF'; Line Feed ('\n') */
lxb_css_syntax_state_delim, /* 0x0B; 'VT'; Vertical Tab */
lxb_css_syntax_state_whitespace, /* 0x0C; 'FF'; Form Feed */
lxb_css_syntax_state_whitespace, /* 0x0D; 'CR'; Carriage Return ('\r') */
lxb_css_syntax_state_delim, /* 0x0E; 'SO'; Shift Out */
lxb_css_syntax_state_delim, /* 0x0F; 'SI'; Shift In */
lxb_css_syntax_state_delim, /* 0x10; 'DLE'; Data Link Escape */
lxb_css_syntax_state_delim, /* 0x11; 'DC1'; Device Control #1 */
lxb_css_syntax_state_delim, /* 0x12; 'DC2'; Device Control #2 */
lxb_css_syntax_state_delim, /* 0x13; 'DC3'; Device Control #3 */
lxb_css_syntax_state_delim, /* 0x14; 'DC4'; Device Control #4 */
lxb_css_syntax_state_delim, /* 0x15; 'NAK'; Negative Acknowledge */
lxb_css_syntax_state_delim, /* 0x16; 'SYN'; Synchronous Idle */
lxb_css_syntax_state_delim, /* 0x17; 'ETB'; End of Transmission Block */
lxb_css_syntax_state_delim, /* 0x18; 'CAN'; Cancel */
lxb_css_syntax_state_delim, /* 0x19; 'EM'; End of Medium */
lxb_css_syntax_state_delim, /* 0x1A; 'SUB'; Substitute */
lxb_css_syntax_state_delim, /* 0x1B; 'ESC'; Escape */
lxb_css_syntax_state_delim, /* 0x1C; 'FS'; File Separator */
lxb_css_syntax_state_delim, /* 0x1D; 'GS'; Group Separator */
lxb_css_syntax_state_delim, /* 0x1E; 'RS'; Record Separator */
lxb_css_syntax_state_delim, /* 0x1F; 'US'; Unit Separator */
lxb_css_syntax_state_whitespace, /* 0x20; 'SP'; Space */
lxb_css_syntax_state_delim, /* 0x21; '!'; Exclamation mark */
lxb_css_syntax_state_string, /* 0x22; '"'; Only quotes above */
lxb_css_syntax_state_hash, /* 0x23; '#'; Pound sign */
lxb_css_syntax_state_delim, /* 0x24; '$'; Dollar sign */
lxb_css_syntax_state_delim, /* 0x25; '%'; Percentage sign */
lxb_css_syntax_state_delim, /* 0x26; '&'; Commericial and */
lxb_css_syntax_state_string, /* 0x27; '''; Apostrophe */
lxb_css_syntax_state_lparenthesis, /* 0x28; '('; Left bracket */
lxb_css_syntax_state_rparenthesis, /* 0x29; ')'; Right bracket */
lxb_css_syntax_state_delim, /* 0x2A; '*'; Asterisk */
lxb_css_syntax_state_plus, /* 0x2B; '+'; Plus symbol */
lxb_css_syntax_state_comma, /* 0x2C; ','; Comma */
lxb_css_syntax_state_minus, /* 0x2D; '-'; Dash */
lxb_css_syntax_state_full_stop, /* 0x2E; '.'; Full stop */
lxb_css_syntax_state_comment, /* 0x2F; '/'; Forward slash */
lxb_css_syntax_state_consume_before_numeric, /* 0x30; '0' */
lxb_css_syntax_state_consume_before_numeric, /* 0x31; '1' */
lxb_css_syntax_state_consume_before_numeric, /* 0x32; '2' */
lxb_css_syntax_state_consume_before_numeric, /* 0x33; '3' */
lxb_css_syntax_state_consume_before_numeric, /* 0x34; '4' */
lxb_css_syntax_state_consume_before_numeric, /* 0x35; '5' */
lxb_css_syntax_state_consume_before_numeric, /* 0x36; '6' */
lxb_css_syntax_state_consume_before_numeric, /* 0x37; '7' */
lxb_css_syntax_state_consume_before_numeric, /* 0x38; '8' */
lxb_css_syntax_state_consume_before_numeric, /* 0x39; '9' */
lxb_css_syntax_state_colon, /* 0x3A; ':'; Colon */
lxb_css_syntax_state_semicolon, /* 0x3B; ';'; Semicolon */
lxb_css_syntax_state_less_sign, /* 0x3C; '<'; Small than bracket */
lxb_css_syntax_state_delim, /* 0x3D; '='; Equals sign */
lxb_css_syntax_state_delim, /* 0x3E; '>'; Bigger than symbol */
lxb_css_syntax_state_delim, /* 0x3F; '?'; Question mark */
lxb_css_syntax_state_at, /* 0x40; '@'; At symbol */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x41; 'A' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x42; 'B' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x43; 'C' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x44; 'D' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x45; 'E' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x46; 'F' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x47; 'G' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x48; 'H' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x49; 'I' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x4A; 'J' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x4B; 'K' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x4C; 'L' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x4D; 'M' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x4E; 'N' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x4F; 'O' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x50; 'P' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x51; 'Q' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x52; 'R' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x53; 'S' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x54; 'T' */
lxb_css_syntax_state_ident_like_begin, /* 0x55; 'U' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x56; 'V' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x57; 'W' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x58; 'X' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x59; 'Y' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x5A; 'Z' */
lxb_css_syntax_state_ls_bracket, /* 0x5B; '['; Left square bracket */
lxb_css_syntax_state_rsolidus, /* 0x5C; '\'; Inverse/backward slash */
lxb_css_syntax_state_rs_bracket, /* 0x5D; ']'; Right square bracket */
lxb_css_syntax_state_delim, /* 0x5E; '^'; Circumflex */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x5F; '_'; Underscore */
lxb_css_syntax_state_delim, /* 0x60; '`'; Gravis (backtick) */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x61; 'a' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x62; 'b' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x63; 'c' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x64; 'd' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x65; 'e' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x66; 'f' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x67; 'g' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x68; 'h' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x69; 'i' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x6A; 'j' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x6B; 'k' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x6C; 'l' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x6D; 'm' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x6E; 'n' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x6F; 'o' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x70; 'p' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x71; 'q' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x72; 'r' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x73; 's' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x74; 't' */
lxb_css_syntax_state_ident_like_begin, /* 0x75; 'u' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x76; 'v' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x77; 'w' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x78; 'x' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x79; 'y' */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x7A; 'z' */
lxb_css_syntax_state_lc_bracket, /* 0x7B; '{'; Left curly bracket */
lxb_css_syntax_state_delim, /* 0x7C; '|'; Vertical line */
lxb_css_syntax_state_rc_bracket, /* 0x7D; '}'; Right curly brackets */
lxb_css_syntax_state_delim, /* 0x7E; '~'; Tilde */
lxb_css_syntax_state_delim, /* 0x7F; 'DEL'; Delete */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x80 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x81 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x82 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x83 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x84 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x85 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x86 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x87 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x88 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x89 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x8A */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x8B */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x8C */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x8D */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x8E */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x8F */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x90 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x91 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x92 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x93 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x94 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x95 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x96 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x97 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x98 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x99 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x9A */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x9B */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x9C */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x9D */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x9E */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0x9F */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA0 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA1 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA2 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA3 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA4 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA5 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA6 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA7 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA8 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xA9 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xAA */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xAB */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xAC */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xAD */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xAE */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xAF */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB0 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB1 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB2 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB3 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB4 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB5 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB6 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB7 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB8 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xB9 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xBA */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xBB */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xBC */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xBD */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xBE */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xBF */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC0 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC1 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC2 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC3 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC4 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC5 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC6 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC7 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC8 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xC9 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xCA */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xCB */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xCC */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xCD */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xCE */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xCF */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD0 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD1 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD2 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD3 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD4 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD5 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD6 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD7 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD8 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xD9 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xDA */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xDB */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xDC */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xDD */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xDE */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xDF */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE0 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE1 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE2 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE3 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE4 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE5 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE6 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE7 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE8 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xE9 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xEA */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xEB */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xEC */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xED */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xEE */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xEF */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF0 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF1 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF2 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF3 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF4 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF5 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF6 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF7 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF8 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xF9 */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xFA */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xFB */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xFC */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xFD */
lxb_css_syntax_state_ident_like_not_url_begin, /* 0xFE */
lxb_css_syntax_state_ident_like_not_url_begin /* 0xFF */
};
#endif /* LEXBOR_CSS_SYNTAX_STATE_RES_H */

166
ext/dom/lexbor/lexbor/css/syntax/syntax.h Normal file
View file

@ -0,0 +1,166 @@
/*
* Copyright (C) 2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_H
#define LEXBOR_CSS_SYNTAX_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/syntax/tokenizer.h"
typedef struct lxb_css_syntax_rule lxb_css_syntax_rule_t;
typedef const lxb_css_syntax_token_t *
(*lxb_css_syntax_state_f)(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
lxb_css_syntax_rule_t *rule);
typedef lxb_status_t
(*lxb_css_syntax_declaration_end_f)(lxb_css_parser_t *parser, void *ctx,
bool important, bool failed);
typedef lxb_status_t
(*lxb_css_syntax_cb_done_f)(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
void *ctx, bool failed);
typedef struct {
uintptr_t begin;
uintptr_t end;
}
lxb_css_syntax_list_rules_offset_t;
typedef struct {
uintptr_t name;
uintptr_t prelude;
uintptr_t prelude_end;
uintptr_t block;
uintptr_t block_end;
}
lxb_css_syntax_at_rule_offset_t;
typedef struct {
uintptr_t prelude;
uintptr_t prelude_end;
uintptr_t block;
uintptr_t block_end;
}
lxb_css_syntax_qualified_offset_t;
typedef struct {
uintptr_t begin;
uintptr_t end;
uintptr_t name_begin;
uintptr_t name_end;
uintptr_t value_begin;
uintptr_t before_important;
uintptr_t value_end;
}
lxb_css_syntax_declarations_offset_t;
typedef struct {
lxb_css_parser_state_f state;
lxb_css_parser_state_f block;
lxb_css_parser_state_f failed;
lxb_css_syntax_cb_done_f end;
}
lxb_css_syntax_cb_base_t;
typedef lxb_css_syntax_cb_base_t lxb_css_syntax_cb_pipe_t;
typedef lxb_css_syntax_cb_base_t lxb_css_syntax_cb_block_t;
typedef lxb_css_syntax_cb_base_t lxb_css_syntax_cb_function_t;
typedef lxb_css_syntax_cb_base_t lxb_css_syntax_cb_components_t;
typedef lxb_css_syntax_cb_base_t lxb_css_syntax_cb_at_rule_t;
typedef lxb_css_syntax_cb_base_t lxb_css_syntax_cb_qualified_rule_t;
typedef struct {
lxb_css_syntax_cb_base_t cb;
lxb_css_syntax_declaration_end_f declaration_end;
const lxb_css_syntax_cb_at_rule_t *at_rule;
}
lxb_css_syntax_cb_declarations_t;
typedef struct {
lxb_css_syntax_cb_base_t cb;
lxb_css_parser_state_f next;
const lxb_css_syntax_cb_at_rule_t *at_rule;
const lxb_css_syntax_cb_qualified_rule_t *qualified_rule;
}
lxb_css_syntax_cb_list_rules_t;
struct lxb_css_syntax_rule {
lxb_css_syntax_state_f phase;
lxb_css_parser_state_f state;
lxb_css_parser_state_f state_back;
lxb_css_syntax_state_f back;
union {
const lxb_css_syntax_cb_base_t *cb;
const lxb_css_syntax_cb_list_rules_t *list_rules;
const lxb_css_syntax_cb_at_rule_t *at_rule;
const lxb_css_syntax_cb_qualified_rule_t *qualified_rule;
const lxb_css_syntax_cb_declarations_t *declarations;
const lxb_css_syntax_cb_components_t *components;
const lxb_css_syntax_cb_function_t *func;
const lxb_css_syntax_cb_block_t *block;
const lxb_css_syntax_cb_pipe_t *pipe;
void *user;
} cbx;
void *context;
uintptr_t offset;
size_t deep;
lxb_css_syntax_token_type_t block_end;
bool skip_ending;
bool skip_consume;
bool important;
bool failed;
bool top_level;
union {
lxb_css_syntax_list_rules_offset_t list_rules;
lxb_css_syntax_at_rule_offset_t at_rule;
lxb_css_syntax_qualified_offset_t qualified;
lxb_css_syntax_declarations_offset_t declarations;
void *user;
} u;
};
LXB_API lxb_status_t
lxb_css_syntax_parse_list_rules(lxb_css_parser_t *parser,
const lxb_css_syntax_cb_list_rules_t *cb,
const lxb_char_t *data, size_t length,
void *ctx, bool top_level);
LXB_API lxb_status_t
lxb_css_syntax_stack_expand(lxb_css_parser_t *parser, size_t count);
LXB_API void
lxb_css_syntax_codepoint_to_ascii(lxb_css_syntax_tokenizer_t *tkz,
lxb_codepoint_t cp);
LXB_API lxb_status_t
lxb_css_syntax_ident_serialize(const lxb_char_t *data, size_t length,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_syntax_string_serialize(const lxb_char_t *data, size_t length,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_syntax_ident_or_string_serialize(const lxb_char_t *data, size_t length,
lexbor_serialize_cb_f cb, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_H */

324
ext/dom/lexbor/lexbor/css/syntax/token.h Normal file
View file

@ -0,0 +1,324 @@
/*
* Copyright (C) 2018-2020 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_TOKEN_H
#define LEXBOR_CSS_SYNTAX_TOKEN_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/str.h"
#include "lexbor/css/log.h"
#include "lexbor/css/syntax/base.h"
#define lxb_css_syntax_token_base(token) ((lxb_css_syntax_token_base_t *) (token))
#define lxb_css_syntax_token_ident(token) ((lxb_css_syntax_token_ident_t *) (token))
#define lxb_css_syntax_token_function(token) ((lxb_css_syntax_token_function_t *) (token))
#define lxb_css_syntax_token_at_keyword(token) ((lxb_css_syntax_token_at_keyword_t *) (token))
#define lxb_css_syntax_token_hash(token) ((lxb_css_syntax_token_hash_t *) (token))
#define lxb_css_syntax_token_string(token) ((lxb_css_syntax_token_string_t *) (token))
#define lxb_css_syntax_token_bad_string(token) ((lxb_css_syntax_token_bad_string_t *) (token))
#define lxb_css_syntax_token_url(token) ((lxb_css_syntax_token_url_t *) (token))
#define lxb_css_syntax_token_bad_url(token) ((lxb_css_syntax_token_bad_url_t *) (token))
#define lxb_css_syntax_token_delim(token) ((lxb_css_syntax_token_delim_t *) (token))
#define lxb_css_syntax_token_delim_char(token) (((lxb_css_syntax_token_delim_t *) (token))->character)
#define lxb_css_syntax_token_number(token) ((lxb_css_syntax_token_number_t *) (token))
#define lxb_css_syntax_token_percentage(token) ((lxb_css_syntax_token_percentage_t *) (token))
#define lxb_css_syntax_token_dimension(token) ((lxb_css_syntax_token_dimension_t *) (token))
#define lxb_css_syntax_token_dimension_string(token) (&((lxb_css_syntax_token_dimension_t *) (token))->str)
#define lxb_css_syntax_token_whitespace(token) ((lxb_css_syntax_token_whitespace_t *) (token))
#define lxb_css_syntax_token_cdo(token) ((lxb_css_syntax_token_cdo_t *) (token))
#define lxb_css_syntax_token_cdc(token) ((lxb_css_syntax_token_cdc_t *) (token))
#define lxb_css_syntax_token_colon(token) ((lxb_css_syntax_token_colon_t *) (token))
#define lxb_css_syntax_token_semicolon(token) ((lxb_css_syntax_token_semicolon_t *) (token))
#define lxb_css_syntax_token_comma(token) ((lxb_css_syntax_token_comma_t *) (token))
#define lxb_css_syntax_token_ls_bracket(token) ((lxb_css_syntax_token_ls_bracket_t *) (token))
#define lxb_css_syntax_token_rs_bracket(token) ((lxb_css_syntax_token_rs_bracket_t *) (token))
#define lxb_css_syntax_token_l_parenthesis(token) ((lxb_css_syntax_token_l_parenthesis_t *) (token))
#define lxb_css_syntax_token_r_parenthesis(token) ((lxb_css_syntax_token_r_parenthesis_t *) (token))
#define lxb_css_syntax_token_lc_bracket(token) ((lxb_css_syntax_token_lc_bracket_t *) (token))
#define lxb_css_syntax_token_rc_bracket(token) ((lxb_css_syntax_token_rc_bracket_t *) (token))
#define lxb_css_syntax_token_comment(token) ((lxb_css_syntax_token_comment_t *) (token))
typedef struct lxb_css_syntax_token_data lxb_css_syntax_token_data_t;
typedef const lxb_char_t *
(*lxb_css_syntax_token_data_cb_f)(const lxb_char_t *begin, const lxb_char_t *end,
lexbor_str_t *str, lexbor_mraw_t *mraw,
lxb_css_syntax_token_data_t *td);
typedef lxb_status_t
(*lxb_css_syntax_token_cb_f)(const lxb_char_t *data, size_t len, void *ctx);
struct lxb_css_syntax_token_data {
lxb_css_syntax_token_data_cb_f cb;
lxb_status_t status;
int count;
uint32_t num;
bool is_last;
};
typedef enum {
LXB_CSS_SYNTAX_TOKEN_UNDEF = 0x00,
/* String tokens. */
LXB_CSS_SYNTAX_TOKEN_IDENT,
LXB_CSS_SYNTAX_TOKEN_FUNCTION,
LXB_CSS_SYNTAX_TOKEN_AT_KEYWORD,
LXB_CSS_SYNTAX_TOKEN_HASH,
LXB_CSS_SYNTAX_TOKEN_STRING,
LXB_CSS_SYNTAX_TOKEN_BAD_STRING,
LXB_CSS_SYNTAX_TOKEN_URL,
LXB_CSS_SYNTAX_TOKEN_BAD_URL,
LXB_CSS_SYNTAX_TOKEN_COMMENT, /* not in specification */
LXB_CSS_SYNTAX_TOKEN_WHITESPACE,
/* Has a string. */
LXB_CSS_SYNTAX_TOKEN_DIMENSION,
/* Other tokens. */
LXB_CSS_SYNTAX_TOKEN_DELIM,
LXB_CSS_SYNTAX_TOKEN_NUMBER,
LXB_CSS_SYNTAX_TOKEN_PERCENTAGE,
LXB_CSS_SYNTAX_TOKEN_CDO,
LXB_CSS_SYNTAX_TOKEN_CDC,
LXB_CSS_SYNTAX_TOKEN_COLON,
LXB_CSS_SYNTAX_TOKEN_SEMICOLON,
LXB_CSS_SYNTAX_TOKEN_COMMA,
LXB_CSS_SYNTAX_TOKEN_LS_BRACKET, /* U+005B LEFT SQUARE BRACKET ([) */
LXB_CSS_SYNTAX_TOKEN_RS_BRACKET, /* U+005D RIGHT SQUARE BRACKET (]) */
LXB_CSS_SYNTAX_TOKEN_L_PARENTHESIS, /* U+0028 LEFT PARENTHESIS (() */
LXB_CSS_SYNTAX_TOKEN_R_PARENTHESIS, /* U+0029 RIGHT PARENTHESIS ()) */
LXB_CSS_SYNTAX_TOKEN_LC_BRACKET, /* U+007B LEFT CURLY BRACKET ({) */
LXB_CSS_SYNTAX_TOKEN_RC_BRACKET, /* U+007D RIGHT CURLY BRACKET (}) */
LXB_CSS_SYNTAX_TOKEN__EOF,
LXB_CSS_SYNTAX_TOKEN__TERMINATED, /* Deprecated, use LXB_CSS_SYNTAX_TOKEN__END. */
LXB_CSS_SYNTAX_TOKEN__END = LXB_CSS_SYNTAX_TOKEN__TERMINATED,
LXB_CSS_SYNTAX_TOKEN__LAST_ENTRY
}
lxb_css_syntax_token_type_t;
typedef struct lxb_css_syntax_token_base {
const lxb_char_t *begin;
size_t length;
uintptr_t user_id;
}
lxb_css_syntax_token_base_t;
typedef struct lxb_css_syntax_token_number {
lxb_css_syntax_token_base_t base;
double num;
bool is_float;
bool have_sign;
}
lxb_css_syntax_token_number_t;
typedef struct lxb_css_syntax_token_string {
lxb_css_syntax_token_base_t base;
const lxb_char_t *data;
size_t length;
}
lxb_css_syntax_token_string_t;
typedef struct lxb_css_syntax_token_dimension {
lxb_css_syntax_token_number_t num;
lxb_css_syntax_token_string_t str;
}
lxb_css_syntax_token_dimension_t;
typedef struct lxb_css_syntax_token_delim {
lxb_css_syntax_token_base_t base;
lxb_char_t character;
}
lxb_css_syntax_token_delim_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_ident_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_function_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_at_keyword_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_hash_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_bad_string_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_url_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_bad_url_t;
typedef lxb_css_syntax_token_number_t lxb_css_syntax_token_percentage_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_whitespace_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_cdo_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_cdc_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_colon_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_semicolon_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_comma_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_ls_bracket_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_rs_bracket_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_l_parenthesis_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_r_parenthesis_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_lc_bracket_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_rc_bracket_t;
typedef lxb_css_syntax_token_string_t lxb_css_syntax_token_comment_t;
typedef lxb_css_syntax_token_base_t lxb_css_syntax_token_terminated_t;
struct lxb_css_syntax_token {
union lxb_css_syntax_token_u {
lxb_css_syntax_token_base_t base;
lxb_css_syntax_token_comment_t comment;
lxb_css_syntax_token_number_t number;
lxb_css_syntax_token_dimension_t dimension;
lxb_css_syntax_token_percentage_t percentage;
lxb_css_syntax_token_hash_t hash;
lxb_css_syntax_token_string_t string;
lxb_css_syntax_token_bad_string_t bad_string;
lxb_css_syntax_token_delim_t delim;
lxb_css_syntax_token_l_parenthesis_t lparenthesis;
lxb_css_syntax_token_r_parenthesis_t rparenthesis;
lxb_css_syntax_token_cdc_t cdc;
lxb_css_syntax_token_function_t function;
lxb_css_syntax_token_ident_t ident;
lxb_css_syntax_token_url_t url;
lxb_css_syntax_token_bad_url_t bad_url;
lxb_css_syntax_token_at_keyword_t at_keyword;
lxb_css_syntax_token_whitespace_t whitespace;
lxb_css_syntax_token_terminated_t terminated;
}
types;
lxb_css_syntax_token_type_t type;
uintptr_t offset;
bool cloned;
};
LXB_API lxb_css_syntax_token_t *
lxb_css_syntax_token(lxb_css_syntax_tokenizer_t *tkz);
LXB_API lxb_css_syntax_token_t *
lxb_css_syntax_token_next(lxb_css_syntax_tokenizer_t *tkz);
LXB_API void
lxb_css_syntax_token_consume(lxb_css_syntax_tokenizer_t *tkz);
LXB_API void
lxb_css_syntax_token_consume_n(lxb_css_syntax_tokenizer_t *tkz, unsigned count);
LXB_API lxb_status_t
lxb_css_syntax_token_string_dup(lxb_css_syntax_token_string_t *token,
lexbor_str_t *str, lexbor_mraw_t *mraw);
LXB_API lxb_status_t
lxb_css_syntax_token_string_make(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token);
LXB_API lxb_css_syntax_token_t *
lxb_css_syntax_token_cached_create(lxb_css_syntax_tokenizer_t *tkz);
LXB_API void
lxb_css_syntax_token_string_free(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token);
LXB_API const lxb_char_t *
lxb_css_syntax_token_type_name_by_id(lxb_css_syntax_token_type_t type);
LXB_API lxb_css_syntax_token_type_t
lxb_css_syntax_token_type_id_by_name(const lxb_char_t *type_name, size_t len);
LXB_API lxb_status_t
lxb_css_syntax_token_serialize(const lxb_css_syntax_token_t *token,
lxb_css_syntax_token_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_syntax_token_serialize_str(const lxb_css_syntax_token_t *token,
lexbor_str_t *str, lexbor_mraw_t *mraw);
LXB_API lxb_char_t *
lxb_css_syntax_token_serialize_char(const lxb_css_syntax_token_t *token,
size_t *out_length);
LXB_API lxb_css_log_message_t *
lxb_css_syntax_token_error(lxb_css_parser_t *parser,
const lxb_css_syntax_token_t *token,
const char *module_name);
/*
* Inline functions
*/
lxb_inline lxb_css_syntax_token_t *
lxb_css_syntax_token_create(lexbor_dobject_t *dobj)
{
return (lxb_css_syntax_token_t *) lexbor_dobject_calloc(dobj);
}
lxb_inline void
lxb_css_syntax_token_clean(lxb_css_syntax_token_t *token)
{
memset(token, 0, sizeof(lxb_css_syntax_token_t));
}
lxb_inline lxb_css_syntax_token_t *
lxb_css_syntax_token_destroy(lxb_css_syntax_token_t *token,
lexbor_dobject_t *dobj)
{
return (lxb_css_syntax_token_t *) lexbor_dobject_free(dobj, token);
}
lxb_inline const lxb_char_t *
lxb_css_syntax_token_type_name(const lxb_css_syntax_token_t *token)
{
return lxb_css_syntax_token_type_name_by_id(token->type);
}
lxb_inline lxb_css_syntax_token_type_t
lxb_css_syntax_token_type(const lxb_css_syntax_token_t *token)
{
return token->type;
}
lxb_inline lxb_css_syntax_token_t *
lxb_css_syntax_token_wo_ws(lxb_css_syntax_tokenizer_t *tkz)
{
lxb_css_syntax_token_t *token;
token = lxb_css_syntax_token(tkz);
if (token == NULL) {
return NULL;
}
if (token->type == LXB_CSS_SYNTAX_TOKEN_WHITESPACE) {
lxb_css_syntax_token_consume(tkz);
token = lxb_css_syntax_token(tkz);
}
return token;
}
/*
* No inline functions for ABI.
*/
LXB_API lxb_css_syntax_token_t *
lxb_css_syntax_token_create_noi(lexbor_dobject_t *dobj);
LXB_API void
lxb_css_syntax_token_clean_noi(lxb_css_syntax_token_t *token);
LXB_API lxb_css_syntax_token_t *
lxb_css_syntax_token_destroy_noi(lxb_css_syntax_token_t *token,
lexbor_dobject_t *dobj);
LXB_API const lxb_char_t *
lxb_css_syntax_token_type_name_noi(lxb_css_syntax_token_t *token);
LXB_API lxb_css_syntax_token_type_t
lxb_css_syntax_token_type_noi(lxb_css_syntax_token_t *token);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_TOKEN_H */

68
ext/dom/lexbor/lexbor/css/syntax/token_res.h Normal file
View file

@ -0,0 +1,68 @@
/*
* Copyright (C) 2018-2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_TOKEN_RES_H
#define LEXBOR_CSS_SYNTAX_TOKEN_RES_H
#ifdef LXB_CSS_SYNTAX_TOKEN_RES_NAME_SHS_MAP
#ifndef LXB_CSS_SYNTAX_TOKEN_RES_NAME_SHS_MAP_ENABLED
#define LXB_CSS_SYNTAX_TOKEN_RES_NAME_SHS_MAP_ENABLED
static const lexbor_shs_entry_t lxb_css_syntax_token_res_name_shs_map[] =
{
{NULL, NULL, 92, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"end-of-file", (void *) LXB_CSS_SYNTAX_TOKEN__EOF, 11, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{"ident", (void *) LXB_CSS_SYNTAX_TOKEN_IDENT, 5, 0}, {"cdo", (void *) LXB_CSS_SYNTAX_TOKEN_CDO, 3, 0},
{NULL, NULL, 0, 0}, {"left-parenthesis", (void *) LXB_CSS_SYNTAX_TOKEN_L_PARENTHESIS, 16, 0},
{"right-parenthesis", (void *) LXB_CSS_SYNTAX_TOKEN_R_PARENTHESIS, 17, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"percentage", (void *) LXB_CSS_SYNTAX_TOKEN_PERCENTAGE, 10, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"at-keyword", (void *) LXB_CSS_SYNTAX_TOKEN_AT_KEYWORD, 10, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{"string", (void *) LXB_CSS_SYNTAX_TOKEN_STRING, 6, 0}, {NULL, NULL, 0, 0},
{"bad-url", (void *) LXB_CSS_SYNTAX_TOKEN_BAD_URL, 7, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"bad-string", (void *) LXB_CSS_SYNTAX_TOKEN_BAD_STRING, 10, 0},
{"whitespace", (void *) LXB_CSS_SYNTAX_TOKEN_WHITESPACE, 10, 0}, {NULL, NULL, 0, 0},
{"undefined", (void *) LXB_CSS_SYNTAX_TOKEN_UNDEF, 9, 0}, {NULL, NULL, 0, 0},
{"right-curly-bracket", (void *) LXB_CSS_SYNTAX_TOKEN_RC_BRACKET, 19, 0}, {"right-square-bracket", (void *) LXB_CSS_SYNTAX_TOKEN_RS_BRACKET, 20, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"number", (void *) LXB_CSS_SYNTAX_TOKEN_NUMBER, 6, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{"semicolon", (void *) LXB_CSS_SYNTAX_TOKEN_SEMICOLON, 9, 0}, {NULL, NULL, 0, 0},
{"dimension", (void *) LXB_CSS_SYNTAX_TOKEN_DIMENSION, 9, 0}, {NULL, NULL, 0, 0},
{"colon", (void *) LXB_CSS_SYNTAX_TOKEN_COLON, 5, 0}, {"function", (void *) LXB_CSS_SYNTAX_TOKEN_FUNCTION, 8, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"comma", (void *) LXB_CSS_SYNTAX_TOKEN_COMMA, 5, 0},
{"url", (void *) LXB_CSS_SYNTAX_TOKEN_URL, 3, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"cdc", (void *) LXB_CSS_SYNTAX_TOKEN_CDC, 3, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"hash", (void *) LXB_CSS_SYNTAX_TOKEN_HASH, 4, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{"comment", (void *) LXB_CSS_SYNTAX_TOKEN_COMMENT, 7, 0}, {NULL, NULL, 0, 0},
{"delim", (void *) LXB_CSS_SYNTAX_TOKEN_DELIM, 5, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}, {"left-curly-bracket", (void *) LXB_CSS_SYNTAX_TOKEN_LC_BRACKET, 18, 0},
{"left-square-bracket", (void *) LXB_CSS_SYNTAX_TOKEN_LS_BRACKET, 19, 0}
};
#endif /* LXB_CSS_SYNTAX_TOKEN_RES_NAME_SHS_MAP_ENABLED */
#endif /* LXB_CSS_SYNTAX_TOKEN_RES_NAME_SHS_MAP */
#endif /* LEXBOR_CSS_SYNTAX_TOKEN_RES_H */

144
ext/dom/lexbor/lexbor/css/syntax/tokenizer.h Executable file
View file

@ -0,0 +1,144 @@
/*
* Copyright (C) 2018-2020 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_TOKENIZER_H
#define LEXBOR_CSS_SYNTAX_TOKENIZER_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/array_obj.h"
#include "lexbor/css/syntax/base.h"
#include "lexbor/css/syntax/token.h"
/* State */
typedef const lxb_char_t *
(*lxb_css_syntax_tokenizer_state_f)(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_t *token,
const lxb_char_t *data, const lxb_char_t *end);
typedef lxb_status_t
(*lxb_css_syntax_tokenizer_chunk_f)(lxb_css_syntax_tokenizer_t *tkz,
const lxb_char_t **data,
const lxb_char_t **end, void *ctx);
enum lxb_css_syntax_tokenizer_opt {
LXB_CSS_SYNTAX_TOKENIZER_OPT_UNDEF = 0x00,
};
typedef struct {
lxb_css_syntax_token_t **list;
size_t size;
size_t length;
}
lxb_css_syntax_tokenizer_cache_t;
struct lxb_css_syntax_tokenizer {
lxb_css_syntax_tokenizer_cache_t *cache;
lexbor_dobject_t *tokens;
lexbor_array_obj_t *parse_errors;
const lxb_char_t *in_begin;
const lxb_char_t *in_end;
const lxb_char_t *begin;
uintptr_t offset;
size_t cache_pos;
size_t prepared;
lexbor_mraw_t *mraw;
lxb_css_syntax_tokenizer_chunk_f chunk_cb;
void *chunk_ctx;
/* Temp */
lxb_char_t *start;
lxb_char_t *pos;
const lxb_char_t *end;
lxb_char_t buffer[128];
lxb_css_syntax_token_data_t token_data;
/* Process */
unsigned int opt; /* bitmap */
lxb_status_t status;
bool eof;
bool with_comment;
};
LXB_API lxb_css_syntax_tokenizer_t *
lxb_css_syntax_tokenizer_create(void);
LXB_API lxb_status_t
lxb_css_syntax_tokenizer_init(lxb_css_syntax_tokenizer_t *tkz);
LXB_API lxb_status_t
lxb_css_syntax_tokenizer_clean(lxb_css_syntax_tokenizer_t *tkz);
LXB_API lxb_css_syntax_tokenizer_t *
lxb_css_syntax_tokenizer_destroy(lxb_css_syntax_tokenizer_t *tkz);
LXB_API lxb_status_t
lxb_css_syntax_tokenizer_next_chunk(lxb_css_syntax_tokenizer_t *tkz,
const lxb_char_t **data, const lxb_char_t **end);
LXB_API bool
lxb_css_syntax_tokenizer_lookup_colon(lxb_css_syntax_tokenizer_t *tkz);
LXB_API bool
lxb_css_syntax_tokenizer_lookup_important(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_type_t stop,
const lxb_char_t stop_ch);
LXB_API bool
lxb_css_syntax_tokenizer_lookup_declaration_ws_end(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_token_type_t stop,
const lxb_char_t stop_ch);
/*
* Inline functions
*/
lxb_inline lxb_status_t
lxb_css_syntax_tokenizer_status(lxb_css_syntax_tokenizer_t *tkz)
{
return tkz->status;
}
lxb_inline void
lxb_css_syntax_tokenizer_chunk_cb_set(lxb_css_syntax_tokenizer_t *tkz,
lxb_css_syntax_tokenizer_chunk_f cb,
void *ctx)
{
tkz->chunk_cb = cb;
tkz->chunk_ctx = ctx;
}
lxb_inline void
lxb_css_syntax_tokenizer_buffer_set(lxb_css_syntax_tokenizer_t *tkz,
const lxb_char_t *data, size_t size)
{
tkz->in_begin = data;
tkz->in_end = data + size;
}
/*
* No inline functions for ABI.
*/
LXB_API lxb_status_t
lxb_css_syntax_tokenizer_status_noi(lxb_css_syntax_tokenizer_t *tkz);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_TOKENIZER_H */

58
ext/dom/lexbor/lexbor/css/syntax/tokenizer/error.h Executable file
View file

@ -0,0 +1,58 @@
/*
* Copyright (C) 2018-2019 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_CSS_SYNTAX_TOKENIZER_ERROR_H
#define LEXBOR_CSS_SYNTAX_TOKENIZER_ERROR_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/core/array_obj.h"
typedef enum {
/* unexpected-eof */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_UNEOF = 0x0000,
/* eof-in-comment */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_EOINCO,
/* eof-in-string */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_EOINST,
/* eof-in-url */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_EOINUR,
/* qo-in-url */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_QOINUR,
/* wrong-escape-in-url */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_WRESINUR,
/* newline-in-string */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_NEINST,
/* bad-char */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_BACH,
/* bad-code-point */
LXB_CSS_SYNTAX_TOKENIZER_ERROR_BACOPO,
}
lxb_css_syntax_tokenizer_error_id_t;
typedef struct {
const lxb_char_t *pos;
lxb_css_syntax_tokenizer_error_id_t id;
}
lxb_css_syntax_tokenizer_error_t;
LXB_API lxb_css_syntax_tokenizer_error_t *
lxb_css_syntax_tokenizer_error_add(lexbor_array_obj_t *parse_errors,
const lxb_char_t *pos,
lxb_css_syntax_tokenizer_error_id_t id);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_CSS_SYNTAX_TOKENIZER_ERROR_H */

46
ext/dom/lexbor/lexbor/css/unit.h Normal file
View file

@ -0,0 +1,46 @@
/*
* Copyright (C) 2021 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_UNIT_H
#define LXB_CSS_UNIT_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
LXB_API const lxb_css_data_t *
lxb_css_unit_absolute_relative_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_data_t *
lxb_css_unit_absolute_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_data_t *
lxb_css_unit_relative_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_data_t *
lxb_css_unit_angel_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_data_t *
lxb_css_unit_frequency_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_data_t *
lxb_css_unit_resolution_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_data_t *
lxb_css_unit_duration_by_name(const lxb_char_t *name, size_t length);
LXB_API const lxb_css_data_t *
lxb_css_unit_by_id(lxb_css_type_t id);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_UNIT_H */

98
ext/dom/lexbor/lexbor/css/unit/const.h Normal file
View file

@ -0,0 +1,98 @@
/*
* Copyright (C) 2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/names.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_UNIT_CONST_H
#define LXB_CSS_UNIT_CONST_H
#include "lexbor/css/value/const.h"
typedef enum {
LXB_CSS_UNIT__UNDEF = 0x0000,
LXB_CSS_UNIT__LAST_ENTRY = 0x0022
}
lxb_css_unit_t;
typedef enum {
LXB_CSS_UNIT_ABSOLUTE__BEGIN = 0x0001,
LXB_CSS_UNIT_Q = 0x0001,
LXB_CSS_UNIT_CM = 0x0002,
LXB_CSS_UNIT_IN = 0x0003,
LXB_CSS_UNIT_MM = 0x0004,
LXB_CSS_UNIT_PC = 0x0005,
LXB_CSS_UNIT_PT = 0x0006,
LXB_CSS_UNIT_PX = 0x0007,
LXB_CSS_UNIT_ABSOLUTE__LAST_ENTRY = 0x0008
}
lxb_css_unit_absolute_t;
typedef enum {
LXB_CSS_UNIT_RELATIVE__BEGIN = 0x0008,
LXB_CSS_UNIT_CAP = 0x0008,
LXB_CSS_UNIT_CH = 0x0009,
LXB_CSS_UNIT_EM = 0x000a,
LXB_CSS_UNIT_EX = 0x000b,
LXB_CSS_UNIT_IC = 0x000c,
LXB_CSS_UNIT_LH = 0x000d,
LXB_CSS_UNIT_REM = 0x000e,
LXB_CSS_UNIT_RLH = 0x000f,
LXB_CSS_UNIT_VB = 0x0010,
LXB_CSS_UNIT_VH = 0x0011,
LXB_CSS_UNIT_VI = 0x0012,
LXB_CSS_UNIT_VMAX = 0x0013,
LXB_CSS_UNIT_VMIN = 0x0014,
LXB_CSS_UNIT_VW = 0x0015,
LXB_CSS_UNIT_RELATIVE__LAST_ENTRY = 0x0016
}
lxb_css_unit_relative_t;
typedef enum {
LXB_CSS_UNIT_ANGEL__BEGIN = 0x0016,
LXB_CSS_UNIT_DEG = 0x0016,
LXB_CSS_UNIT_GRAD = 0x0017,
LXB_CSS_UNIT_RAD = 0x0018,
LXB_CSS_UNIT_TURN = 0x0019,
LXB_CSS_UNIT_ANGEL__LAST_ENTRY = 0x001a
}
lxb_css_unit_angel_t;
typedef enum {
LXB_CSS_UNIT_FREQUENCY__BEGIN = 0x001a,
LXB_CSS_UNIT_HZ = 0x001a,
LXB_CSS_UNIT_KHZ = 0x001b,
LXB_CSS_UNIT_FREQUENCY__LAST_ENTRY = 0x001c
}
lxb_css_unit_frequency_t;
typedef enum {
LXB_CSS_UNIT_RESOLUTION__BEGIN = 0x001c,
LXB_CSS_UNIT_DPCM = 0x001c,
LXB_CSS_UNIT_DPI = 0x001d,
LXB_CSS_UNIT_DPPX = 0x001e,
LXB_CSS_UNIT_X = 0x001f,
LXB_CSS_UNIT_RESOLUTION__LAST_ENTRY = 0x0020
}
lxb_css_unit_resolution_t;
typedef enum {
LXB_CSS_UNIT_DURATION__BEGIN = 0x0020,
LXB_CSS_UNIT_MS = 0x0020,
LXB_CSS_UNIT_S = 0x0021,
LXB_CSS_UNIT_DURATION__LAST_ENTRY = 0x0022
}
lxb_css_unit_duration_t;
#endif /* LXB_CSS_UNIT_CONST_H */

294
ext/dom/lexbor/lexbor/css/unit/res.h Normal file
View file

@ -0,0 +1,294 @@
/*
* Copyright (C) 2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/names.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_UNIT_RES_H
#define LXB_CSS_UNIT_RES_H
#include "lexbor/core/shs.h"
#include "lexbor/css/unit/const.h"
static const lxb_css_data_t lxb_css_unit_data[LXB_CSS_UNIT__LAST_ENTRY] =
{
{(lxb_char_t *) "#undef", 6, LXB_CSS_UNIT__UNDEF},
{(lxb_char_t *) "Q", 1, LXB_CSS_UNIT_Q},
{(lxb_char_t *) "cm", 2, LXB_CSS_UNIT_CM},
{(lxb_char_t *) "in", 2, LXB_CSS_UNIT_IN},
{(lxb_char_t *) "mm", 2, LXB_CSS_UNIT_MM},
{(lxb_char_t *) "pc", 2, LXB_CSS_UNIT_PC},
{(lxb_char_t *) "pt", 2, LXB_CSS_UNIT_PT},
{(lxb_char_t *) "px", 2, LXB_CSS_UNIT_PX},
{(lxb_char_t *) "cap", 3, LXB_CSS_UNIT_CAP},
{(lxb_char_t *) "ch", 2, LXB_CSS_UNIT_CH},
{(lxb_char_t *) "em", 2, LXB_CSS_UNIT_EM},
{(lxb_char_t *) "ex", 2, LXB_CSS_UNIT_EX},
{(lxb_char_t *) "ic", 2, LXB_CSS_UNIT_IC},
{(lxb_char_t *) "lh", 2, LXB_CSS_UNIT_LH},
{(lxb_char_t *) "rem", 3, LXB_CSS_UNIT_REM},
{(lxb_char_t *) "rlh", 3, LXB_CSS_UNIT_RLH},
{(lxb_char_t *) "vb", 2, LXB_CSS_UNIT_VB},
{(lxb_char_t *) "vh", 2, LXB_CSS_UNIT_VH},
{(lxb_char_t *) "vi", 2, LXB_CSS_UNIT_VI},
{(lxb_char_t *) "vmax", 4, LXB_CSS_UNIT_VMAX},
{(lxb_char_t *) "vmin", 4, LXB_CSS_UNIT_VMIN},
{(lxb_char_t *) "vw", 2, LXB_CSS_UNIT_VW},
{(lxb_char_t *) "deg", 3, LXB_CSS_UNIT_DEG},
{(lxb_char_t *) "grad", 4, LXB_CSS_UNIT_GRAD},
{(lxb_char_t *) "rad", 3, LXB_CSS_UNIT_RAD},
{(lxb_char_t *) "turn", 4, LXB_CSS_UNIT_TURN},
{(lxb_char_t *) "Hz", 2, LXB_CSS_UNIT_HZ},
{(lxb_char_t *) "kHz", 3, LXB_CSS_UNIT_KHZ},
{(lxb_char_t *) "dpcm", 4, LXB_CSS_UNIT_DPCM},
{(lxb_char_t *) "dpi", 3, LXB_CSS_UNIT_DPI},
{(lxb_char_t *) "dppx", 4, LXB_CSS_UNIT_DPPX},
{(lxb_char_t *) "x", 1, LXB_CSS_UNIT_X},
{(lxb_char_t *) "ms", 2, LXB_CSS_UNIT_MS},
{(lxb_char_t *) "s", 1, LXB_CSS_UNIT_S}
};
static const lexbor_shs_entry_t lxb_css_unit_absolute_relative_shs[84] =
{
{NULL, NULL, 83, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"rem", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_REM], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"vmax", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VMAX], 4, 0},
{"pc", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_PC], 2, 0},
{"lh", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_LH], 2, 0},
{NULL, NULL, 0, 0},
{"rlh", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_RLH], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"cm", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_CM], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"q", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_Q], 1, 0},
{"ic", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_IC], 2, 0},
{NULL, NULL, 0, 0},
{"vw", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VW], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"pt", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_PT], 2, 0},
{"vb", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VB], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"ex", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_EX], 2, 0},
{"in", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_IN], 2, 0},
{"cap", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_CAP], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"em", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_EM], 2, 0},
{NULL, NULL, 0, 0},
{"vmin", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VMIN], 4, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"vi", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VI], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"mm", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_MM], 2, 0},
{"ch", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_CH], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"px", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_PX], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"vh", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VH], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_unit_absolute_shs[30] =
{
{NULL, NULL, 29, 0},
{NULL, NULL, 0, 0},
{"in", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_IN], 2, 0},
{"pt", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_PT], 2, 0},
{"q", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_Q], 1, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"mm", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_MM], 2, 0},
{"px", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_PX], 2, 0},
{"cm", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_CM], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"pc", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_PC], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_unit_relative_shs[64] =
{
{NULL, NULL, 63, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"ic", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_IC], 2, 0},
{"cap", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_CAP], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"rem", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_REM], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"em", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_EM], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"ch", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_CH], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"ex", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_EX], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"vb", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VB], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"vh", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VH], 2, 0},
{"vi", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VI], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"rlh", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_RLH], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"vmin", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VMIN], 4, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"lh", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_LH], 2, 0},
{NULL, NULL, 0, 0},
{"vw", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VW], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"vmax", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_VMAX], 4, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_unit_angel_shs[7] =
{
{NULL, NULL, 6, 0},
{"turn", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_TURN], 4, 0},
{"deg", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_DEG], 3, 0},
{"grad", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_GRAD], 4, 0},
{"rad", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_RAD], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_unit_frequency_shs[6] =
{
{NULL, NULL, 5, 0},
{NULL, NULL, 0, 0},
{"khz", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_KHZ], 3, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0},
{"hz", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_HZ], 2, 0}
};
static const lexbor_shs_entry_t lxb_css_unit_resolution_shs[7] =
{
{NULL, NULL, 6, 0},
{NULL, NULL, 0, 0},
{"x", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_X], 1, 0},
{"dpcm", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_DPCM], 4, 0},
{"dpi", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_DPI], 3, 0},
{"dppx", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_DPPX], 4, 0},
{NULL, NULL, 0, 0}
};
static const lexbor_shs_entry_t lxb_css_unit_duration_shs[6] =
{
{NULL, NULL, 5, 0},
{NULL, NULL, 0, 0},
{"s", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_S], 1, 0},
{"ms", (void *) &lxb_css_unit_data[LXB_CSS_UNIT_MS], 2, 0},
{NULL, NULL, 0, 0},
{NULL, NULL, 0, 0}
};
#endif /* LXB_CSS_UNIT_RES_H */

290
ext/dom/lexbor/lexbor/css/value.h Normal file
View file

@ -0,0 +1,290 @@
/*
* Copyright (C) 2022-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_CSS_VALUE_H
#define LXB_CSS_VALUE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/css/base.h"
#include "lexbor/css/value/const.h"
#include "lexbor/css/unit/const.h"
typedef struct {
double num;
bool is_float;
}
lxb_css_value_number_t;
typedef struct {
long num;
}
lxb_css_value_integer_t;
typedef lxb_css_value_number_t lxb_css_value_percentage_t;
typedef struct {
double num;
bool is_float;
lxb_css_unit_t unit;
}
lxb_css_value_length_t;
typedef struct {
lxb_css_value_type_t type;
union {
lxb_css_value_length_t length;
lxb_css_value_percentage_t percentage;
} u;
}
lxb_css_value_length_percentage_t;
typedef struct {
lxb_css_value_type_t type;
union {
lxb_css_value_number_t number;
lxb_css_value_length_t length;
lxb_css_value_percentage_t percentage;
} u;
}
lxb_css_value_number_length_percentage_t;
typedef struct {
lxb_css_value_type_t type;
union {
lxb_css_value_number_t number;
lxb_css_value_length_t length;
} u;
}
lxb_css_value_number_length_t;
typedef struct {
lxb_css_value_type_t type;
union {
lxb_css_value_number_t number;
lxb_css_value_percentage_t percentage;
} u;
}
lxb_css_value_number_percentage_t;
typedef struct {
lxb_css_value_type_t type;
lxb_css_value_number_t number;
}
lxb_css_value_number_type_t;
typedef struct {
lxb_css_value_type_t type;
lxb_css_value_integer_t integer;
}
lxb_css_value_integer_type_t;
typedef struct {
lxb_css_value_type_t type;
lxb_css_value_percentage_t percentage;
}
lxb_css_value_percentage_type_t;
typedef struct {
lxb_css_value_type_t type;
lxb_css_value_length_t length;
}
lxb_css_value_length_type_t;
typedef struct {
lxb_css_value_type_t type;
lxb_css_value_length_percentage_t length;
}
lxb_css_value_length_percentage_type_t;
typedef struct {
double num;
bool is_float;
lxb_css_unit_angel_t unit;
}
lxb_css_value_angle_t;
typedef struct {
lxb_css_value_type_t type;
lxb_css_value_angle_t angle;
}
lxb_css_value_angle_type_t;
typedef struct {
lxb_css_value_type_t type;
union {
lxb_css_value_number_t number;
lxb_css_value_angle_t angle;
} u;
}
lxb_css_value_hue_t;
typedef struct {
uint8_t r;
uint8_t g;
uint8_t b;
uint8_t a;
}
lxb_css_value_color_hex_rgba_t;
typedef enum {
LXB_CSS_PROPERTY_COLOR_HEX_TYPE_3 = 0x00,
LXB_CSS_PROPERTY_COLOR_HEX_TYPE_4,
LXB_CSS_PROPERTY_COLOR_HEX_TYPE_6,
LXB_CSS_PROPERTY_COLOR_HEX_TYPE_8
}
lxb_css_value_color_hex_type_t;
typedef struct {
lxb_css_value_color_hex_rgba_t rgba;
lxb_css_value_color_hex_type_t type;
}
lxb_css_value_color_hex_t;
typedef struct {
/*
* If R is <percent> when G and B should be <percent> to.
* If R is <number> when G and B should be <number> to.
* R, G, B can be NONE regardless of neighboring values.
* 'A' can be <percentage> or <number> or NONE.
*/
lxb_css_value_number_percentage_t r;
lxb_css_value_number_percentage_t g;
lxb_css_value_number_percentage_t b;
lxb_css_value_number_percentage_t a;
bool old;
}
lxb_css_value_color_rgba_t;
typedef struct {
lxb_css_value_hue_t h;
lxb_css_value_percentage_type_t s;
lxb_css_value_percentage_type_t l;
lxb_css_value_number_percentage_t a;
bool old;
}
lxb_css_value_color_hsla_t;
typedef struct {
lxb_css_value_number_percentage_t l;
lxb_css_value_number_percentage_t a;
lxb_css_value_number_percentage_t b;
lxb_css_value_number_percentage_t alpha;
}
lxb_css_value_color_lab_t;
typedef struct {
lxb_css_value_number_percentage_t l;
lxb_css_value_number_percentage_t c;
lxb_css_value_hue_t h;
lxb_css_value_number_percentage_t a;
}
lxb_css_value_color_lch_t;
typedef struct {
lxb_css_value_type_t type;
union {
lxb_css_value_color_hex_t hex;
lxb_css_value_color_rgba_t rgb;
lxb_css_value_color_hsla_t hsl;
lxb_css_value_color_hsla_t hwb;
lxb_css_value_color_lab_t lab;
lxb_css_value_color_lch_t lch;
} u;
}
lxb_css_value_color_t;
LXB_API const lxb_css_data_t *
lxb_css_value_by_id(uintptr_t id);
LXB_API lxb_css_value_type_t
lxb_css_value_by_name(const lxb_char_t *name, size_t length);
LXB_API lxb_status_t
lxb_css_value_serialize(lxb_css_value_type_t type,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_percentage_sr(const lxb_css_value_percentage_t *percent,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_length_sr(const lxb_css_value_length_t *len,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_number_sr(const lxb_css_value_number_t *number,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_integer_sr(const lxb_css_value_integer_t *integer,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_length_percentage_sr(const lxb_css_value_length_percentage_t *lp,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_number_length_sr(const lxb_css_value_number_length_t *nl,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_number_percentage_sr(const lxb_css_value_number_percentage_t *np,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_length_type_sr(const lxb_css_value_length_type_t *lt,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_percentage_type_sr(const lxb_css_value_percentage_type_t *pt,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_number_type_sr(const lxb_css_value_number_type_t *num,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_integer_type_sr(const lxb_css_value_integer_type_t *num,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_length_percentage_type_sr(const lxb_css_value_length_percentage_type_t *lpt,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_number_length_percentage_type_sr(const lxb_css_value_number_length_percentage_t *nlp,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_angle_sr(const lxb_css_value_angle_t *angle,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_hue_sr(const lxb_css_value_hue_t *hue,
lexbor_serialize_cb_f cb, void *ctx);
LXB_API lxb_status_t
lxb_css_value_color_serialize(const lxb_css_value_color_t *color,
lexbor_serialize_cb_f cb, void *ctx);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LXB_CSS_VALUE_H */

397
ext/dom/lexbor/lexbor/css/value/const.h Normal file
View file

@ -0,0 +1,397 @@
/*
* Copyright (C) 2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/names.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_VALUE_CONST_H
#define LXB_CSS_VALUE_CONST_H
enum {
LXB_CSS_VALUE__UNDEF = 0x0000,
LXB_CSS_VALUE_INITIAL = 0x0001,
LXB_CSS_VALUE_INHERIT = 0x0002,
LXB_CSS_VALUE_UNSET = 0x0003,
LXB_CSS_VALUE_REVERT = 0x0004,
LXB_CSS_VALUE_FLEX_START = 0x0005,
LXB_CSS_VALUE_FLEX_END = 0x0006,
LXB_CSS_VALUE_CENTER = 0x0007,
LXB_CSS_VALUE_SPACE_BETWEEN = 0x0008,
LXB_CSS_VALUE_SPACE_AROUND = 0x0009,
LXB_CSS_VALUE_STRETCH = 0x000a,
LXB_CSS_VALUE_BASELINE = 0x000b,
LXB_CSS_VALUE_AUTO = 0x000c,
LXB_CSS_VALUE_TEXT_BOTTOM = 0x000d,
LXB_CSS_VALUE_ALPHABETIC = 0x000e,
LXB_CSS_VALUE_IDEOGRAPHIC = 0x000f,
LXB_CSS_VALUE_MIDDLE = 0x0010,
LXB_CSS_VALUE_CENTRAL = 0x0011,
LXB_CSS_VALUE_MATHEMATICAL = 0x0012,
LXB_CSS_VALUE_TEXT_TOP = 0x0013,
LXB_CSS_VALUE__LENGTH = 0x0014,
LXB_CSS_VALUE__PERCENTAGE = 0x0015,
LXB_CSS_VALUE_SUB = 0x0016,
LXB_CSS_VALUE_SUPER = 0x0017,
LXB_CSS_VALUE_TOP = 0x0018,
LXB_CSS_VALUE_BOTTOM = 0x0019,
LXB_CSS_VALUE_FIRST = 0x001a,
LXB_CSS_VALUE_LAST = 0x001b,
LXB_CSS_VALUE_THIN = 0x001c,
LXB_CSS_VALUE_MEDIUM = 0x001d,
LXB_CSS_VALUE_THICK = 0x001e,
LXB_CSS_VALUE_NONE = 0x001f,
LXB_CSS_VALUE_HIDDEN = 0x0020,
LXB_CSS_VALUE_DOTTED = 0x0021,
LXB_CSS_VALUE_DASHED = 0x0022,
LXB_CSS_VALUE_SOLID = 0x0023,
LXB_CSS_VALUE_DOUBLE = 0x0024,
LXB_CSS_VALUE_GROOVE = 0x0025,
LXB_CSS_VALUE_RIDGE = 0x0026,
LXB_CSS_VALUE_INSET = 0x0027,
LXB_CSS_VALUE_OUTSET = 0x0028,
LXB_CSS_VALUE_CONTENT_BOX = 0x0029,
LXB_CSS_VALUE_BORDER_BOX = 0x002a,
LXB_CSS_VALUE_INLINE_START = 0x002b,
LXB_CSS_VALUE_INLINE_END = 0x002c,
LXB_CSS_VALUE_BLOCK_START = 0x002d,
LXB_CSS_VALUE_BLOCK_END = 0x002e,
LXB_CSS_VALUE_LEFT = 0x002f,
LXB_CSS_VALUE_RIGHT = 0x0030,
LXB_CSS_VALUE_CURRENTCOLOR = 0x0031,
LXB_CSS_VALUE_TRANSPARENT = 0x0032,
LXB_CSS_VALUE_HEX = 0x0033,
LXB_CSS_VALUE_ALICEBLUE = 0x0034,
LXB_CSS_VALUE_ANTIQUEWHITE = 0x0035,
LXB_CSS_VALUE_AQUA = 0x0036,
LXB_CSS_VALUE_AQUAMARINE = 0x0037,
LXB_CSS_VALUE_AZURE = 0x0038,
LXB_CSS_VALUE_BEIGE = 0x0039,
LXB_CSS_VALUE_BISQUE = 0x003a,
LXB_CSS_VALUE_BLACK = 0x003b,
LXB_CSS_VALUE_BLANCHEDALMOND = 0x003c,
LXB_CSS_VALUE_BLUE = 0x003d,
LXB_CSS_VALUE_BLUEVIOLET = 0x003e,
LXB_CSS_VALUE_BROWN = 0x003f,
LXB_CSS_VALUE_BURLYWOOD = 0x0040,
LXB_CSS_VALUE_CADETBLUE = 0x0041,
LXB_CSS_VALUE_CHARTREUSE = 0x0042,
LXB_CSS_VALUE_CHOCOLATE = 0x0043,
LXB_CSS_VALUE_CORAL = 0x0044,
LXB_CSS_VALUE_CORNFLOWERBLUE = 0x0045,
LXB_CSS_VALUE_CORNSILK = 0x0046,
LXB_CSS_VALUE_CRIMSON = 0x0047,
LXB_CSS_VALUE_CYAN = 0x0048,
LXB_CSS_VALUE_DARKBLUE = 0x0049,
LXB_CSS_VALUE_DARKCYAN = 0x004a,
LXB_CSS_VALUE_DARKGOLDENROD = 0x004b,
LXB_CSS_VALUE_DARKGRAY = 0x004c,
LXB_CSS_VALUE_DARKGREEN = 0x004d,
LXB_CSS_VALUE_DARKGREY = 0x004e,
LXB_CSS_VALUE_DARKKHAKI = 0x004f,
LXB_CSS_VALUE_DARKMAGENTA = 0x0050,
LXB_CSS_VALUE_DARKOLIVEGREEN = 0x0051,
LXB_CSS_VALUE_DARKORANGE = 0x0052,
LXB_CSS_VALUE_DARKORCHID = 0x0053,
LXB_CSS_VALUE_DARKRED = 0x0054,
LXB_CSS_VALUE_DARKSALMON = 0x0055,
LXB_CSS_VALUE_DARKSEAGREEN = 0x0056,
LXB_CSS_VALUE_DARKSLATEBLUE = 0x0057,
LXB_CSS_VALUE_DARKSLATEGRAY = 0x0058,
LXB_CSS_VALUE_DARKSLATEGREY = 0x0059,
LXB_CSS_VALUE_DARKTURQUOISE = 0x005a,
LXB_CSS_VALUE_DARKVIOLET = 0x005b,
LXB_CSS_VALUE_DEEPPINK = 0x005c,
LXB_CSS_VALUE_DEEPSKYBLUE = 0x005d,
LXB_CSS_VALUE_DIMGRAY = 0x005e,
LXB_CSS_VALUE_DIMGREY = 0x005f,
LXB_CSS_VALUE_DODGERBLUE = 0x0060,
LXB_CSS_VALUE_FIREBRICK = 0x0061,
LXB_CSS_VALUE_FLORALWHITE = 0x0062,
LXB_CSS_VALUE_FORESTGREEN = 0x0063,
LXB_CSS_VALUE_FUCHSIA = 0x0064,
LXB_CSS_VALUE_GAINSBORO = 0x0065,
LXB_CSS_VALUE_GHOSTWHITE = 0x0066,
LXB_CSS_VALUE_GOLD = 0x0067,
LXB_CSS_VALUE_GOLDENROD = 0x0068,
LXB_CSS_VALUE_GRAY = 0x0069,
LXB_CSS_VALUE_GREEN = 0x006a,
LXB_CSS_VALUE_GREENYELLOW = 0x006b,
LXB_CSS_VALUE_GREY = 0x006c,
LXB_CSS_VALUE_HONEYDEW = 0x006d,
LXB_CSS_VALUE_HOTPINK = 0x006e,
LXB_CSS_VALUE_INDIANRED = 0x006f,
LXB_CSS_VALUE_INDIGO = 0x0070,
LXB_CSS_VALUE_IVORY = 0x0071,
LXB_CSS_VALUE_KHAKI = 0x0072,
LXB_CSS_VALUE_LAVENDER = 0x0073,
LXB_CSS_VALUE_LAVENDERBLUSH = 0x0074,
LXB_CSS_VALUE_LAWNGREEN = 0x0075,
LXB_CSS_VALUE_LEMONCHIFFON = 0x0076,
LXB_CSS_VALUE_LIGHTBLUE = 0x0077,
LXB_CSS_VALUE_LIGHTCORAL = 0x0078,
LXB_CSS_VALUE_LIGHTCYAN = 0x0079,
LXB_CSS_VALUE_LIGHTGOLDENRODYELLOW = 0x007a,
LXB_CSS_VALUE_LIGHTGRAY = 0x007b,
LXB_CSS_VALUE_LIGHTGREEN = 0x007c,
LXB_CSS_VALUE_LIGHTGREY = 0x007d,
LXB_CSS_VALUE_LIGHTPINK = 0x007e,
LXB_CSS_VALUE_LIGHTSALMON = 0x007f,
LXB_CSS_VALUE_LIGHTSEAGREEN = 0x0080,
LXB_CSS_VALUE_LIGHTSKYBLUE = 0x0081,
LXB_CSS_VALUE_LIGHTSLATEGRAY = 0x0082,
LXB_CSS_VALUE_LIGHTSLATEGREY = 0x0083,
LXB_CSS_VALUE_LIGHTSTEELBLUE = 0x0084,
LXB_CSS_VALUE_LIGHTYELLOW = 0x0085,
LXB_CSS_VALUE_LIME = 0x0086,
LXB_CSS_VALUE_LIMEGREEN = 0x0087,
LXB_CSS_VALUE_LINEN = 0x0088,
LXB_CSS_VALUE_MAGENTA = 0x0089,
LXB_CSS_VALUE_MAROON = 0x008a,
LXB_CSS_VALUE_MEDIUMAQUAMARINE = 0x008b,
LXB_CSS_VALUE_MEDIUMBLUE = 0x008c,
LXB_CSS_VALUE_MEDIUMORCHID = 0x008d,
LXB_CSS_VALUE_MEDIUMPURPLE = 0x008e,
LXB_CSS_VALUE_MEDIUMSEAGREEN = 0x008f,
LXB_CSS_VALUE_MEDIUMSLATEBLUE = 0x0090,
LXB_CSS_VALUE_MEDIUMSPRINGGREEN = 0x0091,
LXB_CSS_VALUE_MEDIUMTURQUOISE = 0x0092,
LXB_CSS_VALUE_MEDIUMVIOLETRED = 0x0093,
LXB_CSS_VALUE_MIDNIGHTBLUE = 0x0094,
LXB_CSS_VALUE_MINTCREAM = 0x0095,
LXB_CSS_VALUE_MISTYROSE = 0x0096,
LXB_CSS_VALUE_MOCCASIN = 0x0097,
LXB_CSS_VALUE_NAVAJOWHITE = 0x0098,
LXB_CSS_VALUE_NAVY = 0x0099,
LXB_CSS_VALUE_OLDLACE = 0x009a,
LXB_CSS_VALUE_OLIVE = 0x009b,
LXB_CSS_VALUE_OLIVEDRAB = 0x009c,
LXB_CSS_VALUE_ORANGE = 0x009d,
LXB_CSS_VALUE_ORANGERED = 0x009e,
LXB_CSS_VALUE_ORCHID = 0x009f,
LXB_CSS_VALUE_PALEGOLDENROD = 0x00a0,
LXB_CSS_VALUE_PALEGREEN = 0x00a1,
LXB_CSS_VALUE_PALETURQUOISE = 0x00a2,
LXB_CSS_VALUE_PALEVIOLETRED = 0x00a3,
LXB_CSS_VALUE_PAPAYAWHIP = 0x00a4,
LXB_CSS_VALUE_PEACHPUFF = 0x00a5,
LXB_CSS_VALUE_PERU = 0x00a6,
LXB_CSS_VALUE_PINK = 0x00a7,
LXB_CSS_VALUE_PLUM = 0x00a8,
LXB_CSS_VALUE_POWDERBLUE = 0x00a9,
LXB_CSS_VALUE_PURPLE = 0x00aa,
LXB_CSS_VALUE_REBECCAPURPLE = 0x00ab,
LXB_CSS_VALUE_RED = 0x00ac,
LXB_CSS_VALUE_ROSYBROWN = 0x00ad,
LXB_CSS_VALUE_ROYALBLUE = 0x00ae,
LXB_CSS_VALUE_SADDLEBROWN = 0x00af,
LXB_CSS_VALUE_SALMON = 0x00b0,
LXB_CSS_VALUE_SANDYBROWN = 0x00b1,
LXB_CSS_VALUE_SEAGREEN = 0x00b2,
LXB_CSS_VALUE_SEASHELL = 0x00b3,
LXB_CSS_VALUE_SIENNA = 0x00b4,
LXB_CSS_VALUE_SILVER = 0x00b5,
LXB_CSS_VALUE_SKYBLUE = 0x00b6,
LXB_CSS_VALUE_SLATEBLUE = 0x00b7,
LXB_CSS_VALUE_SLATEGRAY = 0x00b8,
LXB_CSS_VALUE_SLATEGREY = 0x00b9,
LXB_CSS_VALUE_SNOW = 0x00ba,
LXB_CSS_VALUE_SPRINGGREEN = 0x00bb,
LXB_CSS_VALUE_STEELBLUE = 0x00bc,
LXB_CSS_VALUE_TAN = 0x00bd,
LXB_CSS_VALUE_TEAL = 0x00be,
LXB_CSS_VALUE_THISTLE = 0x00bf,
LXB_CSS_VALUE_TOMATO = 0x00c0,
LXB_CSS_VALUE_TURQUOISE = 0x00c1,
LXB_CSS_VALUE_VIOLET = 0x00c2,
LXB_CSS_VALUE_WHEAT = 0x00c3,
LXB_CSS_VALUE_WHITE = 0x00c4,
LXB_CSS_VALUE_WHITESMOKE = 0x00c5,
LXB_CSS_VALUE_YELLOW = 0x00c6,
LXB_CSS_VALUE_YELLOWGREEN = 0x00c7,
LXB_CSS_VALUE_CANVAS = 0x00c8,
LXB_CSS_VALUE_CANVASTEXT = 0x00c9,
LXB_CSS_VALUE_LINKTEXT = 0x00ca,
LXB_CSS_VALUE_VISITEDTEXT = 0x00cb,
LXB_CSS_VALUE_ACTIVETEXT = 0x00cc,
LXB_CSS_VALUE_BUTTONFACE = 0x00cd,
LXB_CSS_VALUE_BUTTONTEXT = 0x00ce,
LXB_CSS_VALUE_BUTTONBORDER = 0x00cf,
LXB_CSS_VALUE_FIELD = 0x00d0,
LXB_CSS_VALUE_FIELDTEXT = 0x00d1,
LXB_CSS_VALUE_HIGHLIGHT = 0x00d2,
LXB_CSS_VALUE_HIGHLIGHTTEXT = 0x00d3,
LXB_CSS_VALUE_SELECTEDITEM = 0x00d4,
LXB_CSS_VALUE_SELECTEDITEMTEXT = 0x00d5,
LXB_CSS_VALUE_MARK = 0x00d6,
LXB_CSS_VALUE_MARKTEXT = 0x00d7,
LXB_CSS_VALUE_GRAYTEXT = 0x00d8,
LXB_CSS_VALUE_ACCENTCOLOR = 0x00d9,
LXB_CSS_VALUE_ACCENTCOLORTEXT = 0x00da,
LXB_CSS_VALUE_RGB = 0x00db,
LXB_CSS_VALUE_RGBA = 0x00dc,
LXB_CSS_VALUE_HSL = 0x00dd,
LXB_CSS_VALUE_HSLA = 0x00de,
LXB_CSS_VALUE_HWB = 0x00df,
LXB_CSS_VALUE_LAB = 0x00e0,
LXB_CSS_VALUE_LCH = 0x00e1,
LXB_CSS_VALUE_OKLAB = 0x00e2,
LXB_CSS_VALUE_OKLCH = 0x00e3,
LXB_CSS_VALUE_COLOR = 0x00e4,
LXB_CSS_VALUE_LTR = 0x00e5,
LXB_CSS_VALUE_RTL = 0x00e6,
LXB_CSS_VALUE_BLOCK = 0x00e7,
LXB_CSS_VALUE_INLINE = 0x00e8,
LXB_CSS_VALUE_RUN_IN = 0x00e9,
LXB_CSS_VALUE_FLOW = 0x00ea,
LXB_CSS_VALUE_FLOW_ROOT = 0x00eb,
LXB_CSS_VALUE_TABLE = 0x00ec,
LXB_CSS_VALUE_FLEX = 0x00ed,
LXB_CSS_VALUE_GRID = 0x00ee,
LXB_CSS_VALUE_RUBY = 0x00ef,
LXB_CSS_VALUE_LIST_ITEM = 0x00f0,
LXB_CSS_VALUE_TABLE_ROW_GROUP = 0x00f1,
LXB_CSS_VALUE_TABLE_HEADER_GROUP = 0x00f2,
LXB_CSS_VALUE_TABLE_FOOTER_GROUP = 0x00f3,
LXB_CSS_VALUE_TABLE_ROW = 0x00f4,
LXB_CSS_VALUE_TABLE_CELL = 0x00f5,
LXB_CSS_VALUE_TABLE_COLUMN_GROUP = 0x00f6,
LXB_CSS_VALUE_TABLE_COLUMN = 0x00f7,
LXB_CSS_VALUE_TABLE_CAPTION = 0x00f8,
LXB_CSS_VALUE_RUBY_BASE = 0x00f9,
LXB_CSS_VALUE_RUBY_TEXT = 0x00fa,
LXB_CSS_VALUE_RUBY_BASE_CONTAINER = 0x00fb,
LXB_CSS_VALUE_RUBY_TEXT_CONTAINER = 0x00fc,
LXB_CSS_VALUE_CONTENTS = 0x00fd,
LXB_CSS_VALUE_INLINE_BLOCK = 0x00fe,
LXB_CSS_VALUE_INLINE_TABLE = 0x00ff,
LXB_CSS_VALUE_INLINE_FLEX = 0x0100,
LXB_CSS_VALUE_INLINE_GRID = 0x0101,
LXB_CSS_VALUE_HANGING = 0x0102,
LXB_CSS_VALUE_CONTENT = 0x0103,
LXB_CSS_VALUE_ROW = 0x0104,
LXB_CSS_VALUE_ROW_REVERSE = 0x0105,
LXB_CSS_VALUE_COLUMN = 0x0106,
LXB_CSS_VALUE_COLUMN_REVERSE = 0x0107,
LXB_CSS_VALUE__NUMBER = 0x0108,
LXB_CSS_VALUE_NOWRAP = 0x0109,
LXB_CSS_VALUE_WRAP = 0x010a,
LXB_CSS_VALUE_WRAP_REVERSE = 0x010b,
LXB_CSS_VALUE_SNAP_BLOCK = 0x010c,
LXB_CSS_VALUE_START = 0x010d,
LXB_CSS_VALUE_END = 0x010e,
LXB_CSS_VALUE_NEAR = 0x010f,
LXB_CSS_VALUE_SNAP_INLINE = 0x0110,
LXB_CSS_VALUE__INTEGER = 0x0111,
LXB_CSS_VALUE_REGION = 0x0112,
LXB_CSS_VALUE_PAGE = 0x0113,
LXB_CSS_VALUE_SERIF = 0x0114,
LXB_CSS_VALUE_SANS_SERIF = 0x0115,
LXB_CSS_VALUE_CURSIVE = 0x0116,
LXB_CSS_VALUE_FANTASY = 0x0117,
LXB_CSS_VALUE_MONOSPACE = 0x0118,
LXB_CSS_VALUE_SYSTEM_UI = 0x0119,
LXB_CSS_VALUE_EMOJI = 0x011a,
LXB_CSS_VALUE_MATH = 0x011b,
LXB_CSS_VALUE_FANGSONG = 0x011c,
LXB_CSS_VALUE_UI_SERIF = 0x011d,
LXB_CSS_VALUE_UI_SANS_SERIF = 0x011e,
LXB_CSS_VALUE_UI_MONOSPACE = 0x011f,
LXB_CSS_VALUE_UI_ROUNDED = 0x0120,
LXB_CSS_VALUE_XX_SMALL = 0x0121,
LXB_CSS_VALUE_X_SMALL = 0x0122,
LXB_CSS_VALUE_SMALL = 0x0123,
LXB_CSS_VALUE_LARGE = 0x0124,
LXB_CSS_VALUE_X_LARGE = 0x0125,
LXB_CSS_VALUE_XX_LARGE = 0x0126,
LXB_CSS_VALUE_XXX_LARGE = 0x0127,
LXB_CSS_VALUE_LARGER = 0x0128,
LXB_CSS_VALUE_SMALLER = 0x0129,
LXB_CSS_VALUE_NORMAL = 0x012a,
LXB_CSS_VALUE_ULTRA_CONDENSED = 0x012b,
LXB_CSS_VALUE_EXTRA_CONDENSED = 0x012c,
LXB_CSS_VALUE_CONDENSED = 0x012d,
LXB_CSS_VALUE_SEMI_CONDENSED = 0x012e,
LXB_CSS_VALUE_SEMI_EXPANDED = 0x012f,
LXB_CSS_VALUE_EXPANDED = 0x0130,
LXB_CSS_VALUE_EXTRA_EXPANDED = 0x0131,
LXB_CSS_VALUE_ULTRA_EXPANDED = 0x0132,
LXB_CSS_VALUE_ITALIC = 0x0133,
LXB_CSS_VALUE_OBLIQUE = 0x0134,
LXB_CSS_VALUE_BOLD = 0x0135,
LXB_CSS_VALUE_BOLDER = 0x0136,
LXB_CSS_VALUE_LIGHTER = 0x0137,
LXB_CSS_VALUE_FORCE_END = 0x0138,
LXB_CSS_VALUE_ALLOW_END = 0x0139,
LXB_CSS_VALUE_MIN_CONTENT = 0x013a,
LXB_CSS_VALUE_MAX_CONTENT = 0x013b,
LXB_CSS_VALUE__ANGLE = 0x013c,
LXB_CSS_VALUE_MANUAL = 0x013d,
LXB_CSS_VALUE_LOOSE = 0x013e,
LXB_CSS_VALUE_STRICT = 0x013f,
LXB_CSS_VALUE_ANYWHERE = 0x0140,
LXB_CSS_VALUE_VISIBLE = 0x0141,
LXB_CSS_VALUE_CLIP = 0x0142,
LXB_CSS_VALUE_SCROLL = 0x0143,
LXB_CSS_VALUE_BREAK_WORD = 0x0144,
LXB_CSS_VALUE_STATIC = 0x0145,
LXB_CSS_VALUE_RELATIVE = 0x0146,
LXB_CSS_VALUE_ABSOLUTE = 0x0147,
LXB_CSS_VALUE_STICKY = 0x0148,
LXB_CSS_VALUE_FIXED = 0x0149,
LXB_CSS_VALUE_JUSTIFY = 0x014a,
LXB_CSS_VALUE_MATCH_PARENT = 0x014b,
LXB_CSS_VALUE_JUSTIFY_ALL = 0x014c,
LXB_CSS_VALUE_ALL = 0x014d,
LXB_CSS_VALUE_DIGITS = 0x014e,
LXB_CSS_VALUE_UNDERLINE = 0x014f,
LXB_CSS_VALUE_OVERLINE = 0x0150,
LXB_CSS_VALUE_LINE_THROUGH = 0x0151,
LXB_CSS_VALUE_BLINK = 0x0152,
LXB_CSS_VALUE_WAVY = 0x0153,
LXB_CSS_VALUE_EACH_LINE = 0x0154,
LXB_CSS_VALUE_INTER_WORD = 0x0155,
LXB_CSS_VALUE_INTER_CHARACTER = 0x0156,
LXB_CSS_VALUE_MIXED = 0x0157,
LXB_CSS_VALUE_UPRIGHT = 0x0158,
LXB_CSS_VALUE_SIDEWAYS = 0x0159,
LXB_CSS_VALUE_ELLIPSIS = 0x015a,
LXB_CSS_VALUE_CAPITALIZE = 0x015b,
LXB_CSS_VALUE_UPPERCASE = 0x015c,
LXB_CSS_VALUE_LOWERCASE = 0x015d,
LXB_CSS_VALUE_FULL_WIDTH = 0x015e,
LXB_CSS_VALUE_FULL_SIZE_KANA = 0x015f,
LXB_CSS_VALUE_EMBED = 0x0160,
LXB_CSS_VALUE_ISOLATE = 0x0161,
LXB_CSS_VALUE_BIDI_OVERRIDE = 0x0162,
LXB_CSS_VALUE_ISOLATE_OVERRIDE = 0x0163,
LXB_CSS_VALUE_PLAINTEXT = 0x0164,
LXB_CSS_VALUE_COLLAPSE = 0x0165,
LXB_CSS_VALUE_PRE = 0x0166,
LXB_CSS_VALUE_PRE_WRAP = 0x0167,
LXB_CSS_VALUE_BREAK_SPACES = 0x0168,
LXB_CSS_VALUE_PRE_LINE = 0x0169,
LXB_CSS_VALUE_KEEP_ALL = 0x016a,
LXB_CSS_VALUE_BREAK_ALL = 0x016b,
LXB_CSS_VALUE_BOTH = 0x016c,
LXB_CSS_VALUE_MINIMUM = 0x016d,
LXB_CSS_VALUE_MAXIMUM = 0x016e,
LXB_CSS_VALUE_CLEAR = 0x016f,
LXB_CSS_VALUE_HORIZONTAL_TB = 0x0170,
LXB_CSS_VALUE_VERTICAL_RL = 0x0171,
LXB_CSS_VALUE_VERTICAL_LR = 0x0172,
LXB_CSS_VALUE_SIDEWAYS_RL = 0x0173,
LXB_CSS_VALUE_SIDEWAYS_LR = 0x0174,
LXB_CSS_VALUE__LAST_ENTRY = 0x0175
};
typedef unsigned int lxb_css_value_type_t;
#endif /* LXB_CSS_VALUE_CONST_H */

775
ext/dom/lexbor/lexbor/css/value/res.h Normal file
View file

@ -0,0 +1,775 @@
/*
* Copyright (C) 2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
/*
* Caution!
* This file generated by the script "utils/lexbor/css/names.py"!
* Do not change this file!
*/
#ifndef LXB_CSS_VALUE_RES_H
#define LXB_CSS_VALUE_RES_H
#include "lexbor/core/shs.h"
#include "lexbor/css/value/const.h"
static const lxb_css_data_t lxb_css_value_data[LXB_CSS_VALUE__LAST_ENTRY] =
{
{(lxb_char_t *) "_undef", 6, LXB_CSS_VALUE__UNDEF},
{(lxb_char_t *) "initial", 7, LXB_CSS_VALUE_INITIAL},
{(lxb_char_t *) "inherit", 7, LXB_CSS_VALUE_INHERIT},
{(lxb_char_t *) "unset", 5, LXB_CSS_VALUE_UNSET},
{(lxb_char_t *) "revert", 6, LXB_CSS_VALUE_REVERT},
{(lxb_char_t *) "flex-start", 10, LXB_CSS_VALUE_FLEX_START},
{(lxb_char_t *) "flex-end", 8, LXB_CSS_VALUE_FLEX_END},
{(lxb_char_t *) "center", 6, LXB_CSS_VALUE_CENTER},
{(lxb_char_t *) "space-between", 13, LXB_CSS_VALUE_SPACE_BETWEEN},
{(lxb_char_t *) "space-around", 12, LXB_CSS_VALUE_SPACE_AROUND},
{(lxb_char_t *) "stretch", 7, LXB_CSS_VALUE_STRETCH},
{(lxb_char_t *) "baseline", 8, LXB_CSS_VALUE_BASELINE},
{(lxb_char_t *) "auto", 4, LXB_CSS_VALUE_AUTO},
{(lxb_char_t *) "text-bottom", 11, LXB_CSS_VALUE_TEXT_BOTTOM},
{(lxb_char_t *) "alphabetic", 10, LXB_CSS_VALUE_ALPHABETIC},
{(lxb_char_t *) "ideographic", 11, LXB_CSS_VALUE_IDEOGRAPHIC},
{(lxb_char_t *) "middle", 6, LXB_CSS_VALUE_MIDDLE},
{(lxb_char_t *) "central", 7, LXB_CSS_VALUE_CENTRAL},
{(lxb_char_t *) "mathematical", 12, LXB_CSS_VALUE_MATHEMATICAL},
{(lxb_char_t *) "text-top", 8, LXB_CSS_VALUE_TEXT_TOP},
{(lxb_char_t *) "_length", 7, LXB_CSS_VALUE__LENGTH},
{(lxb_char_t *) "_percentage", 11, LXB_CSS_VALUE__PERCENTAGE},
{(lxb_char_t *) "sub", 3, LXB_CSS_VALUE_SUB},
{(lxb_char_t *) "super", 5, LXB_CSS_VALUE_SUPER},
{(lxb_char_t *) "top", 3, LXB_CSS_VALUE_TOP},
{(lxb_char_t *) "bottom", 6, LXB_CSS_VALUE_BOTTOM},
{(lxb_char_t *) "first", 5, LXB_CSS_VALUE_FIRST},
{(lxb_char_t *) "last", 4, LXB_CSS_VALUE_LAST},
{(lxb_char_t *) "thin", 4, LXB_CSS_VALUE_THIN},
{(lxb_char_t *) "medium", 6, LXB_CSS_VALUE_MEDIUM},
{(lxb_char_t *) "thick", 5, LXB_CSS_VALUE_THICK},
{(lxb_char_t *) "none", 4, LXB_CSS_VALUE_NONE},
{(lxb_char_t *) "hidden", 6, LXB_CSS_VALUE_HIDDEN},
{(lxb_char_t *) "dotted", 6, LXB_CSS_VALUE_DOTTED},
{(lxb_char_t *) "dashed", 6, LXB_CSS_VALUE_DASHED},
{(lxb_char_t *) "solid", 5, LXB_CSS_VALUE_SOLID},
{(lxb_char_t *) "double", 6, LXB_CSS_VALUE_DOUBLE},
{(lxb_char_t *) "groove", 6, LXB_CSS_VALUE_GROOVE},
{(lxb_char_t *) "ridge", 5, LXB_CSS_VALUE_RIDGE},
{(lxb_char_t *) "inset", 5, LXB_CSS_VALUE_INSET},
{(lxb_char_t *) "outset", 6, LXB_CSS_VALUE_OUTSET},
{(lxb_char_t *) "content-box", 11, LXB_CSS_VALUE_CONTENT_BOX},
{(lxb_char_t *) "border-box", 10, LXB_CSS_VALUE_BORDER_BOX},
{(lxb_char_t *) "inline-start", 12, LXB_CSS_VALUE_INLINE_START},
{(lxb_char_t *) "inline-end", 10, LXB_CSS_VALUE_INLINE_END},
{(lxb_char_t *) "block-start", 11, LXB_CSS_VALUE_BLOCK_START},
{(lxb_char_t *) "block-end", 9, LXB_CSS_VALUE_BLOCK_END},
{(lxb_char_t *) "left", 4, LXB_CSS_VALUE_LEFT},
{(lxb_char_t *) "right", 5, LXB_CSS_VALUE_RIGHT},
{(lxb_char_t *) "currentcolor", 12, LXB_CSS_VALUE_CURRENTCOLOR},
{(lxb_char_t *) "transparent", 11, LXB_CSS_VALUE_TRANSPARENT},
{(lxb_char_t *) "hex", 3, LXB_CSS_VALUE_HEX},
{(lxb_char_t *) "aliceblue", 9, LXB_CSS_VALUE_ALICEBLUE},
{(lxb_char_t *) "antiquewhite", 12, LXB_CSS_VALUE_ANTIQUEWHITE},
{(lxb_char_t *) "aqua", 4, LXB_CSS_VALUE_AQUA},
{(lxb_char_t *) "aquamarine", 10, LXB_CSS_VALUE_AQUAMARINE},
{(lxb_char_t *) "azure", 5, LXB_CSS_VALUE_AZURE},
{(lxb_char_t *) "beige", 5, LXB_CSS_VALUE_BEIGE},
{(lxb_char_t *) "bisque", 6, LXB_CSS_VALUE_BISQUE},
{(lxb_char_t *) "black", 5, LXB_CSS_VALUE_BLACK},
{(lxb_char_t *) "blanchedalmond", 14, LXB_CSS_VALUE_BLANCHEDALMOND},
{(lxb_char_t *) "blue", 4, LXB_CSS_VALUE_BLUE},
{(lxb_char_t *) "blueviolet", 10, LXB_CSS_VALUE_BLUEVIOLET},
{(lxb_char_t *) "brown", 5, LXB_CSS_VALUE_BROWN},
{(lxb_char_t *) "burlywood", 9, LXB_CSS_VALUE_BURLYWOOD},
{(lxb_char_t *) "cadetblue", 9, LXB_CSS_VALUE_CADETBLUE},
{(lxb_char_t *) "chartreuse", 10, LXB_CSS_VALUE_CHARTREUSE},
{(lxb_char_t *) "chocolate", 9, LXB_CSS_VALUE_CHOCOLATE},
{(lxb_char_t *) "coral", 5, LXB_CSS_VALUE_CORAL},
{(lxb_char_t *) "cornflowerblue", 14, LXB_CSS_VALUE_CORNFLOWERBLUE},
{(lxb_char_t *) "cornsilk", 8, LXB_CSS_VALUE_CORNSILK},
{(lxb_char_t *) "crimson", 7, LXB_CSS_VALUE_CRIMSON},
{(lxb_char_t *) "cyan", 4, LXB_CSS_VALUE_CYAN},
{(lxb_char_t *) "darkblue", 8, LXB_CSS_VALUE_DARKBLUE},
{(lxb_char_t *) "darkcyan", 8, LXB_CSS_VALUE_DARKCYAN},
{(lxb_char_t *) "darkgoldenrod", 13, LXB_CSS_VALUE_DARKGOLDENROD},
{(lxb_char_t *) "darkgray", 8, LXB_CSS_VALUE_DARKGRAY},
{(lxb_char_t *) "darkgreen", 9, LXB_CSS_VALUE_DARKGREEN},
{(lxb_char_t *) "darkgrey", 8, LXB_CSS_VALUE_DARKGREY},
{(lxb_char_t *) "darkkhaki", 9, LXB_CSS_VALUE_DARKKHAKI},
{(lxb_char_t *) "darkmagenta", 11, LXB_CSS_VALUE_DARKMAGENTA},
{(lxb_char_t *) "darkolivegreen", 14, LXB_CSS_VALUE_DARKOLIVEGREEN},
{(lxb_char_t *) "darkorange", 10, LXB_CSS_VALUE_DARKORANGE},
{(lxb_char_t *) "darkorchid", 10, LXB_CSS_VALUE_DARKORCHID},
{(lxb_char_t *) "darkred", 7, LXB_CSS_VALUE_DARKRED},
{(lxb_char_t *) "darksalmon", 10, LXB_CSS_VALUE_DARKSALMON},
{(lxb_char_t *) "darkseagreen", 12, LXB_CSS_VALUE_DARKSEAGREEN},
{(lxb_char_t *) "darkslateblue", 13, LXB_CSS_VALUE_DARKSLATEBLUE},
{(lxb_char_t *) "darkslategray", 13, LXB_CSS_VALUE_DARKSLATEGRAY},
{(lxb_char_t *) "darkslategrey", 13, LXB_CSS_VALUE_DARKSLATEGREY},
{(lxb_char_t *) "darkturquoise", 13, LXB_CSS_VALUE_DARKTURQUOISE},
{(lxb_char_t *) "darkviolet", 10, LXB_CSS_VALUE_DARKVIOLET},
{(lxb_char_t *) "deeppink", 8, LXB_CSS_VALUE_DEEPPINK},
{(lxb_char_t *) "deepskyblue", 11, LXB_CSS_VALUE_DEEPSKYBLUE},
{(lxb_char_t *) "dimgray", 7, LXB_CSS_VALUE_DIMGRAY},
{(lxb_char_t *) "dimgrey", 7, LXB_CSS_VALUE_DIMGREY},
{(lxb_char_t *) "dodgerblue", 10, LXB_CSS_VALUE_DODGERBLUE},
{(lxb_char_t *) "firebrick", 9, LXB_CSS_VALUE_FIREBRICK},
{(lxb_char_t *) "floralwhite", 11, LXB_CSS_VALUE_FLORALWHITE},
{(lxb_char_t *) "forestgreen", 11, LXB_CSS_VALUE_FORESTGREEN},
{(lxb_char_t *) "fuchsia", 7, LXB_CSS_VALUE_FUCHSIA},
{(lxb_char_t *) "gainsboro", 9, LXB_CSS_VALUE_GAINSBORO},
{(lxb_char_t *) "ghostwhite", 10, LXB_CSS_VALUE_GHOSTWHITE},
{(lxb_char_t *) "gold", 4, LXB_CSS_VALUE_GOLD},
{(lxb_char_t *) "goldenrod", 9, LXB_CSS_VALUE_GOLDENROD},
{(lxb_char_t *) "gray", 4, LXB_CSS_VALUE_GRAY},
{(lxb_char_t *) "green", 5, LXB_CSS_VALUE_GREEN},
{(lxb_char_t *) "greenyellow", 11, LXB_CSS_VALUE_GREENYELLOW},
{(lxb_char_t *) "grey", 4, LXB_CSS_VALUE_GREY},
{(lxb_char_t *) "honeydew", 8, LXB_CSS_VALUE_HONEYDEW},
{(lxb_char_t *) "hotpink", 7, LXB_CSS_VALUE_HOTPINK},
{(lxb_char_t *) "indianred", 9, LXB_CSS_VALUE_INDIANRED},
{(lxb_char_t *) "indigo", 6, LXB_CSS_VALUE_INDIGO},
{(lxb_char_t *) "ivory", 5, LXB_CSS_VALUE_IVORY},
{(lxb_char_t *) "khaki", 5, LXB_CSS_VALUE_KHAKI},
{(lxb_char_t *) "lavender", 8, LXB_CSS_VALUE_LAVENDER},
{(lxb_char_t *) "lavenderblush", 13, LXB_CSS_VALUE_LAVENDERBLUSH},
{(lxb_char_t *) "lawngreen", 9, LXB_CSS_VALUE_LAWNGREEN},
{(lxb_char_t *) "lemonchiffon", 12, LXB_CSS_VALUE_LEMONCHIFFON},
{(lxb_char_t *) "lightblue", 9, LXB_CSS_VALUE_LIGHTBLUE},
{(lxb_char_t *) "lightcoral", 10, LXB_CSS_VALUE_LIGHTCORAL},
{(lxb_char_t *) "lightcyan", 9, LXB_CSS_VALUE_LIGHTCYAN},
{(lxb_char_t *) "lightgoldenrodyellow", 20, LXB_CSS_VALUE_LIGHTGOLDENRODYELLOW},
{(lxb_char_t *) "lightgray", 9, LXB_CSS_VALUE_LIGHTGRAY},
{(lxb_char_t *) "lightgreen", 10, LXB_CSS_VALUE_LIGHTGREEN},
{(lxb_char_t *) "lightgrey", 9, LXB_CSS_VALUE_LIGHTGREY},
{(lxb_char_t *) "lightpink", 9, LXB_CSS_VALUE_LIGHTPINK},
{(lxb_char_t *) "lightsalmon", 11, LXB_CSS_VALUE_LIGHTSALMON},
{(lxb_char_t *) "lightseagreen", 13, LXB_CSS_VALUE_LIGHTSEAGREEN},
{(lxb_char_t *) "lightskyblue", 12, LXB_CSS_VALUE_LIGHTSKYBLUE},
{(lxb_char_t *) "lightslategray", 14, LXB_CSS_VALUE_LIGHTSLATEGRAY},
{(lxb_char_t *) "lightslategrey", 14, LXB_CSS_VALUE_LIGHTSLATEGREY},
{(lxb_char_t *) "lightsteelblue", 14, LXB_CSS_VALUE_LIGHTSTEELBLUE},
{(lxb_char_t *) "lightyellow", 11, LXB_CSS_VALUE_LIGHTYELLOW},
{(lxb_char_t *) "lime", 4, LXB_CSS_VALUE_LIME},
{(lxb_char_t *) "limegreen", 9, LXB_CSS_VALUE_LIMEGREEN},
{(lxb_char_t *) "linen", 5, LXB_CSS_VALUE_LINEN},
{(lxb_char_t *) "magenta", 7, LXB_CSS_VALUE_MAGENTA},
{(lxb_char_t *) "maroon", 6, LXB_CSS_VALUE_MAROON},
{(lxb_char_t *) "mediumaquamarine", 16, LXB_CSS_VALUE_MEDIUMAQUAMARINE},
{(lxb_char_t *) "mediumblue", 10, LXB_CSS_VALUE_MEDIUMBLUE},
{(lxb_char_t *) "mediumorchid", 12, LXB_CSS_VALUE_MEDIUMORCHID},
{(lxb_char_t *) "mediumpurple", 12, LXB_CSS_VALUE_MEDIUMPURPLE},
{(lxb_char_t *) "mediumseagreen", 14, LXB_CSS_VALUE_MEDIUMSEAGREEN},
{(lxb_char_t *) "mediumslateblue", 15, LXB_CSS_VALUE_MEDIUMSLATEBLUE},
{(lxb_char_t *) "mediumspringgreen", 17, LXB_CSS_VALUE_MEDIUMSPRINGGREEN},
{(lxb_char_t *) "mediumturquoise", 15, LXB_CSS_VALUE_MEDIUMTURQUOISE},
{(lxb_char_t *) "mediumvioletred", 15, LXB_CSS_VALUE_MEDIUMVIOLETRED},
{(lxb_char_t *) "midnightblue", 12, LXB_CSS_VALUE_MIDNIGHTBLUE},
{(lxb_char_t *) "mintcream", 9, LXB_CSS_VALUE_MINTCREAM},
{(lxb_char_t *) "mistyrose", 9, LXB_CSS_VALUE_MISTYROSE},
{(lxb_char_t *) "moccasin", 8, LXB_CSS_VALUE_MOCCASIN},
{(lxb_char_t *) "navajowhite", 11, LXB_CSS_VALUE_NAVAJOWHITE},
{(lxb_char_t *) "navy", 4, LXB_CSS_VALUE_NAVY},
{(lxb_char_t *) "oldlace", 7, LXB_CSS_VALUE_OLDLACE},
{(lxb_char_t *) "olive", 5, LXB_CSS_VALUE_OLIVE},
{(lxb_char_t *) "olivedrab", 9, LXB_CSS_VALUE_OLIVEDRAB},
{(lxb_char_t *) "orange", 6, LXB_CSS_VALUE_ORANGE},
{(lxb_char_t *) "orangered", 9, LXB_CSS_VALUE_ORANGERED},
{(lxb_char_t *) "orchid", 6, LXB_CSS_VALUE_ORCHID},
{(lxb_char_t *) "palegoldenrod", 13, LXB_CSS_VALUE_PALEGOLDENROD},
{(lxb_char_t *) "palegreen", 9, LXB_CSS_VALUE_PALEGREEN},
{(lxb_char_t *) "paleturquoise", 13, LXB_CSS_VALUE_PALETURQUOISE},
{(lxb_char_t *) "palevioletred", 13, LXB_CSS_VALUE_PALEVIOLETRED},
{(lxb_char_t *) "papayawhip", 10, LXB_CSS_VALUE_PAPAYAWHIP},
{(lxb_char_t *) "peachpuff", 9, LXB_CSS_VALUE_PEACHPUFF},
{(lxb_char_t *) "peru", 4, LXB_CSS_VALUE_PERU},
{(lxb_char_t *) "pink", 4, LXB_CSS_VALUE_PINK},
{(lxb_char_t *) "plum", 4, LXB_CSS_VALUE_PLUM},
{(lxb_char_t *) "powderblue", 10, LXB_CSS_VALUE_POWDERBLUE},
{(lxb_char_t *) "purple", 6, LXB_CSS_VALUE_PURPLE},
{(lxb_char_t *) "rebeccapurple", 13, LXB_CSS_VALUE_REBECCAPURPLE},
{(lxb_char_t *) "red", 3, LXB_CSS_VALUE_RED},
{(lxb_char_t *) "rosybrown", 9, LXB_CSS_VALUE_ROSYBROWN},
{(lxb_char_t *) "royalblue", 9, LXB_CSS_VALUE_ROYALBLUE},
{(lxb_char_t *) "saddlebrown", 11, LXB_CSS_VALUE_SADDLEBROWN},
{(lxb_char_t *) "salmon", 6, LXB_CSS_VALUE_SALMON},
{(lxb_char_t *) "sandybrown", 10, LXB_CSS_VALUE_SANDYBROWN},
{(lxb_char_t *) "seagreen", 8, LXB_CSS_VALUE_SEAGREEN},
{(lxb_char_t *) "seashell", 8, LXB_CSS_VALUE_SEASHELL},
{(lxb_char_t *) "sienna", 6, LXB_CSS_VALUE_SIENNA},
{(lxb_char_t *) "silver", 6, LXB_CSS_VALUE_SILVER},
{(lxb_char_t *) "skyblue", 7, LXB_CSS_VALUE_SKYBLUE},
{(lxb_char_t *) "slateblue", 9, LXB_CSS_VALUE_SLATEBLUE},
{(lxb_char_t *) "slategray", 9, LXB_CSS_VALUE_SLATEGRAY},
{(lxb_char_t *) "slategrey", 9, LXB_CSS_VALUE_SLATEGREY},
{(lxb_char_t *) "snow", 4, LXB_CSS_VALUE_SNOW},
{(lxb_char_t *) "springgreen", 11, LXB_CSS_VALUE_SPRINGGREEN},
{(lxb_char_t *) "steelblue", 9, LXB_CSS_VALUE_STEELBLUE},
{(lxb_char_t *) "tan", 3, LXB_CSS_VALUE_TAN},
{(lxb_char_t *) "teal", 4, LXB_CSS_VALUE_TEAL},
{(lxb_char_t *) "thistle", 7, LXB_CSS_VALUE_THISTLE},
{(lxb_char_t *) "tomato", 6, LXB_CSS_VALUE_TOMATO},
{(lxb_char_t *) "turquoise", 9, LXB_CSS_VALUE_TURQUOISE},
{(lxb_char_t *) "violet", 6, LXB_CSS_VALUE_VIOLET},
{(lxb_char_t *) "wheat", 5, LXB_CSS_VALUE_WHEAT},
{(lxb_char_t *) "white", 5, LXB_CSS_VALUE_WHITE},
{(lxb_char_t *) "whitesmoke", 10, LXB_CSS_VALUE_WHITESMOKE},
{(lxb_char_t *) "yellow", 6, LXB_CSS_VALUE_YELLOW},
{(lxb_char_t *) "yellowgreen", 11, LXB_CSS_VALUE_YELLOWGREEN},
{(lxb_char_t *) "Canvas", 6, LXB_CSS_VALUE_CANVAS},
{(lxb_char_t *) "CanvasText", 10, LXB_CSS_VALUE_CANVASTEXT},
{(lxb_char_t *) "LinkText", 8, LXB_CSS_VALUE_LINKTEXT},
{(lxb_char_t *) "VisitedText", 11, LXB_CSS_VALUE_VISITEDTEXT},
{(lxb_char_t *) "ActiveText", 10, LXB_CSS_VALUE_ACTIVETEXT},
{(lxb_char_t *) "ButtonFace", 10, LXB_CSS_VALUE_BUTTONFACE},
{(lxb_char_t *) "ButtonText", 10, LXB_CSS_VALUE_BUTTONTEXT},
{(lxb_char_t *) "ButtonBorder", 12, LXB_CSS_VALUE_BUTTONBORDER},
{(lxb_char_t *) "Field", 5, LXB_CSS_VALUE_FIELD},
{(lxb_char_t *) "FieldText", 9, LXB_CSS_VALUE_FIELDTEXT},
{(lxb_char_t *) "Highlight", 9, LXB_CSS_VALUE_HIGHLIGHT},
{(lxb_char_t *) "HighlightText", 13, LXB_CSS_VALUE_HIGHLIGHTTEXT},
{(lxb_char_t *) "SelectedItem", 12, LXB_CSS_VALUE_SELECTEDITEM},
{(lxb_char_t *) "SelectedItemText", 16, LXB_CSS_VALUE_SELECTEDITEMTEXT},
{(lxb_char_t *) "Mark", 4, LXB_CSS_VALUE_MARK},
{(lxb_char_t *) "MarkText", 8, LXB_CSS_VALUE_MARKTEXT},
{(lxb_char_t *) "GrayText", 8, LXB_CSS_VALUE_GRAYTEXT},
{(lxb_char_t *) "AccentColor", 11, LXB_CSS_VALUE_ACCENTCOLOR},
{(lxb_char_t *) "AccentColorText", 15, LXB_CSS_VALUE_ACCENTCOLORTEXT},
{(lxb_char_t *) "rgb", 3, LXB_CSS_VALUE_RGB},
{(lxb_char_t *) "rgba", 4, LXB_CSS_VALUE_RGBA},
{(lxb_char_t *) "hsl", 3, LXB_CSS_VALUE_HSL},
{(lxb_char_t *) "hsla", 4, LXB_CSS_VALUE_HSLA},
{(lxb_char_t *) "hwb", 3, LXB_CSS_VALUE_HWB},
{(lxb_char_t *) "lab", 3, LXB_CSS_VALUE_LAB},
{(lxb_char_t *) "lch", 3, LXB_CSS_VALUE_LCH},
{(lxb_char_t *) "oklab", 5, LXB_CSS_VALUE_OKLAB},
{(lxb_char_t *) "oklch", 5, LXB_CSS_VALUE_OKLCH},
{(lxb_char_t *) "color", 5, LXB_CSS_VALUE_COLOR},
{(lxb_char_t *) "ltr", 3, LXB_CSS_VALUE_LTR},
{(lxb_char_t *) "rtl", 3, LXB_CSS_VALUE_RTL},
{(lxb_char_t *) "block", 5, LXB_CSS_VALUE_BLOCK},
{(lxb_char_t *) "inline", 6, LXB_CSS_VALUE_INLINE},
{(lxb_char_t *) "run-in", 6, LXB_CSS_VALUE_RUN_IN},
{(lxb_char_t *) "flow", 4, LXB_CSS_VALUE_FLOW},
{(lxb_char_t *) "flow-root", 9, LXB_CSS_VALUE_FLOW_ROOT},
{(lxb_char_t *) "table", 5, LXB_CSS_VALUE_TABLE},
{(lxb_char_t *) "flex", 4, LXB_CSS_VALUE_FLEX},
{(lxb_char_t *) "grid", 4, LXB_CSS_VALUE_GRID},
{(lxb_char_t *) "ruby", 4, LXB_CSS_VALUE_RUBY},
{(lxb_char_t *) "list-item", 9, LXB_CSS_VALUE_LIST_ITEM},
{(lxb_char_t *) "table-row-group", 15, LXB_CSS_VALUE_TABLE_ROW_GROUP},
{(lxb_char_t *) "table-header-group", 18, LXB_CSS_VALUE_TABLE_HEADER_GROUP},
{(lxb_char_t *) "table-footer-group", 18, LXB_CSS_VALUE_TABLE_FOOTER_GROUP},
{(lxb_char_t *) "table-row", 9, LXB_CSS_VALUE_TABLE_ROW},
{(lxb_char_t *) "table-cell", 10, LXB_CSS_VALUE_TABLE_CELL},
{(lxb_char_t *) "table-column-group", 18, LXB_CSS_VALUE_TABLE_COLUMN_GROUP},
{(lxb_char_t *) "table-column", 12, LXB_CSS_VALUE_TABLE_COLUMN},
{(lxb_char_t *) "table-caption", 13, LXB_CSS_VALUE_TABLE_CAPTION},
{(lxb_char_t *) "ruby-base", 9, LXB_CSS_VALUE_RUBY_BASE},
{(lxb_char_t *) "ruby-text", 9, LXB_CSS_VALUE_RUBY_TEXT},
{(lxb_char_t *) "ruby-base-container", 19, LXB_CSS_VALUE_RUBY_BASE_CONTAINER},
{(lxb_char_t *) "ruby-text-container", 19, LXB_CSS_VALUE_RUBY_TEXT_CONTAINER},
{(lxb_char_t *) "contents", 8, LXB_CSS_VALUE_CONTENTS},
{(lxb_char_t *) "inline-block", 12, LXB_CSS_VALUE_INLINE_BLOCK},
{(lxb_char_t *) "inline-table", 12, LXB_CSS_VALUE_INLINE_TABLE},
{(lxb_char_t *) "inline-flex", 11, LXB_CSS_VALUE_INLINE_FLEX},
{(lxb_char_t *) "inline-grid", 11, LXB_CSS_VALUE_INLINE_GRID},
{(lxb_char_t *) "hanging", 7, LXB_CSS_VALUE_HANGING},
{(lxb_char_t *) "content", 7, LXB_CSS_VALUE_CONTENT},
{(lxb_char_t *) "row", 3, LXB_CSS_VALUE_ROW},
{(lxb_char_t *) "row-reverse", 11, LXB_CSS_VALUE_ROW_REVERSE},
{(lxb_char_t *) "column", 6, LXB_CSS_VALUE_COLUMN},
{(lxb_char_t *) "column-reverse", 14, LXB_CSS_VALUE_COLUMN_REVERSE},
{(lxb_char_t *) "_number", 7, LXB_CSS_VALUE__NUMBER},
{(lxb_char_t *) "nowrap", 6, LXB_CSS_VALUE_NOWRAP},
{(lxb_char_t *) "wrap", 4, LXB_CSS_VALUE_WRAP},
{(lxb_char_t *) "wrap-reverse", 12, LXB_CSS_VALUE_WRAP_REVERSE},
{(lxb_char_t *) "snap-block", 10, LXB_CSS_VALUE_SNAP_BLOCK},
{(lxb_char_t *) "start", 5, LXB_CSS_VALUE_START},
{(lxb_char_t *) "end", 3, LXB_CSS_VALUE_END},
{(lxb_char_t *) "near", 4, LXB_CSS_VALUE_NEAR},
{(lxb_char_t *) "snap-inline", 11, LXB_CSS_VALUE_SNAP_INLINE},
{(lxb_char_t *) "_integer", 8, LXB_CSS_VALUE__INTEGER},
{(lxb_char_t *) "region", 6, LXB_CSS_VALUE_REGION},
{(lxb_char_t *) "page", 4, LXB_CSS_VALUE_PAGE},
{(lxb_char_t *) "serif", 5, LXB_CSS_VALUE_SERIF},
{(lxb_char_t *) "sans-serif", 10, LXB_CSS_VALUE_SANS_SERIF},
{(lxb_char_t *) "cursive", 7, LXB_CSS_VALUE_CURSIVE},
{(lxb_char_t *) "fantasy", 7, LXB_CSS_VALUE_FANTASY},
{(lxb_char_t *) "monospace", 9, LXB_CSS_VALUE_MONOSPACE},
{(lxb_char_t *) "system-ui", 9, LXB_CSS_VALUE_SYSTEM_UI},
{(lxb_char_t *) "emoji", 5, LXB_CSS_VALUE_EMOJI},
{(lxb_char_t *) "math", 4, LXB_CSS_VALUE_MATH},
{(lxb_char_t *) "fangsong", 8, LXB_CSS_VALUE_FANGSONG},
{(lxb_char_t *) "ui-serif", 8, LXB_CSS_VALUE_UI_SERIF},
{(lxb_char_t *) "ui-sans-serif", 13, LXB_CSS_VALUE_UI_SANS_SERIF},
{(lxb_char_t *) "ui-monospace", 12, LXB_CSS_VALUE_UI_MONOSPACE},
{(lxb_char_t *) "ui-rounded", 10, LXB_CSS_VALUE_UI_ROUNDED},
{(lxb_char_t *) "xx-small", 8, LXB_CSS_VALUE_XX_SMALL},
{(lxb_char_t *) "x-small", 7, LXB_CSS_VALUE_X_SMALL},
{(lxb_char_t *) "small", 5, LXB_CSS_VALUE_SMALL},
{(lxb_char_t *) "large", 5, LXB_CSS_VALUE_LARGE},
{(lxb_char_t *) "x-large", 7, LXB_CSS_VALUE_X_LARGE},
{(lxb_char_t *) "xx-large", 8, LXB_CSS_VALUE_XX_LARGE},
{(lxb_char_t *) "xxx-large", 9, LXB_CSS_VALUE_XXX_LARGE},
{(lxb_char_t *) "larger", 6, LXB_CSS_VALUE_LARGER},
{(lxb_char_t *) "smaller", 7, LXB_CSS_VALUE_SMALLER},
{(lxb_char_t *) "normal", 6, LXB_CSS_VALUE_NORMAL},
{(lxb_char_t *) "ultra-condensed", 15, LXB_CSS_VALUE_ULTRA_CONDENSED},
{(lxb_char_t *) "extra-condensed", 15, LXB_CSS_VALUE_EXTRA_CONDENSED},
{(lxb_char_t *) "condensed", 9, LXB_CSS_VALUE_CONDENSED},
{(lxb_char_t *) "semi-condensed", 14, LXB_CSS_VALUE_SEMI_CONDENSED},
{(lxb_char_t *) "semi-expanded", 13, LXB_CSS_VALUE_SEMI_EXPANDED},
{(lxb_char_t *) "expanded", 8, LXB_CSS_VALUE_EXPANDED},
{(lxb_char_t *) "extra-expanded", 14, LXB_CSS_VALUE_EXTRA_EXPANDED},
{(lxb_char_t *) "ultra-expanded", 14, LXB_CSS_VALUE_ULTRA_EXPANDED},
{(lxb_char_t *) "italic", 6, LXB_CSS_VALUE_ITALIC},
{(lxb_char_t *) "oblique", 7, LXB_CSS_VALUE_OBLIQUE},
{(lxb_char_t *) "bold", 4, LXB_CSS_VALUE_BOLD},
{(lxb_char_t *) "bolder", 6, LXB_CSS_VALUE_BOLDER},
{(lxb_char_t *) "lighter", 7, LXB_CSS_VALUE_LIGHTER},
{(lxb_char_t *) "force-end", 9, LXB_CSS_VALUE_FORCE_END},
{(lxb_char_t *) "allow-end", 9, LXB_CSS_VALUE_ALLOW_END},
{(lxb_char_t *) "min-content", 11, LXB_CSS_VALUE_MIN_CONTENT},
{(lxb_char_t *) "max-content", 11, LXB_CSS_VALUE_MAX_CONTENT},
{(lxb_char_t *) "_angle", 6, LXB_CSS_VALUE__ANGLE},
{(lxb_char_t *) "manual", 6, LXB_CSS_VALUE_MANUAL},
{(lxb_char_t *) "loose", 5, LXB_CSS_VALUE_LOOSE},
{(lxb_char_t *) "strict", 6, LXB_CSS_VALUE_STRICT},
{(lxb_char_t *) "anywhere", 8, LXB_CSS_VALUE_ANYWHERE},
{(lxb_char_t *) "visible", 7, LXB_CSS_VALUE_VISIBLE},
{(lxb_char_t *) "clip", 4, LXB_CSS_VALUE_CLIP},
{(lxb_char_t *) "scroll", 6, LXB_CSS_VALUE_SCROLL},
{(lxb_char_t *) "break-word", 10, LXB_CSS_VALUE_BREAK_WORD},
{(lxb_char_t *) "static", 6, LXB_CSS_VALUE_STATIC},
{(lxb_char_t *) "relative", 8, LXB_CSS_VALUE_RELATIVE},
{(lxb_char_t *) "absolute", 8, LXB_CSS_VALUE_ABSOLUTE},
{(lxb_char_t *) "sticky", 6, LXB_CSS_VALUE_STICKY},
{(lxb_char_t *) "fixed", 5, LXB_CSS_VALUE_FIXED},
{(lxb_char_t *) "justify", 7, LXB_CSS_VALUE_JUSTIFY},
{(lxb_char_t *) "match-parent", 12, LXB_CSS_VALUE_MATCH_PARENT},
{(lxb_char_t *) "justify-all", 11, LXB_CSS_VALUE_JUSTIFY_ALL},
{(lxb_char_t *) "all", 3, LXB_CSS_VALUE_ALL},
{(lxb_char_t *) "digits", 6, LXB_CSS_VALUE_DIGITS},
{(lxb_char_t *) "underline", 9, LXB_CSS_VALUE_UNDERLINE},
{(lxb_char_t *) "overline", 8, LXB_CSS_VALUE_OVERLINE},
{(lxb_char_t *) "line-through", 12, LXB_CSS_VALUE_LINE_THROUGH},
{(lxb_char_t *) "blink", 5, LXB_CSS_VALUE_BLINK},
{(lxb_char_t *) "wavy", 4, LXB_CSS_VALUE_WAVY},
{(lxb_char_t *) "each-line", 9, LXB_CSS_VALUE_EACH_LINE},
{(lxb_char_t *) "inter-word", 10, LXB_CSS_VALUE_INTER_WORD},
{(lxb_char_t *) "inter-character", 15, LXB_CSS_VALUE_INTER_CHARACTER},
{(lxb_char_t *) "mixed", 5, LXB_CSS_VALUE_MIXED},
{(lxb_char_t *) "upright", 7, LXB_CSS_VALUE_UPRIGHT},
{(lxb_char_t *) "sideways", 8, LXB_CSS_VALUE_SIDEWAYS},
{(lxb_char_t *) "ellipsis", 8, LXB_CSS_VALUE_ELLIPSIS},
{(lxb_char_t *) "capitalize", 10, LXB_CSS_VALUE_CAPITALIZE},
{(lxb_char_t *) "uppercase", 9, LXB_CSS_VALUE_UPPERCASE},
{(lxb_char_t *) "lowercase", 9, LXB_CSS_VALUE_LOWERCASE},
{(lxb_char_t *) "full-width", 10, LXB_CSS_VALUE_FULL_WIDTH},
{(lxb_char_t *) "full-size-kana", 14, LXB_CSS_VALUE_FULL_SIZE_KANA},
{(lxb_char_t *) "embed", 5, LXB_CSS_VALUE_EMBED},
{(lxb_char_t *) "isolate", 7, LXB_CSS_VALUE_ISOLATE},
{(lxb_char_t *) "bidi-override", 13, LXB_CSS_VALUE_BIDI_OVERRIDE},
{(lxb_char_t *) "isolate-override", 16, LXB_CSS_VALUE_ISOLATE_OVERRIDE},
{(lxb_char_t *) "plaintext", 9, LXB_CSS_VALUE_PLAINTEXT},
{(lxb_char_t *) "collapse", 8, LXB_CSS_VALUE_COLLAPSE},
{(lxb_char_t *) "pre", 3, LXB_CSS_VALUE_PRE},
{(lxb_char_t *) "pre-wrap", 8, LXB_CSS_VALUE_PRE_WRAP},
{(lxb_char_t *) "break-spaces", 12, LXB_CSS_VALUE_BREAK_SPACES},
{(lxb_char_t *) "pre-line", 8, LXB_CSS_VALUE_PRE_LINE},
{(lxb_char_t *) "keep-all", 8, LXB_CSS_VALUE_KEEP_ALL},
{(lxb_char_t *) "break-all", 9, LXB_CSS_VALUE_BREAK_ALL},
{(lxb_char_t *) "both", 4, LXB_CSS_VALUE_BOTH},
{(lxb_char_t *) "minimum", 7, LXB_CSS_VALUE_MINIMUM},
{(lxb_char_t *) "maximum", 7, LXB_CSS_VALUE_MAXIMUM},
{(lxb_char_t *) "clear", 5, LXB_CSS_VALUE_CLEAR},
{(lxb_char_t *) "horizontal-tb", 13, LXB_CSS_VALUE_HORIZONTAL_TB},
{(lxb_char_t *) "vertical-rl", 11, LXB_CSS_VALUE_VERTICAL_RL},
{(lxb_char_t *) "vertical-lr", 11, LXB_CSS_VALUE_VERTICAL_LR},
{(lxb_char_t *) "sideways-rl", 11, LXB_CSS_VALUE_SIDEWAYS_RL},
{(lxb_char_t *) "sideways-lr", 11, LXB_CSS_VALUE_SIDEWAYS_LR}
};
static const lexbor_shs_entry_t lxb_css_value_shs[373] =
{
{NULL, NULL, 253, 0},
{"salmon", (void *) LXB_CSS_VALUE_SALMON, 6, 2},
{"canvas", (void *) LXB_CSS_VALUE_CANVAS, 6, 4},
{"allow-end", (void *) LXB_CSS_VALUE_ALLOW_END, 9, 0},
{"static", (void *) LXB_CSS_VALUE_STATIC, 6, 5},
{"sticky", (void *) LXB_CSS_VALUE_STICKY, 6, 0},
{"darkviolet", (void *) LXB_CSS_VALUE_DARKVIOLET, 10, 0},
{"blue", (void *) LXB_CSS_VALUE_BLUE, 4, 1},
{"end", (void *) LXB_CSS_VALUE_END, 3, 24},
{"middle", (void *) LXB_CSS_VALUE_MIDDLE, 6, 32},
{"rgb", (void *) LXB_CSS_VALUE_RGB, 3, 59},
{"baseline", (void *) LXB_CSS_VALUE_BASELINE, 8, 69},
{"mistyrose", (void *) LXB_CSS_VALUE_MISTYROSE, 9, 71},
{"expanded", (void *) LXB_CSS_VALUE_EXPANDED, 8, 92},
{"space-between", (void *) LXB_CSS_VALUE_SPACE_BETWEEN, 13, 0},
{"mediumpurple", (void *) LXB_CSS_VALUE_MEDIUMPURPLE, 12, 99},
{"bidi-override", (void *) LXB_CSS_VALUE_BIDI_OVERRIDE, 13, 0},
{"bold", (void *) LXB_CSS_VALUE_BOLD, 4, 103},
{"mixed", (void *) LXB_CSS_VALUE_MIXED, 5, 105},
{"extra-expanded", (void *) LXB_CSS_VALUE_EXTRA_EXPANDED, 14, 119},
{"auto", (void *) LXB_CSS_VALUE_AUTO, 4, 129},
{"teal", (void *) LXB_CSS_VALUE_TEAL, 4, 130},
{"lab", (void *) LXB_CSS_VALUE_LAB, 3, 131},
{"break-word", (void *) LXB_CSS_VALUE_BREAK_WORD, 10, 0},
{"beige", (void *) LXB_CSS_VALUE_BEIGE, 5, 0},
{"mediumorchid", (void *) LXB_CSS_VALUE_MEDIUMORCHID, 12, 0},
{"vertical-lr", (void *) LXB_CSS_VALUE_VERTICAL_LR, 11, 0},
{"table-cell", (void *) LXB_CSS_VALUE_TABLE_CELL, 10, 135},
{"pre-wrap", (void *) LXB_CSS_VALUE_PRE_WRAP, 8, 136},
{"super", (void *) LXB_CSS_VALUE_SUPER, 5, 0},
{"silver", (void *) LXB_CSS_VALUE_SILVER, 6, 137},
{"hsl", (void *) LXB_CSS_VALUE_HSL, 3, 140},
{"bisque", (void *) LXB_CSS_VALUE_BISQUE, 6, 53},
{"darkblue", (void *) LXB_CSS_VALUE_DARKBLUE, 8, 0},
{"hex", (void *) LXB_CSS_VALUE_HEX, 3, 0},
{"darkorange", (void *) LXB_CSS_VALUE_DARKORANGE, 10, 143},
{"lightcoral", (void *) LXB_CSS_VALUE_LIGHTCORAL, 10, 145},
{"table-row", (void *) LXB_CSS_VALUE_TABLE_ROW, 9, 0},
{"ridge", (void *) LXB_CSS_VALUE_RIDGE, 5, 149},
{"violet", (void *) LXB_CSS_VALUE_VIOLET, 6, 156},
{"italic", (void *) LXB_CSS_VALUE_ITALIC, 6, 157},
{"relative", (void *) LXB_CSS_VALUE_RELATIVE, 8, 0},
{"royalblue", (void *) LXB_CSS_VALUE_ROYALBLUE, 9, 179},
{"highlighttext", (void *) LXB_CSS_VALUE_HIGHLIGHTTEXT, 13, 0},
{"visitedtext", (void *) LXB_CSS_VALUE_VISITEDTEXT, 11, 193},
{"ideographic", (void *) LXB_CSS_VALUE_IDEOGRAPHIC, 11, 0},
{"outset", (void *) LXB_CSS_VALUE_OUTSET, 6, 194},
{"azure", (void *) LXB_CSS_VALUE_AZURE, 5, 0},
{"pink", (void *) LXB_CSS_VALUE_PINK, 4, 0},
{"near", (void *) LXB_CSS_VALUE_NEAR, 4, 0},
{"magenta", (void *) LXB_CSS_VALUE_MAGENTA, 7, 204},
{"aliceblue", (void *) LXB_CSS_VALUE_ALICEBLUE, 9, 0},
{"aquamarine", (void *) LXB_CSS_VALUE_AQUAMARINE, 10, 0},
{"seagreen", (void *) LXB_CSS_VALUE_SEAGREEN, 8, 55},
{"antiquewhite", (void *) LXB_CSS_VALUE_ANTIQUEWHITE, 12, 0},
{"contents", (void *) LXB_CSS_VALUE_CONTENTS, 8, 56},
{"lightpink", (void *) LXB_CSS_VALUE_LIGHTPINK, 9, 0},
{"snap-block", (void *) LXB_CSS_VALUE_SNAP_BLOCK, 10, 0},
{"white", (void *) LXB_CSS_VALUE_WHITE, 5, 0},
{"embed", (void *) LXB_CSS_VALUE_EMBED, 5, 66},
{"first", (void *) LXB_CSS_VALUE_FIRST, 5, 211},
{"groove", (void *) LXB_CSS_VALUE_GROOVE, 6, 212},
{"normal", (void *) LXB_CSS_VALUE_NORMAL, 6, 0},
{"whitesmoke", (void *) LXB_CSS_VALUE_WHITESMOKE, 10, 0},
{"fieldtext", (void *) LXB_CSS_VALUE_FIELDTEXT, 9, 221},
{"flex-start", (void *) LXB_CSS_VALUE_FLEX_START, 10, 227},
{"slategray", (void *) LXB_CSS_VALUE_SLATEGRAY, 9, 67},
{"slategrey", (void *) LXB_CSS_VALUE_SLATEGREY, 9, 68},
{"darkmagenta", (void *) LXB_CSS_VALUE_DARKMAGENTA, 11, 0},
{"sandybrown", (void *) LXB_CSS_VALUE_SANDYBROWN, 10, 0},
{"field", (void *) LXB_CSS_VALUE_FIELD, 5, 234},
{"monospace", (void *) LXB_CSS_VALUE_MONOSPACE, 9, 78},
{"color", (void *) LXB_CSS_VALUE_COLOR, 5, 236},
{"center", (void *) LXB_CSS_VALUE_CENTER, 6, 240},
{"force-end", (void *) LXB_CSS_VALUE_FORCE_END, 9, 0},
{"solid", (void *) LXB_CSS_VALUE_SOLID, 5, 243},
{"gold", (void *) LXB_CSS_VALUE_GOLD, 4, 248},
{"peachpuff", (void *) LXB_CSS_VALUE_PEACHPUFF, 9, 0},
{"saddlebrown", (void *) LXB_CSS_VALUE_SADDLEBROWN, 11, 86},
{"inline", (void *) LXB_CSS_VALUE_INLINE, 6, 254},
{"isolate", (void *) LXB_CSS_VALUE_ISOLATE, 7, 0},
{"goldenrod", (void *) LXB_CSS_VALUE_GOLDENROD, 9, 0},
{"cyan", (void *) LXB_CSS_VALUE_CYAN, 4, 256},
{"linen", (void *) LXB_CSS_VALUE_LINEN, 5, 257},
{"column", (void *) LXB_CSS_VALUE_COLUMN, 6, 258},
{"crimson", (void *) LXB_CSS_VALUE_CRIMSON, 7, 259},
{"springgreen", (void *) LXB_CSS_VALUE_SPRINGGREEN, 11, 0},
{"lawngreen", (void *) LXB_CSS_VALUE_LAWNGREEN, 9, 260},
{"lightgreen", (void *) LXB_CSS_VALUE_LIGHTGREEN, 10, 0},
{"plum", (void *) LXB_CSS_VALUE_PLUM, 4, 262},
{"initial", (void *) LXB_CSS_VALUE_INITIAL, 7, 264},
{"lightseagreen", (void *) LXB_CSS_VALUE_LIGHTSEAGREEN, 13, 0},
{"mediumblue", (void *) LXB_CSS_VALUE_MEDIUMBLUE, 10, 93},
{"activetext", (void *) LXB_CSS_VALUE_ACTIVETEXT, 10, 94},
{"buttonface", (void *) LXB_CSS_VALUE_BUTTONFACE, 10, 96},
{"each-line", (void *) LXB_CSS_VALUE_EACH_LINE, 9, 0},
{"greenyellow", (void *) LXB_CSS_VALUE_GREENYELLOW, 11, 0},
{"hanging", (void *) LXB_CSS_VALUE_HANGING, 7, 0},
{"hotpink", (void *) LXB_CSS_VALUE_HOTPINK, 7, 0},
{"midnightblue", (void *) LXB_CSS_VALUE_MIDNIGHTBLUE, 12, 0},
{"stretch", (void *) LXB_CSS_VALUE_STRETCH, 7, 0},
{"lime", (void *) LXB_CSS_VALUE_LIME, 4, 266},
{"unset", (void *) LXB_CSS_VALUE_UNSET, 5, 267},
{"x-small", (void *) LXB_CSS_VALUE_X_SMALL, 7, 0},
{"upright", (void *) LXB_CSS_VALUE_UPRIGHT, 7, 0},
{"xx-small", (void *) LXB_CSS_VALUE_XX_SMALL, 8, 108},
{"lightblue", (void *) LXB_CSS_VALUE_LIGHTBLUE, 9, 270},
{"aqua", (void *) LXB_CSS_VALUE_AQUA, 4, 271},
{"mediumslateblue", (void *) LXB_CSS_VALUE_MEDIUMSLATEBLUE, 15, 110},
{"lightskyblue", (void *) LXB_CSS_VALUE_LIGHTSKYBLUE, 12, 0},
{"mediumturquoise", (void *) LXB_CSS_VALUE_MEDIUMTURQUOISE, 15, 113},
{"plaintext", (void *) LXB_CSS_VALUE_PLAINTEXT, 9, 272},
{"justify-all", (void *) LXB_CSS_VALUE_JUSTIFY_ALL, 11, 0},
{"accentcolortext", (void *) LXB_CSS_VALUE_ACCENTCOLORTEXT, 15, 0},
{"tan", (void *) LXB_CSS_VALUE_TAN, 3, 273},
{"thin", (void *) LXB_CSS_VALUE_THIN, 4, 274},
{"blueviolet", (void *) LXB_CSS_VALUE_BLUEVIOLET, 10, 275},
{"run-in", (void *) LXB_CSS_VALUE_RUN_IN, 6, 276},
{"match-parent", (void *) LXB_CSS_VALUE_MATCH_PARENT, 12, 0},
{"mediumaquamarine", (void *) LXB_CSS_VALUE_MEDIUMAQUAMARINE, 16, 0},
{"snow", (void *) LXB_CSS_VALUE_SNOW, 4, 280},
{"small", (void *) LXB_CSS_VALUE_SMALL, 5, 0},
{"sienna", (void *) LXB_CSS_VALUE_SIENNA, 6, 283},
{"table-column", (void *) LXB_CSS_VALUE_TABLE_COLUMN, 12, 0},
{"seashell", (void *) LXB_CSS_VALUE_SEASHELL, 8, 286},
{"lightslategray", (void *) LXB_CSS_VALUE_LIGHTSLATEGRAY, 14, 287},
{"ruby", (void *) LXB_CSS_VALUE_RUBY, 4, 0},
{"sideways-rl", (void *) LXB_CSS_VALUE_SIDEWAYS_RL, 11, 0},
{"all", (void *) LXB_CSS_VALUE_ALL, 3, 288},
{"extra-condensed", (void *) LXB_CSS_VALUE_EXTRA_CONDENSED, 15, 0},
{"indigo", (void *) LXB_CSS_VALUE_INDIGO, 6, 0},
{"block-end", (void *) LXB_CSS_VALUE_BLOCK_END, 9, 134},
{"bolder", (void *) LXB_CSS_VALUE_BOLDER, 6, 0},
{"forestgreen", (void *) LXB_CSS_VALUE_FORESTGREEN, 11, 0},
{"burlywood", (void *) LXB_CSS_VALUE_BURLYWOOD, 9, 0},
{"blanchedalmond", (void *) LXB_CSS_VALUE_BLANCHEDALMOND, 14, 0},
{"mediumvioletred", (void *) LXB_CSS_VALUE_MEDIUMVIOLETRED, 15, 0},
{"papayawhip", (void *) LXB_CSS_VALUE_PAPAYAWHIP, 10, 0},
{"buttonborder", (void *) LXB_CSS_VALUE_BUTTONBORDER, 12, 0},
{"nowrap", (void *) LXB_CSS_VALUE_NOWRAP, 6, 0},
{"double", (void *) LXB_CSS_VALUE_DOUBLE, 6, 141},
{"smaller", (void *) LXB_CSS_VALUE_SMALLER, 7, 142},
{"cornsilk", (void *) LXB_CSS_VALUE_CORNSILK, 8, 0},
{"dodgerblue", (void *) LXB_CSS_VALUE_DODGERBLUE, 10, 144},
{"sideways-lr", (void *) LXB_CSS_VALUE_SIDEWAYS_LR, 11, 0},
{"deepskyblue", (void *) LXB_CSS_VALUE_DEEPSKYBLUE, 11, 0},
{"skyblue", (void *) LXB_CSS_VALUE_SKYBLUE, 7, 0},
{"gainsboro", (void *) LXB_CSS_VALUE_GAINSBORO, 9, 0},
{"khaki", (void *) LXB_CSS_VALUE_KHAKI, 5, 290},
{"firebrick", (void *) LXB_CSS_VALUE_FIREBRICK, 9, 153},
{"snap-inline", (void *) LXB_CSS_VALUE_SNAP_INLINE, 11, 0},
{"dotted", (void *) LXB_CSS_VALUE_DOTTED, 6, 293},
{"flow", (void *) LXB_CSS_VALUE_FLOW, 4, 295},
{"darkslateblue", (void *) LXB_CSS_VALUE_DARKSLATEBLUE, 13, 154},
{"darkturquoise", (void *) LXB_CSS_VALUE_DARKTURQUOISE, 13, 0},
{"hwb", (void *) LXB_CSS_VALUE_HWB, 3, 297},
{"highlight", (void *) LXB_CSS_VALUE_HIGHLIGHT, 9, 0},
{"palegoldenrod", (void *) LXB_CSS_VALUE_PALEGOLDENROD, 13, 159},
{"visible", (void *) LXB_CSS_VALUE_VISIBLE, 7, 298},
{"palevioletred", (void *) LXB_CSS_VALUE_PALEVIOLETRED, 13, 0},
{"green", (void *) LXB_CSS_VALUE_GREEN, 5, 299},
{"hidden", (void *) LXB_CSS_VALUE_HIDDEN, 6, 300},
{"emoji", (void *) LXB_CSS_VALUE_EMOJI, 5, 301},
{"darkgray", (void *) LXB_CSS_VALUE_DARKGRAY, 8, 303},
{"tomato", (void *) LXB_CSS_VALUE_TOMATO, 6, 304},
{"xx-large", (void *) LXB_CSS_VALUE_XX_LARGE, 8, 305},
{"fangsong", (void *) LXB_CSS_VALUE_FANGSONG, 8, 306},
{"start", (void *) LXB_CSS_VALUE_START, 5, 0},
{"right", (void *) LXB_CSS_VALUE_RIGHT, 5, 307},
{"revert", (void *) LXB_CSS_VALUE_REVERT, 6, 0},
{"wavy", (void *) LXB_CSS_VALUE_WAVY, 4, 0},
{"rgba", (void *) LXB_CSS_VALUE_RGBA, 4, 310},
{"maroon", (void *) LXB_CSS_VALUE_MAROON, 6, 313},
{"olive", (void *) LXB_CSS_VALUE_OLIVE, 5, 314},
{"orange", (void *) LXB_CSS_VALUE_ORANGE, 6, 315},
{"oldlace", (void *) LXB_CSS_VALUE_OLDLACE, 7, 317},
{"overline", (void *) LXB_CSS_VALUE_OVERLINE, 8, 320},
{"pre", (void *) LXB_CSS_VALUE_PRE, 3, 322},
{"lch", (void *) LXB_CSS_VALUE_LCH, 3, 323},
{"ruby-base", (void *) LXB_CSS_VALUE_RUBY_BASE, 9, 0},
{"purple", (void *) LXB_CSS_VALUE_PURPLE, 6, 325},
{"rtl", (void *) LXB_CSS_VALUE_RTL, 3, 328},
{"bottom", (void *) LXB_CSS_VALUE_BOTTOM, 6, 329},
{"flex", (void *) LXB_CSS_VALUE_FLEX, 4, 331},
{"powderblue", (void *) LXB_CSS_VALUE_POWDERBLUE, 10, 0},
{"ltr", (void *) LXB_CSS_VALUE_LTR, 3, 334},
{"ultra-condensed", (void *) LXB_CSS_VALUE_ULTRA_CONDENSED, 15, 0},
{"line-through", (void *) LXB_CSS_VALUE_LINE_THROUGH, 12, 336},
{"sub", (void *) LXB_CSS_VALUE_SUB, 3, 337},
{"lighter", (void *) LXB_CSS_VALUE_LIGHTER, 7, 340},
{"lavender", (void *) LXB_CSS_VALUE_LAVENDER, 8, 341},
{"inline-grid", (void *) LXB_CSS_VALUE_INLINE_GRID, 11, 0},
{"row", (void *) LXB_CSS_VALUE_ROW, 3, 343},
{"row-reverse", (void *) LXB_CSS_VALUE_ROW_REVERSE, 11, 0},
{"rebeccapurple", (void *) LXB_CSS_VALUE_REBECCAPURPLE, 13, 0},
{"content", (void *) LXB_CSS_VALUE_CONTENT, 7, 344},
{"red", (void *) LXB_CSS_VALUE_RED, 3, 0},
{"selecteditem", (void *) LXB_CSS_VALUE_SELECTEDITEM, 12, 0},
{"oklch", (void *) LXB_CSS_VALUE_OKLCH, 5, 346},
{"table", (void *) LXB_CSS_VALUE_TABLE, 5, 348},
{"mark", (void *) LXB_CSS_VALUE_MARK, 4, 0},
{"black", (void *) LXB_CSS_VALUE_BLACK, 5, 349},
{"inline-block", (void *) LXB_CSS_VALUE_INLINE_BLOCK, 12, 0},
{"clip", (void *) LXB_CSS_VALUE_CLIP, 4, 352},
{"anywhere", (void *) LXB_CSS_VALUE_ANYWHERE, 8, 205},
{"absolute", (void *) LXB_CSS_VALUE_ABSOLUTE, 8, 0},
{"wheat", (void *) LXB_CSS_VALUE_WHEAT, 5, 0},
{"underline", (void *) LXB_CSS_VALUE_UNDERLINE, 9, 353},
{"top", (void *) LXB_CSS_VALUE_TOP, 3, 0},
{"alphabetic", (void *) LXB_CSS_VALUE_ALPHABETIC, 10, 0},
{"ui-monospace", (void *) LXB_CSS_VALUE_UI_MONOSPACE, 12, 0},
{"darkkhaki", (void *) LXB_CSS_VALUE_DARKKHAKI, 9, 0},
{"graytext", (void *) LXB_CSS_VALUE_GRAYTEXT, 8, 214},
{"serif", (void *) LXB_CSS_VALUE_SERIF, 5, 354},
{"list-item", (void *) LXB_CSS_VALUE_LIST_ITEM, 9, 0},
{"coral", (void *) LXB_CSS_VALUE_CORAL, 5, 355},
{"ellipsis", (void *) LXB_CSS_VALUE_ELLIPSIS, 8, 0},
{"central", (void *) LXB_CSS_VALUE_CENTRAL, 7, 357},
{"darkcyan", (void *) LXB_CSS_VALUE_DARKCYAN, 8, 358},
{"hsla", (void *) LXB_CSS_VALUE_HSLA, 4, 359},
{"darksalmon", (void *) LXB_CSS_VALUE_DARKSALMON, 10, 360},
{"flow-root", (void *) LXB_CSS_VALUE_FLOW_ROOT, 9, 0},
{"darkseagreen", (void *) LXB_CSS_VALUE_DARKSEAGREEN, 12, 0},
{"table-header-group", (void *) LXB_CSS_VALUE_TABLE_HEADER_GROUP, 18, 361},
{"darkolivegreen", (void *) LXB_CSS_VALUE_DARKOLIVEGREEN, 14, 0},
{"gray", (void *) LXB_CSS_VALUE_GRAY, 4, 363},
{"_angle", (void *) LXB_CSS_VALUE__ANGLE, 6, 0},
{"ghostwhite", (void *) LXB_CSS_VALUE_GHOSTWHITE, 10, 229},
{"thick", (void *) LXB_CSS_VALUE_THICK, 5, 0},
{"wrap-reverse", (void *) LXB_CSS_VALUE_WRAP_REVERSE, 12, 0},
{"math", (void *) LXB_CSS_VALUE_MATH, 4, 365},
{"_length", (void *) LXB_CSS_VALUE__LENGTH, 7, 366},
{"fuchsia", (void *) LXB_CSS_VALUE_FUCHSIA, 7, 0},
{"wrap", (void *) LXB_CSS_VALUE_WRAP, 4, 367},
{"fixed", (void *) LXB_CSS_VALUE_FIXED, 5, 235},
{"lightyellow", (void *) LXB_CSS_VALUE_LIGHTYELLOW, 11, 0},
{"clear", (void *) LXB_CSS_VALUE_CLEAR, 5, 237},
{"deeppink", (void *) LXB_CSS_VALUE_DEEPPINK, 8, 0},
{"last", (void *) LXB_CSS_VALUE_LAST, 4, 368},
{"full-size-kana", (void *) LXB_CSS_VALUE_FULL_SIZE_KANA, 14, 0},
{"flex-end", (void *) LXB_CSS_VALUE_FLEX_END, 8, 0},
{"palegreen", (void *) LXB_CSS_VALUE_PALEGREEN, 9, 370},
{"linktext", (void *) LXB_CSS_VALUE_LINKTEXT, 8, 0},
{"text-bottom", (void *) LXB_CSS_VALUE_TEXT_BOTTOM, 11, 245},
{"inset", (void *) LXB_CSS_VALUE_INSET, 5, 0},
{"inline-flex", (void *) LXB_CSS_VALUE_INLINE_FLEX, 11, 0},
{"inherit", (void *) LXB_CSS_VALUE_INHERIT, 7, 0},
{"navy", (void *) LXB_CSS_VALUE_NAVY, 4, 0},
{"grid", (void *) LXB_CSS_VALUE_GRID, 4, 252},
{"ruby-base-container", (void *) LXB_CSS_VALUE_RUBY_BASE_CONTAINER, 19, 371},
{"orchid", (void *) LXB_CSS_VALUE_ORCHID, 6, 0},
{"inline-start", (void *) LXB_CSS_VALUE_INLINE_START, 12, 0},
{"border-box", (void *) LXB_CSS_VALUE_BORDER_BOX, 10, 0},
{"peru", (void *) LXB_CSS_VALUE_PERU, 4, 372},
{"currentcolor", (void *) LXB_CSS_VALUE_CURRENTCOLOR, 12, 255},
{"lightgoldenrodyellow", (void *) LXB_CSS_VALUE_LIGHTGOLDENRODYELLOW, 20, 0},
{"space-around", (void *) LXB_CSS_VALUE_SPACE_AROUND, 12, 0},
{"semi-expanded", (void *) LXB_CSS_VALUE_SEMI_EXPANDED, 13, 0},
{"semi-condensed", (void *) LXB_CSS_VALUE_SEMI_CONDENSED, 14, 0},
{"inline-table", (void *) LXB_CSS_VALUE_INLINE_TABLE, 12, 0},
{"lightcyan", (void *) LXB_CSS_VALUE_LIGHTCYAN, 9, 261},
{"limegreen", (void *) LXB_CSS_VALUE_LIMEGREEN, 9, 0},
{"lightsalmon", (void *) LXB_CSS_VALUE_LIGHTSALMON, 11, 263},
{"isolate-override", (void *) LXB_CSS_VALUE_ISOLATE_OVERRIDE, 16, 0},
{"keep-all", (void *) LXB_CSS_VALUE_KEEP_ALL, 8, 265},
{"lemonchiffon", (void *) LXB_CSS_VALUE_LEMONCHIFFON, 12, 0},
{"sideways", (void *) LXB_CSS_VALUE_SIDEWAYS, 8, 0},
{"large", (void *) LXB_CSS_VALUE_LARGE, 5, 268},
{"loose", (void *) LXB_CSS_VALUE_LOOSE, 5, 269},
{"honeydew", (void *) LXB_CSS_VALUE_HONEYDEW, 8, 0},
{"lowercase", (void *) LXB_CSS_VALUE_LOWERCASE, 9, 0},
{"floralwhite", (void *) LXB_CSS_VALUE_FLORALWHITE, 11, 0},
{"lightsteelblue", (void *) LXB_CSS_VALUE_LIGHTSTEELBLUE, 14, 0},
{"marktext", (void *) LXB_CSS_VALUE_MARKTEXT, 8, 0},
{"none", (void *) LXB_CSS_VALUE_NONE, 4, 0},
{"buttontext", (void *) LXB_CSS_VALUE_BUTTONTEXT, 10, 0},
{"region", (void *) LXB_CSS_VALUE_REGION, 6, 277},
{"block-start", (void *) LXB_CSS_VALUE_BLOCK_START, 11, 278},
{"min-content", (void *) LXB_CSS_VALUE_MIN_CONTENT, 11, 279},
{"max-content", (void *) LXB_CSS_VALUE_MAX_CONTENT, 11, 0},
{"lightgray", (void *) LXB_CSS_VALUE_LIGHTGRAY, 9, 281},
{"lightgrey", (void *) LXB_CSS_VALUE_LIGHTGREY, 9, 282},
{"rosybrown", (void *) LXB_CSS_VALUE_ROSYBROWN, 9, 0},
{"scroll", (void *) LXB_CSS_VALUE_SCROLL, 6, 284},
{"digits", (void *) LXB_CSS_VALUE_DIGITS, 6, 285},
{"navajowhite", (void *) LXB_CSS_VALUE_NAVAJOWHITE, 11, 0},
{"table-caption", (void *) LXB_CSS_VALUE_TABLE_CAPTION, 13, 0},
{"lightslategrey", (void *) LXB_CSS_VALUE_LIGHTSLATEGREY, 14, 0},
{"yellow", (void *) LXB_CSS_VALUE_YELLOW, 6, 289},
{"break-spaces", (void *) LXB_CSS_VALUE_BREAK_SPACES, 12, 0},
{"oklab", (void *) LXB_CSS_VALUE_OKLAB, 5, 291},
{"slateblue", (void *) LXB_CSS_VALUE_SLATEBLUE, 9, 292},
{"steelblue", (void *) LXB_CSS_VALUE_STEELBLUE, 9, 0},
{"dashed", (void *) LXB_CSS_VALUE_DASHED, 6, 294},
{"transparent", (void *) LXB_CSS_VALUE_TRANSPARENT, 11, 0},
{"darkred", (void *) LXB_CSS_VALUE_DARKRED, 7, 296},
{"olivedrab", (void *) LXB_CSS_VALUE_OLIVEDRAB, 9, 0},
{"darkorchid", (void *) LXB_CSS_VALUE_DARKORCHID, 10, 0},
{"darkgoldenrod", (void *) LXB_CSS_VALUE_DARKGOLDENROD, 13, 0},
{"_number", (void *) LXB_CSS_VALUE__NUMBER, 7, 0},
{"_integer", (void *) LXB_CSS_VALUE__INTEGER, 8, 0},
{"dimgray", (void *) LXB_CSS_VALUE_DIMGRAY, 7, 302},
{"dimgrey", (void *) LXB_CSS_VALUE_DIMGREY, 7, 0},
{"darkgrey", (void *) LXB_CSS_VALUE_DARKGREY, 8, 0},
{"x-large", (void *) LXB_CSS_VALUE_X_LARGE, 7, 0},
{"horizontal-tb", (void *) LXB_CSS_VALUE_HORIZONTAL_TB, 13, 0},
{"xxx-large", (void *) LXB_CSS_VALUE_XXX_LARGE, 9, 0},
{"strict", (void *) LXB_CSS_VALUE_STRICT, 6, 308},
{"darkslategray", (void *) LXB_CSS_VALUE_DARKSLATEGRAY, 13, 309},
{"darkslategrey", (void *) LXB_CSS_VALUE_DARKSLATEGREY, 13, 0},
{"brown", (void *) LXB_CSS_VALUE_BROWN, 5, 311},
{"system-ui", (void *) LXB_CSS_VALUE_SYSTEM_UI, 9, 312},
{"accentcolor", (void *) LXB_CSS_VALUE_ACCENTCOLOR, 11, 0},
{"ruby-text", (void *) LXB_CSS_VALUE_RUBY_TEXT, 9, 0},
{"cursive", (void *) LXB_CSS_VALUE_CURSIVE, 7, 0},
{"moccasin", (void *) LXB_CSS_VALUE_MOCCASIN, 8, 316},
{"collapse", (void *) LXB_CSS_VALUE_COLLAPSE, 8, 0},
{"oblique", (void *) LXB_CSS_VALUE_OBLIQUE, 7, 318},
{"cadetblue", (void *) LXB_CSS_VALUE_CADETBLUE, 9, 319},
{"chocolate", (void *) LXB_CSS_VALUE_CHOCOLATE, 9, 0},
{"chartreuse", (void *) LXB_CSS_VALUE_CHARTREUSE, 10, 321},
{"capitalize", (void *) LXB_CSS_VALUE_CAPITALIZE, 10, 0},
{"yellowgreen", (void *) LXB_CSS_VALUE_YELLOWGREEN, 11, 0},
{"page", (void *) LXB_CSS_VALUE_PAGE, 4, 324},
{"selecteditemtext", (void *) LXB_CSS_VALUE_SELECTEDITEMTEXT, 16, 0},
{"cornflowerblue", (void *) LXB_CSS_VALUE_CORNFLOWERBLUE, 14, 326},
{"mediumseagreen", (void *) LXB_CSS_VALUE_MEDIUMSEAGREEN, 14, 327},
{"column-reverse", (void *) LXB_CSS_VALUE_COLUMN_REVERSE, 14, 0},
{"ui-rounded", (void *) LXB_CSS_VALUE_UI_ROUNDED, 10, 0},
{"medium", (void *) LXB_CSS_VALUE_MEDIUM, 6, 330},
{"pre-line", (void *) LXB_CSS_VALUE_PRE_LINE, 8, 0},
{"minimum", (void *) LXB_CSS_VALUE_MINIMUM, 7, 332},
{"maximum", (void *) LXB_CSS_VALUE_MAXIMUM, 7, 333},
{"mediumspringgreen", (void *) LXB_CSS_VALUE_MEDIUMSPRINGGREEN, 17, 0},
{"mintcream", (void *) LXB_CSS_VALUE_MINTCREAM, 9, 335},
{"ultra-expanded", (void *) LXB_CSS_VALUE_ULTRA_EXPANDED, 14, 0},
{"paleturquoise", (void *) LXB_CSS_VALUE_PALETURQUOISE, 13, 0},
{"larger", (void *) LXB_CSS_VALUE_LARGER, 6, 338},
{"content-box", (void *) LXB_CSS_VALUE_CONTENT_BOX, 11, 339},
{"lavenderblush", (void *) LXB_CSS_VALUE_LAVENDERBLUSH, 13, 0},
{"indianred", (void *) LXB_CSS_VALUE_INDIANRED, 9, 0},
{"inline-end", (void *) LXB_CSS_VALUE_INLINE_END, 10, 342},
{"inter-word", (void *) LXB_CSS_VALUE_INTER_WORD, 10, 0},
{"manual", (void *) LXB_CSS_VALUE_MANUAL, 6, 0},
{"justify", (void *) LXB_CSS_VALUE_JUSTIFY, 7, 345},
{"break-all", (void *) LXB_CSS_VALUE_BREAK_ALL, 9, 0},
{"canvastext", (void *) LXB_CSS_VALUE_CANVASTEXT, 10, 347},
{"mathematical", (void *) LXB_CSS_VALUE_MATHEMATICAL, 12, 0},
{"full-width", (void *) LXB_CSS_VALUE_FULL_WIDTH, 10, 0},
{"block", (void *) LXB_CSS_VALUE_BLOCK, 5, 350},
{"blink", (void *) LXB_CSS_VALUE_BLINK, 5, 351},
{"thistle", (void *) LXB_CSS_VALUE_THISTLE, 7, 0},
{"turquoise", (void *) LXB_CSS_VALUE_TURQUOISE, 9, 0},
{"uppercase", (void *) LXB_CSS_VALUE_UPPERCASE, 9, 0},
{"text-top", (void *) LXB_CSS_VALUE_TEXT_TOP, 8, 0},
{"ivory", (void *) LXB_CSS_VALUE_IVORY, 5, 356},
{"inter-character", (void *) LXB_CSS_VALUE_INTER_CHARACTER, 15, 0},
{"fantasy", (void *) LXB_CSS_VALUE_FANTASY, 7, 0},
{"sans-serif", (void *) LXB_CSS_VALUE_SANS_SERIF, 10, 0},
{"darkgreen", (void *) LXB_CSS_VALUE_DARKGREEN, 9, 0},
{"table-row-group", (void *) LXB_CSS_VALUE_TABLE_ROW_GROUP, 15, 0},
{"table-footer-group", (void *) LXB_CSS_VALUE_TABLE_FOOTER_GROUP, 18, 362},
{"table-column-group", (void *) LXB_CSS_VALUE_TABLE_COLUMN_GROUP, 18, 0},
{"grey", (void *) LXB_CSS_VALUE_GREY, 4, 364},
{"vertical-rl", (void *) LXB_CSS_VALUE_VERTICAL_RL, 11, 0},
{"both", (void *) LXB_CSS_VALUE_BOTH, 4, 0},
{"_percentage", (void *) LXB_CSS_VALUE__PERCENTAGE, 11, 0},
{"ui-serif", (void *) LXB_CSS_VALUE_UI_SERIF, 8, 0},
{"left", (void *) LXB_CSS_VALUE_LEFT, 4, 369},
{"ui-sans-serif", (void *) LXB_CSS_VALUE_UI_SANS_SERIF, 13, 0},
{"condensed", (void *) LXB_CSS_VALUE_CONDENSED, 9, 0},
{"ruby-text-container", (void *) LXB_CSS_VALUE_RUBY_TEXT_CONTAINER, 19, 0},
{"orangered", (void *) LXB_CSS_VALUE_ORANGERED, 9, 0}
};
#endif /* LXB_CSS_VALUE_RES_H */

32
ext/dom/lexbor/lexbor/dom/base.h Normal file
View file

@ -0,0 +1,32 @@
/*
* Copyright (C) 2019-2023 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_DOM_BASE_H
#define LEXBOR_DOM_BASE_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#define LXB_DOM_VERSION_MAJOR 1
#define LXB_DOM_VERSION_MINOR 6
#define LXB_DOM_VERSION_PATCH 0
#define LXB_DOM_VERSION_STRING \
LEXBOR_STRINGIZE(LXB_DOM_VERSION_MAJOR) "." \
LEXBOR_STRINGIZE(LXB_DOM_VERSION_MINOR) "." \
LEXBOR_STRINGIZE(LXB_DOM_VERSION_PATCH)
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_DOM_BASE_H */

97
ext/dom/lexbor/lexbor/dom/collection.c Normal file
View file

@ -0,0 +1,97 @@
/*
* Copyright (C) 2018-2022 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#include "lexbor/dom/collection.h"
#include "lexbor/dom/interfaces/document.h"
lxb_dom_collection_t *
lxb_dom_collection_create(lxb_dom_document_t *document)
{
lxb_dom_collection_t *col;
col = lexbor_calloc(1, sizeof(lxb_dom_collection_t));
if (col == NULL) {
return NULL;
}
col->document = document;
return col;
}
lxb_status_t
lxb_dom_collection_init(lxb_dom_collection_t *col, size_t start_list_size)
{
if (col == NULL) {
return LXB_STATUS_ERROR_WRONG_ARGS;
}
if (col->document == NULL) {
return LXB_STATUS_ERROR_INCOMPLETE_OBJECT;
}
return lexbor_array_init(&col->array, start_list_size);
}
lxb_dom_collection_t *
lxb_dom_collection_destroy(lxb_dom_collection_t *col, bool self_destroy)
{
if (col == NULL) {
return NULL;
}
if (col->array.list != NULL) {
lexbor_array_destroy(&col->array, false);
col->array.list = NULL;
}
if (self_destroy) {
return lexbor_free(col);
}
return col;
}
/*
* No inline functions for ABI.
*/
lxb_dom_collection_t *
lxb_dom_collection_make_noi(lxb_dom_document_t *document, size_t start_list_size)
{
return lxb_dom_collection_make(document, start_list_size);
}
void
lxb_dom_collection_clean_noi(lxb_dom_collection_t *col)
{
lxb_dom_collection_clean(col);
}
lxb_status_t
lxb_dom_collection_append_noi(lxb_dom_collection_t *col, void *value)
{
return lxb_dom_collection_append(col, value);
}
lxb_dom_element_t *
lxb_dom_collection_element_noi(lxb_dom_collection_t *col, size_t idx)
{
return lxb_dom_collection_element(col, idx);
}
lxb_dom_node_t *
lxb_dom_collection_node_noi(lxb_dom_collection_t *col, size_t idx)
{
return lxb_dom_collection_node(col, idx);
}
size_t
lxb_dom_collection_length_noi(lxb_dom_collection_t *col)
{
return lxb_dom_collection_length(col);
}

112
ext/dom/lexbor/lexbor/dom/collection.h Normal file
View file

@ -0,0 +1,112 @@
/*
* Copyright (C) 2018 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LEXBOR_DOM_COLLECTION_H
#define LEXBOR_DOM_COLLECTION_H
#ifdef __cplusplus
extern "C" {
#endif
#include "lexbor/core/base.h"
#include "lexbor/core/array.h"
#include "lexbor/dom/interface.h"
typedef struct {
lexbor_array_t array;
lxb_dom_document_t *document;
}
lxb_dom_collection_t;
LXB_API lxb_dom_collection_t *
lxb_dom_collection_create(lxb_dom_document_t *document);
LXB_API lxb_status_t
lxb_dom_collection_init(lxb_dom_collection_t *col, size_t start_list_size);
LXB_API lxb_dom_collection_t *
lxb_dom_collection_destroy(lxb_dom_collection_t *col, bool self_destroy);
/*
* Inline functions
*/
lxb_inline lxb_dom_collection_t *
lxb_dom_collection_make(lxb_dom_document_t *document, size_t start_list_size)
{
lxb_status_t status;
lxb_dom_collection_t *col;
col = lxb_dom_collection_create(document);
status = lxb_dom_collection_init(col, start_list_size);
if(status != LXB_STATUS_OK) {
return lxb_dom_collection_destroy(col, true);
}
return col;
}
lxb_inline void
lxb_dom_collection_clean(lxb_dom_collection_t *col)
{
lexbor_array_clean(&col->array);
}
lxb_inline lxb_status_t
lxb_dom_collection_append(lxb_dom_collection_t *col, void *value)
{
return lexbor_array_push(&col->array, value);
}
lxb_inline lxb_dom_element_t *
lxb_dom_collection_element(lxb_dom_collection_t *col, size_t idx)
{
return (lxb_dom_element_t *) lexbor_array_get(&col->array, idx);
}
lxb_inline lxb_dom_node_t *
lxb_dom_collection_node(lxb_dom_collection_t *col, size_t idx)
{
return (lxb_dom_node_t *) lexbor_array_get(&col->array, idx);
}
lxb_inline size_t
lxb_dom_collection_length(lxb_dom_collection_t *col)
{
return lexbor_array_length(&col->array);
}
/*
* No inline functions for ABI.
*/
LXB_API lxb_dom_collection_t *
lxb_dom_collection_make_noi(lxb_dom_document_t *document, size_t start_list_size);
LXB_API void
lxb_dom_collection_clean_noi(lxb_dom_collection_t *col);
LXB_API lxb_status_t
lxb_dom_collection_append_noi(lxb_dom_collection_t *col, void *value);
LXB_API lxb_dom_element_t *
lxb_dom_collection_element_noi(lxb_dom_collection_t *col, size_t idx);
LXB_API lxb_dom_node_t *
lxb_dom_collection_node_noi(lxb_dom_collection_t *col, size_t idx);
LXB_API size_t
lxb_dom_collection_length_noi(lxb_dom_collection_t *col);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* LEXBOR_DOM_COLLECTION_H */

29
ext/dom/lexbor/lexbor/dom/dom.h Normal file
View file

@ -0,0 +1,29 @@
/*
* Copyright (C) 2020 Alexander Borisov
*
* Author: Alexander Borisov <borisov@lexbor.com>
*/
#ifndef LXB_DOM_H
#define LXB_DOM_H
#include "lexbor/dom/base.h"
#include "lexbor/dom/interface.h"
#include "lexbor/dom/collection.h"
#include "lexbor/dom/exception.h"
#include "lexbor/dom/interfaces/shadow_root.h"
#include "lexbor/dom/interfaces/attr.h"
#include "lexbor/dom/interfaces/cdata_section.h"
#include "lexbor/dom/interfaces/text.h"
#include "lexbor/dom/interfaces/event_target.h"
#include "lexbor/dom/interfaces/comment.h"
#include "lexbor/dom/interfaces/attr_const.h"
#include "lexbor/dom/interfaces/node.h"
#include "lexbor/dom/interfaces/document_type.h"
#include "lexbor/dom/interfaces/element.h"
#include "lexbor/dom/interfaces/document_fragment.h"
#include "lexbor/dom/interfaces/document.h"
#include "lexbor/dom/interfaces/character_data.h"
#include "lexbor/dom/interfaces/processing_instruction.h"
#endif /* LXB_DOM_H */

Some files were not shown because too many files have changed in this diff Show more