mirrors/Modest
1
0
Fork 0
mirror of https://github.com/lexborisov/Modest synced 2025-02-17 22:35:00 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #33 from swizard0/master

Browse Source 
typo fix: "pasition" -> "position"
This commit is contained in:
lex 2017-08-27 20:26:52 +03:00 committed by GitHub
commit ec59dbf322
7 changed files with 489 additions and 496 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
examples/myhtml/tokenizer_colorize_high_level.c
View File

@ -1,20 +1,20 @@
/* /*
Copyright (C) 2015-2016 Alexander Borisov Copyright (C) 2015-2016 Alexander Borisov
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Author: lex.borisov@gmail.com (Alexander Borisov) Author: lex.borisov@gmail.com (Alexander Borisov)
*/ */
@ -37,30 +37,30 @@ struct res_html load_html_file(const char* filename)
fprintf(stderr, "Can't open html file: %s\n", filename); fprintf(stderr, "Can't open html file: %s\n", filename);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if(fseek(fh, 0L, SEEK_END) != 0) { if(fseek(fh, 0L, SEEK_END) != 0) {
fprintf(stderr, "Can't set position (fseek) in file: %s\n", filename); fprintf(stderr, "Can't set position (fseek) in file: %s\n", filename);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
long size = ftell(fh); long size = ftell(fh);
if(fseek(fh, 0L, SEEK_SET) != 0) { if(fseek(fh, 0L, SEEK_SET) != 0) {
fprintf(stderr, "Can't set position (fseek) in file: %s\n", filename); fprintf(stderr, "Can't set position (fseek) in file: %s\n", filename);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if(size <= 0) { if(size <= 0) {
fprintf(stderr, "Can't get file size or file is empty: %s\n", filename); fprintf(stderr, "Can't get file size or file is empty: %s\n", filename);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
char *html = (char*)malloc(size + 1); char *html = (char*)malloc(size + 1);
if(html == NULL) { if(html == NULL) {
fprintf(stderr, "Can't allocate mem for html file: %s\n", filename); fprintf(stderr, "Can't allocate mem for html file: %s\n", filename);
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
size_t nread = fread(html, 1, size, fh); size_t nread = fread(html, 1, size, fh);
if (nread != size) { if (nread != size) {
fprintf(stderr, "could not read %ld bytes (" MyCORE_FMT_Z " bytes done)\n", size, nread); fprintf(stderr, "could not read %ld bytes (" MyCORE_FMT_Z " bytes done)\n", size, nread);
@ -68,7 +68,7 @@ struct res_html load_html_file(const char* filename)
} }
fclose(fh); fclose(fh);
struct res_html res = {html, (size_t)size}; struct res_html res = {html, (size_t)size};
return res; return res;
} }
@ -77,10 +77,10 @@ void colorize_print(mycore_incoming_buffer_t *inc_buf, size_t begin, size_t leng
{ {
if(length) { if(length) {
inc_buf = mycore_incoming_buffer_find_by_position(inc_buf, begin); inc_buf = mycore_incoming_buffer_find_by_position(inc_buf, begin);
size_t between_begin = (begin - mycore_incoming_buffer_offset(inc_buf)); size_t between_begin = (begin - mycore_incoming_buffer_offset(inc_buf));
const char* between_data = mycore_incoming_buffer_data(inc_buf); const char* between_data = mycore_incoming_buffer_data(inc_buf);
printf("%s%.*s\e[0m", color, (int)length, &between_data[between_begin]); printf("%s%.*s\e[0m", color, (int)length, &between_data[between_begin]);
} }
} }
@ -91,16 +91,16 @@ size_t colorize_print_attributes(myhtml_tree_t* tree, myhtml_tree_attr_t* attr,
{ {
myhtml_position_t key_pos = myhtml_attribute_key_raw_position(attr); myhtml_position_t key_pos = myhtml_attribute_key_raw_position(attr);
myhtml_position_t value_pos = myhtml_attribute_value_raw_position(attr); myhtml_position_t value_pos = myhtml_attribute_value_raw_position(attr);
if(key_pos.length) if(key_pos.length)
{ {
/* print <div[ ]key=value> */ /* print <div[ ]key=value> */
if(last_pos < key_pos.begin) if(last_pos < key_pos.begin)
colorize_print(inc_buf, last_pos, (key_pos.begin - last_pos), "\e[31m"); colorize_print(inc_buf, last_pos, (key_pos.begin - last_pos), "\e[31m");
/* print <div [key]=value> */ /* print <div [key]=value> */
colorize_print(inc_buf, key_pos.begin, key_pos.length, "\e[33m"); colorize_print(inc_buf, key_pos.begin, key_pos.length, "\e[33m");
/* get/check max position */ /* get/check max position */
if((key_pos.begin + key_pos.length) > last_pos) if((key_pos.begin + key_pos.length) > last_pos)
last_pos = key_pos.begin + key_pos.length; last_pos = key_pos.begin + key_pos.length;
@ -110,7 +110,7 @@ size_t colorize_print_attributes(myhtml_tree_t* tree, myhtml_tree_attr_t* attr,
if(value_pos.length && last_pos < value_pos.begin) if(value_pos.length && last_pos < value_pos.begin)
colorize_print(inc_buf, last_pos, (value_pos.begin - last_pos), "\e[31m"); colorize_print(inc_buf, last_pos, (value_pos.begin - last_pos), "\e[31m");
} }
if(value_pos.length) if(value_pos.length)
{ {
/* print <div key[=]value> */ /* print <div key[=]value> */
@ -118,37 +118,37 @@ size_t colorize_print_attributes(myhtml_tree_t* tree, myhtml_tree_attr_t* attr,
size_t between_begin = key_pos.begin + key_pos.length; size_t between_begin = key_pos.begin + key_pos.length;
colorize_print(inc_buf, between_begin, (value_pos.begin - between_begin), "\e[31m"); colorize_print(inc_buf, between_begin, (value_pos.begin - between_begin), "\e[31m");
} }
/* print <div key=[value]> */ /* print <div key=[value]> */
colorize_print(inc_buf, value_pos.begin, value_pos.length, "\e[34m"); colorize_print(inc_buf, value_pos.begin, value_pos.length, "\e[34m");
/* get/check max position */ /* get/check max position */
if(value_pos.begin + value_pos.length > last_pos) if(value_pos.begin + value_pos.length > last_pos)
last_pos = value_pos.begin + value_pos.length; last_pos = value_pos.begin + value_pos.length;
} }
attr = myhtml_attribute_next(attr); attr = myhtml_attribute_next(attr);
} }
return last_pos; return last_pos;
} }
void * colorize_callback_before_token_done(myhtml_tree_t* tree, myhtml_token_node_t* token, void* ctx) void * colorize_callback_before_token_done(myhtml_tree_t* tree, myhtml_token_node_t* token, void* ctx)
{ {
mycore_incoming_buffer_t *inc_buf = myhtml_tree_incoming_buffer_first(tree); mycore_incoming_buffer_t *inc_buf = myhtml_tree_incoming_buffer_first(tree);
myhtml_position_t token_pos = myhtml_token_node_raw_pasition(token); myhtml_position_t token_pos = myhtml_token_node_raw_position(token);
myhtml_position_t token_element_pos = myhtml_token_node_element_pasition(token); myhtml_position_t token_element_pos = myhtml_token_node_element_position(token);
size_t last_pos = token_pos.begin + token_pos.length; size_t last_pos = token_pos.begin + token_pos.length;
switch (myhtml_token_node_tag_id(token)) { switch (myhtml_token_node_tag_id(token)) {
case MyHTML_TAG__DOCTYPE: { case MyHTML_TAG__DOCTYPE: {
/* print [<!DOCTYPE] */ /* print [<!DOCTYPE] */
colorize_print(inc_buf, token_element_pos.begin, (token_pos.begin - token_element_pos.begin), "\e[37m"); colorize_print(inc_buf, token_element_pos.begin, (token_pos.begin - token_element_pos.begin), "\e[37m");
colorize_print(inc_buf, token_pos.begin, token_pos.length, "\e[37m"); colorize_print(inc_buf, token_pos.begin, token_pos.length, "\e[37m");
/* print [>] */ /* print [>] */
colorize_print(inc_buf, last_pos, ((token_element_pos.begin + token_element_pos.length) - last_pos), "\e[37m"); colorize_print(inc_buf, last_pos, ((token_element_pos.begin + token_element_pos.length) - last_pos), "\e[37m");
break; break;
@ -160,9 +160,9 @@ void * colorize_callback_before_token_done(myhtml_tree_t* tree, myhtml_token_nod
case MyHTML_TAG__COMMENT: { case MyHTML_TAG__COMMENT: {
/* print [<!--] */ /* print [<!--] */
colorize_print(inc_buf, token_element_pos.begin, (token_pos.begin - token_element_pos.begin), "\e[32m"); colorize_print(inc_buf, token_element_pos.begin, (token_pos.begin - token_element_pos.begin), "\e[32m");
colorize_print(inc_buf, token_pos.begin, token_pos.length, "\e[32m"); colorize_print(inc_buf, token_pos.begin, token_pos.length, "\e[32m");
/* print [-->] */ /* print [-->] */
colorize_print(inc_buf, last_pos, ((token_element_pos.begin + token_element_pos.length) - last_pos), "\e[32m"); colorize_print(inc_buf, last_pos, ((token_element_pos.begin + token_element_pos.length) - last_pos), "\e[32m");
break; break;
@ -170,20 +170,20 @@ void * colorize_callback_before_token_done(myhtml_tree_t* tree, myhtml_token_nod
default: { default: {
/* print [<]div> */ /* print [<]div> */
colorize_print(inc_buf, token_element_pos.begin, (token_pos.begin - token_element_pos.begin), "\e[31m"); colorize_print(inc_buf, token_element_pos.begin, (token_pos.begin - token_element_pos.begin), "\e[31m");
/* print <[div]> */ /* print <[div]> */
colorize_print(inc_buf, token_pos.begin, token_pos.length, "\e[31m"); colorize_print(inc_buf, token_pos.begin, token_pos.length, "\e[31m");
if(myhtml_token_node_attribute_first(token)) if(myhtml_token_node_attribute_first(token))
last_pos = colorize_print_attributes(tree, myhtml_token_node_attribute_first(token), inc_buf, last_pos); last_pos = colorize_print_attributes(tree, myhtml_token_node_attribute_first(token), inc_buf, last_pos);
/* print <div[>] */ /* print <div[>] */
colorize_print(inc_buf, last_pos, ((token_element_pos.begin + token_element_pos.length) - last_pos), "\e[31m"); colorize_print(inc_buf, last_pos, ((token_element_pos.begin + token_element_pos.length) - last_pos), "\e[31m");
break; break;
} }
} }
return ctx; return ctx;
} }
@ -198,30 +198,28 @@ int main(int argc, const char * argv[])
printf("Bad ARGV!\nUse: tokenizer_colorize_high_level <path_to_html_file>\n"); printf("Bad ARGV!\nUse: tokenizer_colorize_high_level <path_to_html_file>\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
struct res_html res = load_html_file(path); struct res_html res = load_html_file(path);
// basic init // basic init
myhtml_t* myhtml = myhtml_create(); myhtml_t* myhtml = myhtml_create();
myhtml_init(myhtml, MyHTML_OPTIONS_DEFAULT, 1, 0); myhtml_init(myhtml, MyHTML_OPTIONS_DEFAULT, 1, 0);
// init tree // init tree
myhtml_tree_t* tree = myhtml_tree_create(); myhtml_tree_t* tree = myhtml_tree_create();
myhtml_tree_init(tree, myhtml); myhtml_tree_init(tree, myhtml);
myhtml_callback_before_token_done_set(tree, colorize_callback_before_token_done, NULL); myhtml_callback_before_token_done_set(tree, colorize_callback_before_token_done, NULL);
// parse html // parse html
myhtml_parse(tree, MyENCODING_UTF_8, res.html, res.size); myhtml_parse(tree, MyENCODING_UTF_8, res.html, res.size);
printf("\n"); printf("\n");
myhtml_tree_destroy(tree); myhtml_tree_destroy(tree);
myhtml_destroy(myhtml); myhtml_destroy(myhtml);
free(res.html); free(res.html);
return 0; return 0;
} }

20
include/myhtml/api.h
View File

@ -1,20 +1,20 @@
/* /*
Copyright (C) 2015-2017 Alexander Borisov Copyright (C) 2015-2017 Alexander Borisov
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Author: lex.borisov@gmail.com (Alexander Borisov) Author: lex.borisov@gmail.com (Alexander Borisov)
*/ */
@ -328,7 +328,7 @@ enum myhtml_tags {
// base // base
/* /*
Very important!!! Very important!!!
for myhtml 0..00ffff; MyHTML_STATUS_OK == 0x000000 for myhtml 0..00ffff; MyHTML_STATUS_OK == 0x000000
for mycss and modules 010000..01ffff; MyCSS_STATUS_OK == 0x000000 for mycss and modules 010000..01ffff; MyCSS_STATUS_OK == 0x000000
for modest 020000..02ffff; MODEST_STATUS_OK == 0x000000 for modest 020000..02ffff; MODEST_STATUS_OK == 0x000000
@ -380,7 +380,7 @@ enum myhtml_namespace {
MyHTML_NAMESPACE_XLINK = 0x04, MyHTML_NAMESPACE_XLINK = 0x04,
MyHTML_NAMESPACE_XML = 0x05, MyHTML_NAMESPACE_XML = 0x05,
MyHTML_NAMESPACE_XMLNS = 0x06, MyHTML_NAMESPACE_XMLNS = 0x06,
/* MyHTML_NAMESPACE_ANY == MyHTML_NAMESPACE_LAST_ENTRY */ /* MyHTML_NAMESPACE_ANY == MyHTML_NAMESPACE_LAST_ENTRY */
MyHTML_NAMESPACE_ANY = 0x07, MyHTML_NAMESPACE_ANY = 0x07,
MyHTML_NAMESPACE_LAST_ENTRY = 0x07 MyHTML_NAMESPACE_LAST_ENTRY = 0x07
@ -1366,7 +1366,7 @@ myhtml_node_string(myhtml_tree_node_t *node);
* @return myhtml_tree_node_t * @return myhtml_tree_node_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_node_raw_pasition(myhtml_tree_node_t *node); myhtml_node_raw_position(myhtml_tree_node_t *node);
/** /**
* Get element position for Tree Node in Incoming Buffer * Get element position for Tree Node in Incoming Buffer
@ -1378,7 +1378,7 @@ myhtml_node_raw_pasition(myhtml_tree_node_t *node);
* @return myhtml_tree_node_t * @return myhtml_tree_node_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_node_element_pasition(myhtml_tree_node_t *node); myhtml_node_element_position(myhtml_tree_node_t *node);
/** /**
* Get data value from tree node * Get data value from tree node
@ -1619,7 +1619,7 @@ myhtml_token_node_tag_id(myhtml_token_node_t *token_node);
* @return myhtml_position_t * @return myhtml_position_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_token_node_raw_pasition(myhtml_token_node_t *token_node); myhtml_token_node_raw_position(myhtml_token_node_t *token_node);
/** /**
* Get element position for Token Node in Incoming Buffer * Get element position for Token Node in Incoming Buffer
@ -1631,7 +1631,7 @@ myhtml_token_node_raw_pasition(myhtml_token_node_t *token_node);
* @return myhtml_position_t * @return myhtml_position_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_token_node_element_pasition(myhtml_token_node_t *token_node); myhtml_token_node_element_position(myhtml_token_node_t *token_node);
/** /**
* Get first attribute of a token node * Get first attribute of a token node

16
include/myhtml/myhtml.h
View File

@ -1,20 +1,20 @@
/* /*
Copyright (C) 2015-2017 Alexander Borisov Copyright (C) 2015-2017 Alexander Borisov
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Author: lex.borisov@gmail.com (Alexander Borisov) Author: lex.borisov@gmail.com (Alexander Borisov)
*/ */
@ -69,10 +69,10 @@ struct myhtml {
mythread_t* thread_batch; mythread_t* thread_batch;
mythread_t* thread_list[3]; mythread_t* thread_list[3];
size_t thread_total; size_t thread_total;
myhtml_tokenizer_state_f* parse_state_func; myhtml_tokenizer_state_f* parse_state_func;
myhtml_insertion_f* insertion_func; myhtml_insertion_f* insertion_func;
enum myhtml_options opt; enum myhtml_options opt;
myhtml_tree_node_t *marker; myhtml_tree_node_t *marker;
}; };
@ -177,8 +177,8 @@ myhtml_tree_attr_t * myhtml_node_attribute_first(myhtml_tree_node_t *node);
myhtml_tree_attr_t * myhtml_node_attribute_last(myhtml_tree_node_t *node); myhtml_tree_attr_t * myhtml_node_attribute_last(myhtml_tree_node_t *node);
const char * myhtml_node_text(myhtml_tree_node_t *node, size_t *length); const char * myhtml_node_text(myhtml_tree_node_t *node, size_t *length);
mycore_string_t * myhtml_node_string(myhtml_tree_node_t *node); mycore_string_t * myhtml_node_string(myhtml_tree_node_t *node);
myhtml_position_t myhtml_node_raw_pasition(myhtml_tree_node_t *node); myhtml_position_t myhtml_node_raw_position(myhtml_tree_node_t *node);
myhtml_position_t myhtml_node_element_pasition(myhtml_tree_node_t *node); myhtml_position_t myhtml_node_element_position(myhtml_tree_node_t *node);
void myhtml_node_set_data(myhtml_tree_node_t *node, void* data); void myhtml_node_set_data(myhtml_tree_node_t *node, void* data);
void * myhtml_node_get_data(myhtml_tree_node_t *node); void * myhtml_node_get_data(myhtml_tree_node_t *node);

40
include/myhtml/token.h
View File

@ -1,20 +1,20 @@
/* /*
Copyright (C) 2015-2017 Alexander Borisov Copyright (C) 2015-2017 Alexander Borisov
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Author: lex.borisov@gmail.com (Alexander Borisov) Author: lex.borisov@gmail.com (Alexander Borisov)
*/ */
@ -42,7 +42,7 @@ extern "C" {
struct myhtml_token_replacement_entry { struct myhtml_token_replacement_entry {
char* from; char* from;
size_t from_size; size_t from_size;
char* to; char* to;
size_t to_size; size_t to_size;
}; };
@ -50,55 +50,55 @@ struct myhtml_token_replacement_entry {
struct myhtml_token_namespace_replacement { struct myhtml_token_namespace_replacement {
char* from; char* from;
size_t from_size; size_t from_size;
char* to; char* to;
size_t to_size; size_t to_size;
enum myhtml_namespace ns; enum myhtml_namespace ns;
}; };
struct myhtml_token_attr { struct myhtml_token_attr {
myhtml_token_attr_t* next; myhtml_token_attr_t* next;
myhtml_token_attr_t* prev; myhtml_token_attr_t* prev;
mycore_string_t key; mycore_string_t key;
mycore_string_t value; mycore_string_t value;
size_t raw_key_begin; size_t raw_key_begin;
size_t raw_key_length; size_t raw_key_length;
size_t raw_value_begin; size_t raw_value_begin;
size_t raw_value_length; size_t raw_value_length;
enum myhtml_namespace ns; enum myhtml_namespace ns;
}; };
struct myhtml_token_node { struct myhtml_token_node {
myhtml_tag_id_t tag_id; myhtml_tag_id_t tag_id;
mycore_string_t str; mycore_string_t str;
size_t raw_begin; size_t raw_begin;
size_t raw_length; size_t raw_length;
size_t element_begin; size_t element_begin;
size_t element_length; size_t element_length;
myhtml_token_attr_t* attr_first; myhtml_token_attr_t* attr_first;
myhtml_token_attr_t* attr_last; myhtml_token_attr_t* attr_last;
volatile enum myhtml_token_type type; volatile enum myhtml_token_type type;
}; };
struct myhtml_token { struct myhtml_token {
myhtml_tree_t* tree; // ref myhtml_tree_t* tree; // ref
mcobject_async_t* nodes_obj; // myhtml_token_node_t mcobject_async_t* nodes_obj; // myhtml_token_node_t
mcobject_async_t* attr_obj; // myhtml_token_attr_t mcobject_async_t* attr_obj; // myhtml_token_attr_t
// def thread node id // def thread node id
size_t mcasync_token_id; size_t mcasync_token_id;
size_t mcasync_attr_id; size_t mcasync_attr_id;
bool is_new_tmp; bool is_new_tmp;
}; };
@ -108,8 +108,8 @@ void myhtml_token_clean_all(myhtml_token_t* token);
myhtml_token_t * myhtml_token_destroy(myhtml_token_t* token); myhtml_token_t * myhtml_token_destroy(myhtml_token_t* token);
myhtml_tag_id_t myhtml_token_node_tag_id(myhtml_token_node_t *token_node); myhtml_tag_id_t myhtml_token_node_tag_id(myhtml_token_node_t *token_node);
myhtml_position_t myhtml_token_node_raw_pasition(myhtml_token_node_t *token_node); myhtml_position_t myhtml_token_node_raw_position(myhtml_token_node_t *token_node);
myhtml_position_t myhtml_token_node_element_pasition(myhtml_token_node_t *token_node); myhtml_position_t myhtml_token_node_element_position(myhtml_token_node_t *token_node);
myhtml_tree_attr_t * myhtml_token_node_attribute_first(myhtml_token_node_t *token_node); myhtml_tree_attr_t * myhtml_token_node_attribute_first(myhtml_token_node_t *token_node);
myhtml_tree_attr_t * myhtml_token_node_attribute_last(myhtml_token_node_t *token_node); myhtml_tree_attr_t * myhtml_token_node_attribute_last(myhtml_token_node_t *token_node);

20
source/myhtml/api.h
View File

@ -1,20 +1,20 @@
/* /*
Copyright (C) 2015-2017 Alexander Borisov Copyright (C) 2015-2017 Alexander Borisov
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Author: lex.borisov@gmail.com (Alexander Borisov) Author: lex.borisov@gmail.com (Alexander Borisov)
*/ */
@ -328,7 +328,7 @@ enum myhtml_tags {
// base // base
/* /*
Very important!!! Very important!!!
for myhtml 0..00ffff; MyHTML_STATUS_OK == 0x000000 for myhtml 0..00ffff; MyHTML_STATUS_OK == 0x000000
for mycss and modules 010000..01ffff; MyCSS_STATUS_OK == 0x000000 for mycss and modules 010000..01ffff; MyCSS_STATUS_OK == 0x000000
for modest 020000..02ffff; MODEST_STATUS_OK == 0x000000 for modest 020000..02ffff; MODEST_STATUS_OK == 0x000000
@ -380,7 +380,7 @@ enum myhtml_namespace {
MyHTML_NAMESPACE_XLINK = 0x04, MyHTML_NAMESPACE_XLINK = 0x04,
MyHTML_NAMESPACE_XML = 0x05, MyHTML_NAMESPACE_XML = 0x05,
MyHTML_NAMESPACE_XMLNS = 0x06, MyHTML_NAMESPACE_XMLNS = 0x06,
/* MyHTML_NAMESPACE_ANY == MyHTML_NAMESPACE_LAST_ENTRY */ /* MyHTML_NAMESPACE_ANY == MyHTML_NAMESPACE_LAST_ENTRY */
MyHTML_NAMESPACE_ANY = 0x07, MyHTML_NAMESPACE_ANY = 0x07,
MyHTML_NAMESPACE_LAST_ENTRY = 0x07 MyHTML_NAMESPACE_LAST_ENTRY = 0x07
@ -1366,7 +1366,7 @@ myhtml_node_string(myhtml_tree_node_t *node);
* @return myhtml_tree_node_t * @return myhtml_tree_node_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_node_raw_pasition(myhtml_tree_node_t *node); myhtml_node_raw_position(myhtml_tree_node_t *node);
/** /**
* Get element position for Tree Node in Incoming Buffer * Get element position for Tree Node in Incoming Buffer
@ -1378,7 +1378,7 @@ myhtml_node_raw_pasition(myhtml_tree_node_t *node);
* @return myhtml_tree_node_t * @return myhtml_tree_node_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_node_element_pasition(myhtml_tree_node_t *node); myhtml_node_element_position(myhtml_tree_node_t *node);
/** /**
* Get data value from tree node * Get data value from tree node
@ -1619,7 +1619,7 @@ myhtml_token_node_tag_id(myhtml_token_node_t *token_node);
* @return myhtml_position_t * @return myhtml_position_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_token_node_raw_pasition(myhtml_token_node_t *token_node); myhtml_token_node_raw_position(myhtml_token_node_t *token_node);
/** /**
* Get element position for Token Node in Incoming Buffer * Get element position for Token Node in Incoming Buffer
@ -1631,7 +1631,7 @@ myhtml_token_node_raw_pasition(myhtml_token_node_t *token_node);
* @return myhtml_position_t * @return myhtml_position_t
*/ */
myhtml_position_t myhtml_position_t
myhtml_token_node_element_pasition(myhtml_token_node_t *token_node); myhtml_token_node_element_position(myhtml_token_node_t *token_node);
/** /**
* Get first attribute of a token node * Get first attribute of a token node

554
source/myhtml/myhtml.c
View File

File diff suppressed because it is too large Load Diff

245
source/myhtml/token.c
View File

@ -1,20 +1,20 @@
/* /*
Copyright (C) 2015-2017 Alexander Borisov Copyright (C) 2015-2017 Alexander Borisov
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Author: lex.borisov@gmail.com (Alexander Borisov) Author: lex.borisov@gmail.com (Alexander Borisov)
*/ */
@ -101,36 +101,36 @@ myhtml_token_t * myhtml_token_create(myhtml_tree_t* tree, size_t size)
{ {
if(size == 0) if(size == 0)
size = 4096; size = 4096;
myhtml_token_t* token = (myhtml_token_t*)mycore_malloc(sizeof(myhtml_token_t)); myhtml_token_t* token = (myhtml_token_t*)mycore_malloc(sizeof(myhtml_token_t));
if(token == NULL) if(token == NULL)
return NULL; return NULL;
token->nodes_obj = mcobject_async_create(); token->nodes_obj = mcobject_async_create();
if(token->nodes_obj == NULL) { if(token->nodes_obj == NULL) {
mycore_free(token); mycore_free(token);
return NULL; return NULL;
} }
token->attr_obj = mcobject_async_create(); token->attr_obj = mcobject_async_create();
if(token->attr_obj == NULL) { if(token->attr_obj == NULL) {
mycore_free(token->nodes_obj); mycore_free(token->nodes_obj);
mycore_free(token); mycore_free(token);
return NULL; return NULL;
} }
mcobject_async_init(token->nodes_obj, 128, size, sizeof(myhtml_token_node_t)); mcobject_async_init(token->nodes_obj, 128, size, sizeof(myhtml_token_node_t));
mcobject_async_init(token->attr_obj, 128, size, sizeof(myhtml_token_attr_t)); mcobject_async_init(token->attr_obj, 128, size, sizeof(myhtml_token_attr_t));
token->mcasync_token_id = mcobject_async_node_add(token->nodes_obj, NULL); token->mcasync_token_id = mcobject_async_node_add(token->nodes_obj, NULL);
token->mcasync_attr_id = mcobject_async_node_add(token->attr_obj, NULL); token->mcasync_attr_id = mcobject_async_node_add(token->attr_obj, NULL);
token->tree = tree; token->tree = tree;
return token; return token;
} }
@ -150,15 +150,15 @@ myhtml_token_t * myhtml_token_destroy(myhtml_token_t* token)
{ {
if(token == NULL) if(token == NULL)
return NULL; return NULL;
if(token->nodes_obj) if(token->nodes_obj)
token->nodes_obj = mcobject_async_destroy(token->nodes_obj, 1); token->nodes_obj = mcobject_async_destroy(token->nodes_obj, 1);
if(token->attr_obj) if(token->attr_obj)
token->attr_obj = mcobject_async_destroy(token->attr_obj, 1); token->attr_obj = mcobject_async_destroy(token->attr_obj, 1);
mycore_free(token); mycore_free(token);
return NULL; return NULL;
} }
@ -167,7 +167,7 @@ myhtml_token_node_t * myhtml_token_node_create(myhtml_token_t* token, size_t asy
myhtml_token_node_t *token_node = (myhtml_token_node_t*)mcobject_async_malloc(token->nodes_obj, async_node_id, NULL); myhtml_token_node_t *token_node = (myhtml_token_node_t*)mcobject_async_malloc(token->nodes_obj, async_node_id, NULL);
if(token_node == NULL) if(token_node == NULL)
return NULL; return NULL;
myhtml_token_node_clean(token_node); myhtml_token_node_clean(token_node);
return token_node; return token_node;
} }
@ -176,7 +176,7 @@ void myhtml_token_node_clean(myhtml_token_node_t* node)
{ {
memset(node, 0, sizeof(myhtml_token_node_t)); memset(node, 0, sizeof(myhtml_token_node_t));
node->type = MyHTML_TOKEN_TYPE_OPEN|MyHTML_TOKEN_TYPE_WHITESPACE; node->type = MyHTML_TOKEN_TYPE_OPEN|MyHTML_TOKEN_TYPE_WHITESPACE;
mycore_string_clean_all(&node->str); mycore_string_clean_all(&node->str);
} }
@ -185,7 +185,7 @@ myhtml_token_attr_t * myhtml_token_attr_create(myhtml_token_t* token, size_t asy
myhtml_token_attr_t *attr_node = mcobject_async_malloc(token->attr_obj, async_node_id, NULL); myhtml_token_attr_t *attr_node = mcobject_async_malloc(token->attr_obj, async_node_id, NULL);
if(attr_node == NULL) if(attr_node == NULL)
return NULL; return NULL;
myhtml_token_attr_clean(attr_node); myhtml_token_attr_clean(attr_node);
return attr_node; return attr_node;
} }
@ -194,7 +194,7 @@ void myhtml_token_attr_clean(myhtml_token_attr_t* attr)
{ {
memset(attr, 0, sizeof(myhtml_token_attr_t)); memset(attr, 0, sizeof(myhtml_token_attr_t));
attr->ns = MyHTML_NAMESPACE_HTML; attr->ns = MyHTML_NAMESPACE_HTML;
mycore_string_clean_all(&attr->key); mycore_string_clean_all(&attr->key);
mycore_string_clean_all(&attr->value); mycore_string_clean_all(&attr->value);
} }
@ -204,19 +204,19 @@ myhtml_tag_id_t myhtml_token_node_tag_id(myhtml_token_node_t *token_node)
return token_node->tag_id; return token_node->tag_id;
} }
myhtml_position_t myhtml_token_node_raw_pasition(myhtml_token_node_t *token_node) myhtml_position_t myhtml_token_node_raw_position(myhtml_token_node_t *token_node)
{ {
if(token_node) if(token_node)
return (myhtml_position_t){token_node->raw_begin, token_node->raw_length}; return (myhtml_position_t){token_node->raw_begin, token_node->raw_length};
return (myhtml_position_t){0, 0}; return (myhtml_position_t){0, 0};
} }
myhtml_position_t myhtml_token_node_element_pasition(myhtml_token_node_t *token_node) myhtml_position_t myhtml_token_node_element_position(myhtml_token_node_t *token_node)
{ {
if(token_node) if(token_node)
return (myhtml_position_t){token_node->element_begin, token_node->element_length}; return (myhtml_position_t){token_node->element_begin, token_node->element_length};
return (myhtml_position_t){0, 0}; return (myhtml_position_t){0, 0};
} }
@ -234,7 +234,7 @@ const char * myhtml_token_node_text(myhtml_token_node_t *token_node, size_t *len
{ {
if(length) if(length)
*length = token_node->str.length; *length = token_node->str.length;
return token_node->str.data; return token_node->str.data;
} }
@ -269,13 +269,13 @@ myhtml_token_node_t * myhtml_token_node_clone(myhtml_token_t* token, myhtml_toke
{ {
if(node == NULL) if(node == NULL)
return NULL; return NULL;
myhtml_tree_t* tree = token->tree; myhtml_tree_t* tree = token->tree;
myhtml_token_node_t* new_node = myhtml_token_node_create(token, token_thread_idx); myhtml_token_node_t* new_node = myhtml_token_node_create(token, token_thread_idx);
if(new_node == NULL) if(new_node == NULL)
return NULL; return NULL;
new_node->tag_id = node->tag_id; new_node->tag_id = node->tag_id;
new_node->type = node->type; new_node->type = node->type;
new_node->attr_first = NULL; new_node->attr_first = NULL;
@ -284,17 +284,17 @@ myhtml_token_node_t * myhtml_token_node_clone(myhtml_token_t* token, myhtml_toke
new_node->raw_length = node->raw_length; new_node->raw_length = node->raw_length;
new_node->element_begin = node->element_begin; new_node->element_begin = node->element_begin;
new_node->element_length = node->element_length; new_node->element_length = node->element_length;
mycore_string_init(tree->mchar, tree->mchar_node_id, &new_node->str, node->str.size); mycore_string_init(tree->mchar, tree->mchar_node_id, &new_node->str, node->str.size);
myhtml_token_node_attr_copy(token, node, new_node, attr_thread_idx); myhtml_token_node_attr_copy(token, node, new_node, attr_thread_idx);
return new_node; return new_node;
} }
void myhtml_token_node_text_append(myhtml_token_t* token, myhtml_token_node_t* dest, const char* text, size_t text_len) void myhtml_token_node_text_append(myhtml_token_t* token, myhtml_token_node_t* dest, const char* text, size_t text_len)
{ {
mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &dest->str, (text_len + 2)); mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &dest->str, (text_len + 2));
mycore_string_t* string = &dest->str; mycore_string_t* string = &dest->str;
mycore_string_append(string, text, text_len); mycore_string_append(string, text, text_len);
} }
@ -305,36 +305,36 @@ myhtml_token_attr_t * myhtml_token_node_attr_append(myhtml_token_t* token, myhtm
{ {
myhtml_token_attr_t* new_attr = mcobject_async_malloc(token->attr_obj, thread_idx, NULL); myhtml_token_attr_t* new_attr = mcobject_async_malloc(token->attr_obj, thread_idx, NULL);
new_attr->next = 0; new_attr->next = 0;
if(key_len) { if(key_len) {
mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->key, (key_len + 1)); mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->key, (key_len + 1));
mycore_string_append_lowercase(&new_attr->key, key, key_len); mycore_string_append_lowercase(&new_attr->key, key, key_len);
} }
else else
mycore_string_clean_all(&new_attr->key); mycore_string_clean_all(&new_attr->key);
if(value_len) { if(value_len) {
mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->value, (value_len + 1)); mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->value, (value_len + 1));
mycore_string_append(&new_attr->value, value, value_len); mycore_string_append(&new_attr->value, value, value_len);
} }
else else
mycore_string_clean_all(&new_attr->value); mycore_string_clean_all(&new_attr->value);
if(dest->attr_first == NULL) { if(dest->attr_first == NULL) {
new_attr->prev = 0; new_attr->prev = 0;
dest->attr_first = new_attr; dest->attr_first = new_attr;
dest->attr_last = new_attr; dest->attr_last = new_attr;
} }
else { else {
dest->attr_last->next = new_attr; dest->attr_last->next = new_attr;
new_attr->prev = dest->attr_last; new_attr->prev = dest->attr_last;
dest->attr_last = new_attr; dest->attr_last = new_attr;
} }
new_attr->ns = MyHTML_NAMESPACE_HTML; new_attr->ns = MyHTML_NAMESPACE_HTML;
return new_attr; return new_attr;
} }
@ -345,10 +345,10 @@ myhtml_token_attr_t * myhtml_token_node_attr_append_with_convert_encoding(myhtml
{ {
myhtml_token_attr_t* new_attr = mcobject_async_malloc(token->attr_obj, thread_idx, NULL); myhtml_token_attr_t* new_attr = mcobject_async_malloc(token->attr_obj, thread_idx, NULL);
new_attr->next = 0; new_attr->next = 0;
if(key_len) { if(key_len) {
mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->key, (key_len + 1)); mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->key, (key_len + 1));
if(encoding == MyENCODING_UTF_8) if(encoding == MyENCODING_UTF_8)
mycore_string_append_lowercase(&new_attr->key, key, key_len); mycore_string_append_lowercase(&new_attr->key, key, key_len);
else else
@ -356,10 +356,10 @@ myhtml_token_attr_t * myhtml_token_node_attr_append_with_convert_encoding(myhtml
} }
else else
mycore_string_clean_all(&new_attr->key); mycore_string_clean_all(&new_attr->key);
if(value_len) { if(value_len) {
mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->value, (value_len + 1)); mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->value, (value_len + 1));
if(encoding == MyENCODING_UTF_8) if(encoding == MyENCODING_UTF_8)
mycore_string_append(&new_attr->value, value, value_len); mycore_string_append(&new_attr->value, value, value_len);
else else
@ -367,35 +367,35 @@ myhtml_token_attr_t * myhtml_token_node_attr_append_with_convert_encoding(myhtml
} }
else else
mycore_string_clean_all(&new_attr->value); mycore_string_clean_all(&new_attr->value);
if(dest->attr_first == NULL) { if(dest->attr_first == NULL) {
new_attr->prev = 0; new_attr->prev = 0;
dest->attr_first = new_attr; dest->attr_first = new_attr;
dest->attr_last = new_attr; dest->attr_last = new_attr;
} }
else { else {
dest->attr_last->next = new_attr; dest->attr_last->next = new_attr;
new_attr->prev = dest->attr_last; new_attr->prev = dest->attr_last;
dest->attr_last = new_attr; dest->attr_last = new_attr;
} }
new_attr->ns = MyHTML_NAMESPACE_HTML; new_attr->ns = MyHTML_NAMESPACE_HTML;
return new_attr; return new_attr;
} }
void myhtml_token_node_attr_copy_with_check(myhtml_token_t* token, myhtml_token_node_t* target, myhtml_token_node_t* dest, size_t thread_idx) void myhtml_token_node_attr_copy_with_check(myhtml_token_t* token, myhtml_token_node_t* target, myhtml_token_node_t* dest, size_t thread_idx)
{ {
myhtml_token_attr_t* attr = target->attr_first; myhtml_token_attr_t* attr = target->attr_first;
while (attr) while (attr)
{ {
if(attr->key.length && myhtml_token_attr_by_name(dest, attr->key.data, attr->key.length) == NULL) { if(attr->key.length && myhtml_token_attr_by_name(dest, attr->key.data, attr->key.length) == NULL) {
myhtml_token_attr_copy(token, attr, dest, thread_idx); myhtml_token_attr_copy(token, attr, dest, thread_idx);
} }
attr = attr->next; attr = attr->next;
} }
} }
@ -403,7 +403,7 @@ void myhtml_token_node_attr_copy_with_check(myhtml_token_t* token, myhtml_token_
void myhtml_token_node_attr_copy(myhtml_token_t* token, myhtml_token_node_t* target, myhtml_token_node_t* dest, size_t thread_idx) void myhtml_token_node_attr_copy(myhtml_token_t* token, myhtml_token_node_t* target, myhtml_token_node_t* dest, size_t thread_idx)
{ {
myhtml_token_attr_t* attr = target->attr_first; myhtml_token_attr_t* attr = target->attr_first;
while (attr) while (attr)
{ {
myhtml_token_attr_copy(token, attr, dest, thread_idx); myhtml_token_attr_copy(token, attr, dest, thread_idx);
@ -415,36 +415,36 @@ bool myhtml_token_attr_copy(myhtml_token_t* token, myhtml_token_attr_t* attr, my
{ {
myhtml_token_attr_t* new_attr = mcobject_async_malloc(token->attr_obj, thread_idx, NULL); myhtml_token_attr_t* new_attr = mcobject_async_malloc(token->attr_obj, thread_idx, NULL);
new_attr->next = 0; new_attr->next = 0;
if(attr->key.length) { if(attr->key.length) {
mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->key, (attr->key.length + 1)); mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->key, (attr->key.length + 1));
mycore_string_append_lowercase(&new_attr->key, attr->key.data, attr->key.length); mycore_string_append_lowercase(&new_attr->key, attr->key.data, attr->key.length);
} }
else else
mycore_string_clean_all(&new_attr->key); mycore_string_clean_all(&new_attr->key);
if(attr->value.length) { if(attr->value.length) {
mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->value, (attr->value.length + 1)); mycore_string_init(token->tree->mchar, token->tree->mchar_node_id, &new_attr->value, (attr->value.length + 1));
mycore_string_append(&new_attr->value, attr->value.data, attr->value.length); mycore_string_append(&new_attr->value, attr->value.data, attr->value.length);
} }
else else
mycore_string_clean_all(&new_attr->value); mycore_string_clean_all(&new_attr->value);
if(dest->attr_first == NULL) { if(dest->attr_first == NULL) {
new_attr->prev = 0; new_attr->prev = 0;
dest->attr_first = new_attr; dest->attr_first = new_attr;
dest->attr_last = new_attr; dest->attr_last = new_attr;
} }
else { else {
dest->attr_last->next = new_attr; dest->attr_last->next = new_attr;
new_attr->prev = dest->attr_last; new_attr->prev = dest->attr_last;
dest->attr_last = new_attr; dest->attr_last = new_attr;
} }
new_attr->ns = attr->ns; new_attr->ns = attr->ns;
return true; return true;
} }
@ -452,7 +452,7 @@ myhtml_token_attr_t * myhtml_token_attr_match(myhtml_token_t* token, myhtml_toke
const char* key, size_t key_size, const char* value, size_t value_size) const char* key, size_t key_size, const char* value, size_t value_size)
{ {
myhtml_token_attr_t* attr = target->attr_first; myhtml_token_attr_t* attr = target->attr_first;
while (attr) while (attr)
{ {
if(attr->key.length == key_size && attr->value.length == value_size) if(attr->key.length == key_size && attr->value.length == value_size)
@ -464,10 +464,10 @@ myhtml_token_attr_t * myhtml_token_attr_match(myhtml_token_t* token, myhtml_toke
return NULL; return NULL;
} }
} }
attr = attr->next; attr = attr->next;
} }
return NULL; return NULL;
} }
@ -475,7 +475,7 @@ myhtml_token_attr_t * myhtml_token_attr_match_case(myhtml_token_t* token, myhtml
const char* key, size_t key_size, const char* value, size_t value_size) const char* key, size_t key_size, const char* value, size_t value_size)
{ {
myhtml_token_attr_t* attr = target->attr_first; myhtml_token_attr_t* attr = target->attr_first;
while (attr) while (attr)
{ {
if(attr->key.length == key_size && attr->value.length == value_size) if(attr->key.length == key_size && attr->value.length == value_size)
@ -487,17 +487,17 @@ myhtml_token_attr_t * myhtml_token_attr_match_case(myhtml_token_t* token, myhtml
return NULL; return NULL;
} }
} }
attr = attr->next; attr = attr->next;
} }
return NULL; return NULL;
} }
void myhtml_token_adjust_mathml_attributes(myhtml_token_node_t* target) void myhtml_token_adjust_mathml_attributes(myhtml_token_node_t* target)
{ {
myhtml_token_attr_t* attr = myhtml_token_attr_by_name(target, "definitionurl", 13); myhtml_token_attr_t* attr = myhtml_token_attr_by_name(target, "definitionurl", 13);
if(attr) { if(attr) {
memcpy(attr->key.data, "definitionURL", 13); memcpy(attr->key.data, "definitionURL", 13);
} }
@ -512,10 +512,10 @@ void _myhtml_token_create_copy_srt(myhtml_token_t* token, const char* from, size
void myhtml_token_strict_doctype_by_token(myhtml_token_t* token, myhtml_token_node_t* target, myhtml_tree_doctype_t* return_doctype) void myhtml_token_strict_doctype_by_token(myhtml_token_t* token, myhtml_token_node_t* target, myhtml_tree_doctype_t* return_doctype)
{ {
myhtml_token_attr_t* attr = target->attr_first; myhtml_token_attr_t* attr = target->attr_first;
if(attr && attr->key.length) { if(attr && attr->key.length) {
_myhtml_token_create_copy_srt(token, attr->key.data, attr->key.length, &return_doctype->attr_name); _myhtml_token_create_copy_srt(token, attr->key.data, attr->key.length, &return_doctype->attr_name);
if(mycore_strcmp("html", return_doctype->attr_name)) if(mycore_strcmp("html", return_doctype->attr_name))
return_doctype->is_html = false; return_doctype->is_html = false;
else else
@ -523,41 +523,41 @@ void myhtml_token_strict_doctype_by_token(myhtml_token_t* token, myhtml_token_no
} }
else { else {
return_doctype->is_html = false; return_doctype->is_html = false;
_myhtml_token_create_copy_srt(token, "\0", 1, &return_doctype->attr_name); _myhtml_token_create_copy_srt(token, "\0", 1, &return_doctype->attr_name);
if(return_doctype->attr_public) if(return_doctype->attr_public)
mycore_free(return_doctype->attr_public); mycore_free(return_doctype->attr_public);
return_doctype->attr_public = NULL; return_doctype->attr_public = NULL;
if(return_doctype->attr_system) if(return_doctype->attr_system)
mycore_free(return_doctype->attr_system); mycore_free(return_doctype->attr_system);
return_doctype->attr_system = NULL; return_doctype->attr_system = NULL;
return; return;
} }
attr = attr->next; attr = attr->next;
if(attr && attr->value.length) if(attr && attr->value.length)
{ {
if(mycore_strcasecmp(attr->value.data, "PUBLIC") == 0) if(mycore_strcasecmp(attr->value.data, "PUBLIC") == 0)
{ {
// try see public // try see public
attr = attr->next; attr = attr->next;
if(attr && attr->value.length) { if(attr && attr->value.length) {
_myhtml_token_create_copy_srt(token, attr->value.data, attr->value.length, &return_doctype->attr_public); _myhtml_token_create_copy_srt(token, attr->value.data, attr->value.length, &return_doctype->attr_public);
// try see system // try see system
attr = attr->next; attr = attr->next;
if(attr && attr->value.length) if(attr && attr->value.length)
_myhtml_token_create_copy_srt(token, attr->value.data, attr->value.length, &return_doctype->attr_system); _myhtml_token_create_copy_srt(token, attr->value.data, attr->value.length, &return_doctype->attr_system);
else { else {
if(return_doctype->attr_system) if(return_doctype->attr_system)
mycore_free(return_doctype->attr_system); mycore_free(return_doctype->attr_system);
_myhtml_token_create_copy_srt(token, "\0", 1, &return_doctype->attr_system); _myhtml_token_create_copy_srt(token, "\0", 1, &return_doctype->attr_system);
} }
} }
@ -565,7 +565,7 @@ void myhtml_token_strict_doctype_by_token(myhtml_token_t* token, myhtml_token_no
if(return_doctype->attr_public) if(return_doctype->attr_public)
mycore_free(return_doctype->attr_public); mycore_free(return_doctype->attr_public);
return_doctype->attr_public = NULL; return_doctype->attr_public = NULL;
if(return_doctype->attr_system) if(return_doctype->attr_system)
mycore_free(return_doctype->attr_system); mycore_free(return_doctype->attr_system);
return_doctype->attr_system = NULL; return_doctype->attr_system = NULL;
@ -574,7 +574,7 @@ void myhtml_token_strict_doctype_by_token(myhtml_token_t* token, myhtml_token_no
else if(mycore_strncasecmp(attr->value.data, "SYSTEM", attr->value.length) == 0) else if(mycore_strncasecmp(attr->value.data, "SYSTEM", attr->value.length) == 0)
{ {
attr = attr->next; attr = attr->next;
if(attr && attr->value.length) { if(attr && attr->value.length) {
_myhtml_token_create_copy_srt(token, "\0", 1, &return_doctype->attr_public); _myhtml_token_create_copy_srt(token, "\0", 1, &return_doctype->attr_public);
_myhtml_token_create_copy_srt(token, attr->value.data, attr->value.length, &return_doctype->attr_system); _myhtml_token_create_copy_srt(token, attr->value.data, attr->value.length, &return_doctype->attr_system);
@ -583,7 +583,7 @@ void myhtml_token_strict_doctype_by_token(myhtml_token_t* token, myhtml_token_no
if(return_doctype->attr_public) if(return_doctype->attr_public)
mycore_free(return_doctype->attr_public); mycore_free(return_doctype->attr_public);
return_doctype->attr_public = NULL; return_doctype->attr_public = NULL;
if(return_doctype->attr_system) if(return_doctype->attr_system)
mycore_free(return_doctype->attr_system); mycore_free(return_doctype->attr_system);
return_doctype->attr_system = NULL; return_doctype->attr_system = NULL;
@ -593,7 +593,7 @@ void myhtml_token_strict_doctype_by_token(myhtml_token_t* token, myhtml_token_no
if(return_doctype->attr_public) if(return_doctype->attr_public)
mycore_free(return_doctype->attr_public); mycore_free(return_doctype->attr_public);
return_doctype->attr_public = NULL; return_doctype->attr_public = NULL;
if(return_doctype->attr_system) if(return_doctype->attr_system)
mycore_free(return_doctype->attr_system); mycore_free(return_doctype->attr_system);
return_doctype->attr_system = NULL; return_doctype->attr_system = NULL;
@ -617,7 +617,7 @@ bool myhtml_token_doctype_check_xhtml_1_0(myhtml_tree_doctype_t* return_doctype)
{ {
if(return_doctype->attr_system == NULL) if(return_doctype->attr_system == NULL)
return true; return true;
return mycore_strcmp(return_doctype->attr_public, "-//W3C//DTD XHTML 1.0 Strict//EN") && return mycore_strcmp(return_doctype->attr_public, "-//W3C//DTD XHTML 1.0 Strict//EN") &&
mycore_strcmp(return_doctype->attr_system, "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"); mycore_strcmp(return_doctype->attr_system, "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd");
} }
@ -626,7 +626,7 @@ bool myhtml_token_doctype_check_xhtml_1_1(myhtml_tree_doctype_t* return_doctype)
{ {
if(return_doctype->attr_system == NULL) if(return_doctype->attr_system == NULL)
return true; return true;
return mycore_strcmp(return_doctype->attr_public, "-//W3C//DTD XHTML 1.1//EN") && return mycore_strcmp(return_doctype->attr_public, "-//W3C//DTD XHTML 1.1//EN") &&
mycore_strcmp(return_doctype->attr_system, "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"); mycore_strcmp(return_doctype->attr_system, "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd");
} }
@ -635,19 +635,19 @@ bool myhtml_token_release_and_check_doctype_attributes(myhtml_token_t* token, my
{ {
if(return_doctype == NULL) if(return_doctype == NULL)
return false; return false;
myhtml_token_strict_doctype_by_token(token, target, return_doctype); myhtml_token_strict_doctype_by_token(token, target, return_doctype);
if(return_doctype->attr_name == NULL) if(return_doctype->attr_name == NULL)
return false; return false;
if((return_doctype->is_html || if((return_doctype->is_html ||
return_doctype->attr_public || return_doctype->attr_public ||
(return_doctype->attr_system && mycore_strcmp(return_doctype->attr_system, "about:legacy-compat")))) (return_doctype->attr_system && mycore_strcmp(return_doctype->attr_system, "about:legacy-compat"))))
{ {
if(return_doctype->attr_public == NULL) if(return_doctype->attr_public == NULL)
return false; return false;
if(return_doctype->is_html && if(return_doctype->is_html &&
myhtml_token_doctype_check_html_4_0(return_doctype) && myhtml_token_doctype_check_html_4_0(return_doctype) &&
myhtml_token_doctype_check_html_4_01(return_doctype) && myhtml_token_doctype_check_html_4_01(return_doctype) &&
@ -657,19 +657,19 @@ bool myhtml_token_release_and_check_doctype_attributes(myhtml_token_t* token, my
return false; return false;
} }
} }
return true; return true;
} }
void myhtml_token_adjust_svg_attributes(myhtml_token_node_t* target) void myhtml_token_adjust_svg_attributes(myhtml_token_node_t* target)
{ {
size_t count = sizeof(myhtml_token_attr_svg_replacement) / sizeof(myhtml_token_replacement_entry_t); size_t count = sizeof(myhtml_token_attr_svg_replacement) / sizeof(myhtml_token_replacement_entry_t);
for (size_t i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
{ {
myhtml_token_attr_t* attr = myhtml_token_attr_by_name(target, myhtml_token_attr_svg_replacement[i].from, myhtml_token_attr_t* attr = myhtml_token_attr_by_name(target, myhtml_token_attr_svg_replacement[i].from,
myhtml_token_attr_svg_replacement[i].from_size); myhtml_token_attr_svg_replacement[i].from_size);
if(attr) { if(attr) {
mycore_string_clean(&attr->key); mycore_string_clean(&attr->key);
mycore_string_append(&attr->key, myhtml_token_attr_svg_replacement[i].to, mycore_string_append(&attr->key, myhtml_token_attr_svg_replacement[i].to,
@ -681,17 +681,17 @@ void myhtml_token_adjust_svg_attributes(myhtml_token_node_t* target)
void myhtml_token_adjust_foreign_attributes(myhtml_token_node_t* target) void myhtml_token_adjust_foreign_attributes(myhtml_token_node_t* target)
{ {
size_t count = sizeof(myhtml_token_attr_namespace_replacement) / sizeof(myhtml_token_namespace_replacement_t); size_t count = sizeof(myhtml_token_attr_namespace_replacement) / sizeof(myhtml_token_namespace_replacement_t);
for (size_t i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
{ {
myhtml_token_attr_t* attr = myhtml_token_attr_by_name(target, myhtml_token_attr_namespace_replacement[i].from, myhtml_token_attr_t* attr = myhtml_token_attr_by_name(target, myhtml_token_attr_namespace_replacement[i].from,
myhtml_token_attr_namespace_replacement[i].from_size); myhtml_token_attr_namespace_replacement[i].from_size);
if(attr) { if(attr) {
mycore_string_clean(&attr->key); mycore_string_clean(&attr->key);
mycore_string_append(&attr->key, myhtml_token_attr_namespace_replacement[i].to, mycore_string_append(&attr->key, myhtml_token_attr_namespace_replacement[i].to,
myhtml_token_attr_namespace_replacement[i].to_size); myhtml_token_attr_namespace_replacement[i].to_size);
attr->ns = myhtml_token_attr_namespace_replacement[i].ns; attr->ns = myhtml_token_attr_namespace_replacement[i].ns;
} }
} }
@ -701,10 +701,10 @@ bool myhtml_token_attr_compare(myhtml_token_node_t* target, myhtml_token_node_t*
{ {
if(target == NULL || dest == NULL) if(target == NULL || dest == NULL)
return false; return false;
myhtml_token_attr_t* target_attr = target->attr_first; myhtml_token_attr_t* target_attr = target->attr_first;
myhtml_token_attr_t* dest_attr = dest->attr_first; myhtml_token_attr_t* dest_attr = dest->attr_first;
while (target_attr && dest_attr) while (target_attr && dest_attr)
{ {
if(target_attr->key.length == dest_attr->key.length && if(target_attr->key.length == dest_attr->key.length &&
@ -712,37 +712,37 @@ bool myhtml_token_attr_compare(myhtml_token_node_t* target, myhtml_token_node_t*
{ {
if(mycore_strcmp(target_attr->key.data, dest_attr->key.data) != 0) if(mycore_strcmp(target_attr->key.data, dest_attr->key.data) != 0)
break; break;
if(mycore_strcasecmp(target_attr->value.data, dest_attr->value.data) != 0) if(mycore_strcasecmp(target_attr->value.data, dest_attr->value.data) != 0)
break; break;
} }
else else
break; break;
target_attr = target_attr->next; target_attr = target_attr->next;
dest_attr = dest_attr->next; dest_attr = dest_attr->next;
} }
if(target_attr == NULL && dest_attr == NULL) if(target_attr == NULL && dest_attr == NULL)
return true; return true;
return false; return false;
} }
myhtml_token_attr_t * myhtml_token_attr_by_name(myhtml_token_node_t* node, const char* name, size_t name_length) myhtml_token_attr_t * myhtml_token_attr_by_name(myhtml_token_node_t* node, const char* name, size_t name_length)
{ {
myhtml_token_attr_t* attr = node->attr_first; myhtml_token_attr_t* attr = node->attr_first;
while (attr) while (attr)
{ {
if(name_length == attr->key.length) { if(name_length == attr->key.length) {
if(mycore_strcmp(attr->key.data, name) == 0) if(mycore_strcmp(attr->key.data, name) == 0)
break; break;
} }
attr = attr->next; attr = attr->next;
} }
return attr; return attr;
} }
@ -751,24 +751,24 @@ void myhtml_token_delete(myhtml_token_t* token, myhtml_token_node_t* node)
if(node->str.data && node->str.mchar) { if(node->str.data && node->str.mchar) {
mchar_async_free(node->str.mchar, node->str.node_idx, node->str.data); mchar_async_free(node->str.mchar, node->str.node_idx, node->str.data);
} }
mcobject_async_free(token->nodes_obj, node); mcobject_async_free(token->nodes_obj, node);
} }
void myhtml_token_attr_delete_all(myhtml_token_t* token, myhtml_token_node_t* node) void myhtml_token_attr_delete_all(myhtml_token_t* token, myhtml_token_node_t* node)
{ {
myhtml_token_attr_t* attr = node->attr_first; myhtml_token_attr_t* attr = node->attr_first;
while (attr) while (attr)
{ {
if(attr->key.data && attr->key.mchar) { if(attr->key.data && attr->key.mchar) {
mchar_async_free(attr->key.mchar, attr->key.node_idx, attr->key.data); mchar_async_free(attr->key.mchar, attr->key.node_idx, attr->key.data);
} }
if(attr->value.data && attr->value.mchar) { if(attr->value.data && attr->value.mchar) {
mchar_async_free(attr->value.mchar, attr->value.node_idx, attr->value.data); mchar_async_free(attr->value.mchar, attr->value.node_idx, attr->value.data);
} }
attr = attr->next; attr = attr->next;
} }
} }
@ -783,18 +783,18 @@ myhtml_token_attr_t * myhtml_token_attr_remove(myhtml_token_node_t* node, myhtml
else { else {
node->attr_first = attr->next; node->attr_first = attr->next;
} }
if(attr->next) { if(attr->next) {
attr->next->prev = attr->prev; attr->next->prev = attr->prev;
} }
else { else {
node->attr_last = attr->prev; node->attr_last = attr->prev;
} }
attr->next = NULL; attr->next = NULL;
attr->prev = NULL; attr->prev = NULL;
} }
return attr; return attr;
} }
@ -807,13 +807,13 @@ myhtml_token_node_t * myhtml_token_merged_two_token_string(myhtml_tree_t* tree,
{ {
myhtml_token_node_wait_for_done(tree->token, token_to); myhtml_token_node_wait_for_done(tree->token, token_to);
myhtml_token_node_wait_for_done(tree->token, token_from); myhtml_token_node_wait_for_done(tree->token, token_from);
mycore_string_t *string1 = &token_to->str; mycore_string_t *string1 = &token_to->str;
mycore_string_t *string2 = &token_from->str; mycore_string_t *string2 = &token_from->str;
token_to->raw_begin = 0; token_to->raw_begin = 0;
token_to->raw_length = 0; token_to->raw_length = 0;
if(token_to->str.node_idx == tree->mchar_node_id) if(token_to->str.node_idx == tree->mchar_node_id)
{ {
if(cp_reverse) { if(cp_reverse) {
@ -822,7 +822,7 @@ myhtml_token_node_t * myhtml_token_merged_two_token_string(myhtml_tree_t* tree,
else { else {
mycore_string_copy(string1, string2); mycore_string_copy(string1, string2);
} }
return token_to; return token_to;
} }
if(token_from->str.node_idx == tree->mchar_node_id) if(token_from->str.node_idx == tree->mchar_node_id)
@ -833,13 +833,13 @@ myhtml_token_node_t * myhtml_token_merged_two_token_string(myhtml_tree_t* tree,
else { else {
mycore_string_copy(string1, string2); mycore_string_copy(string1, string2);
} }
return token_from; return token_from;
} }
else { else {
mycore_string_t string_base; mycore_string_t string_base;
mycore_string_init(tree->mchar, tree->mchar_node_id, &string_base, (string1->length + string2->length + 2)); mycore_string_init(tree->mchar, tree->mchar_node_id, &string_base, (string1->length + string2->length + 2));
if(cp_reverse) { if(cp_reverse) {
mycore_string_copy(&string_base, string2); mycore_string_copy(&string_base, string2);
mycore_string_copy(&string_base, string1); mycore_string_copy(&string_base, string1);
@ -848,22 +848,21 @@ myhtml_token_node_t * myhtml_token_merged_two_token_string(myhtml_tree_t* tree,
mycore_string_copy(&string_base, string1); mycore_string_copy(&string_base, string1);
mycore_string_copy(&string_base, string2); mycore_string_copy(&string_base, string2);
} }
token_to->str = string_base; token_to->str = string_base;
} }
return token_to; return token_to;
} }
void myhtml_token_set_replacement_character_for_null_token(myhtml_tree_t* tree, myhtml_token_node_t* node) void myhtml_token_set_replacement_character_for_null_token(myhtml_tree_t* tree, myhtml_token_node_t* node)
{ {
myhtml_token_node_wait_for_done(tree->token, node); myhtml_token_node_wait_for_done(tree->token, node);
mycore_string_t new_str; mycore_string_t new_str;
mycore_string_init(tree->mchar, tree->mchar_node_id, &new_str, (node->str.length + 2)); mycore_string_init(tree->mchar, tree->mchar_node_id, &new_str, (node->str.length + 2));
mycore_string_append_with_replacement_null_characters(&new_str, node->str.data, node->str.length); mycore_string_append_with_replacement_null_characters(&new_str, node->str.data, node->str.length);
node->str = new_str; node->str = new_str;
} }