From 378842a34976f7e7b118efcfdeabab6cafa50f13 Mon Sep 17 00:00:00 2001 From: Witold Filipczyk Date: Sun, 31 Dec 2023 16:08:35 +0100 Subject: [PATCH] [quickjs] C only There are some bugs left. --- src/ecmascript/quickjs.c | 19 - src/ecmascript/quickjs/Makefile | 2 +- src/ecmascript/quickjs/mapa.c | 756 +++++++++++++++++++++++++++++ src/ecmascript/quickjs/mapa.cpp | 607 ----------------------- src/ecmascript/quickjs/mapa.h | 10 +- src/ecmascript/quickjs/meson.build | 2 +- src/ecmascript/quickjs/xhr.c | 9 +- 7 files changed, 767 insertions(+), 638 deletions(-) create mode 100644 src/ecmascript/quickjs/mapa.c delete mode 100644 src/ecmascript/quickjs/mapa.cpp diff --git a/src/ecmascript/quickjs.c b/src/ecmascript/quickjs.c index 924648c1..f2e1fa9e 100644 --- a/src/ecmascript/quickjs.c +++ b/src/ecmascript/quickjs.c @@ -94,25 +94,6 @@ quickjs_done(struct module *xxx) #ifdef ECMASCRIPT_DEBUG fprintf(stderr, "%s:%s\n", __FILE__, __FUNCTION__); #endif - attr_clear_map(map_attrs); - attr_clear_map(map_attributes); - attr_clear_map_rev(map_rev_attributes); - attr_clear_map(map_collections); - attr_clear_map_rev(map_rev_collections); - attr_clear_map(map_doctypes); - attr_clear_map(map_elements); - attr_clear_map_void(map_privates); - attr_clear_map(map_form); - attr_clear_map_rev(map_form_rev); - attr_clear_map(map_forms); - attr_clear_map_rev(map_rev_forms); - attr_clear_map(map_inputs); - attr_clear_map(map_nodelist); - attr_clear_map_rev(map_rev_nodelist); - - attr_clear_map(map_form_elements); - attr_clear_map_rev(map_form_elements_rev); - attr_delete_map(map_attrs); attr_delete_map(map_attributes); attr_delete_map_rev(map_rev_attributes); diff --git a/src/ecmascript/quickjs/Makefile b/src/ecmascript/quickjs/Makefile index b33e06b6..66168003 100644 --- a/src/ecmascript/quickjs/Makefile +++ b/src/ecmascript/quickjs/Makefile @@ -2,6 +2,6 @@ top_builddir=../../.. include $(top_builddir)/Makefile.config OBJS = attr.o attributes.o collection.o console.o document.o element.o form.o forms.o heartbeat.o history.o implementation.o input.o \ - keyboard.o localstorage.o location.o mapa.obj message.o navigator.o nodelist.o screen.o style.o unibar.o window.o xhr.o + keyboard.o localstorage.o location.o mapa.o message.o navigator.o nodelist.o screen.o style.o unibar.o window.o xhr.o include $(top_srcdir)/Makefile.lib diff --git a/src/ecmascript/quickjs/mapa.c b/src/ecmascript/quickjs/mapa.c new file mode 100644 index 00000000..4deb5793 --- /dev/null +++ b/src/ecmascript/quickjs/mapa.c @@ -0,0 +1,756 @@ +/* map temporary file */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include + +#include "elinks.h" + +#include "ecmascript/quickjs.h" +#include "ecmascript/quickjs/mapa.h" +#include "ecmascript/quickjs/xhr.h" +#include "util/hash.h" +#include "util/memory.h" +#include "util/string.h" + +void +attr_save_in_map(void *m, void *node, JSValueConst value) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&node, sizeof(node)); + + if (key) { + char *v = memacpy((const char *)&value, sizeof(value)); + + if (v) { + add_hash_item(hash, key, sizeof(node), v); + } + } + } +} + +void attr_save_in_map_void(void *m, void *node, void *value) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&node, sizeof(node)); + + if (key) { + add_hash_item(hash, key, sizeof(node), value); + } + } +} + +void * +attr_create_new_attrs_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_attributes_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_attributes_map_rev(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_collections_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_doctypes_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_elements_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_privates_map_void(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_form_elements_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_form_elements_map_rev(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_form_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_form_map_rev(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_forms_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_forms_map_rev(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_input_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_collections_map_rev(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_nodelist_map(void) +{ + return (void *)init_hash8(); +} + +#if 0 +struct classcomp { + bool operator() (const std::string& lhs, const std::string& rhs) const + { + return strcasecmp(lhs.c_str(), rhs.c_str()) < 0; + } +}; +#endif + +void * +attr_create_new_requestHeaders_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_responseHeaders_map(void) +{ + return (void *)init_hash8(); +} + +void * +attr_create_new_nodelist_map_rev(void) +{ + return (void *)init_hash8(); +} + +void +delete_map_str(void *m) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + struct hash_item *item; + int i; + + foreach_hash_item (item, *hash, i) { + mem_free_set(&item->key, NULL); + mem_free_set(&item->value, NULL); + } + free_hash(&hash); + } +} + +void +attr_delete_map(void *m) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + struct hash_item *item; + int i; + + foreach_hash_item (item, *hash, i) { + mem_free_set(&item->key, NULL); + mem_free_set(&item->value, NULL); + } + free_hash(&hash); + } +} + +void +attr_delete_map_rev(void *m) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + struct hash_item *item; + int i; + + foreach_hash_item (item, *hash, i) { + mem_free_set(&item->key, NULL); + mem_free_set(&item->value, NULL); + } + free_hash(&hash); + } +} + +void +attr_delete_map_void(void *m) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + struct hash_item *item; + int i; + + foreach_hash_item (item, *hash, i) { + mem_free_set(&item->key, NULL); + } + free_hash(&hash); + } +} + +JSValue +attr_find_in_map(void *m, void *node) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&node, sizeof(node)); + + if (key) { + struct hash_item *item = get_hash_item(hash, key, sizeof(node)); + + mem_free(key); + + if (item) { + char *v = (char *)item->value; + JSValue ret; + + memcpy(&ret, v, sizeof(ret)); + return ret; + } + } + } + + return JS_NULL; +} + +void * +attr_find_in_map_void(void *m, void *node) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&node, sizeof(node)); + + if (key) { + struct hash_item *item = get_hash_item(hash, key, sizeof(node)); + + mem_free(key); + + if (item) { + return item->value; + } + } + } + + return NULL; +} + +void +attr_erase_from_map(void *m, void *node) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&node, sizeof(node)); + + if (key) { + struct hash_item *item = get_hash_item(hash, key, sizeof(node)); + + if (item) { + mem_free_set(&item->key, NULL); + mem_free_set(&item->value, NULL); + del_hash_item(hash, item); + } + mem_free(key); + } + } +} + +void +attr_save_in_map_rev(void *m, JSValueConst value, void *node) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&value, sizeof(value)); + + if (key) { + add_hash_item(hash, key, sizeof(value), node); + } + } +} + +void * +attr_find_in_map_rev(void *m, JSValueConst value) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&value, sizeof(value)); + + if (key) { + struct hash_item *item = get_hash_item(hash, key, sizeof(value)); + + mem_free(key); + + if (item) { + return item->value; + } + } + } + + return NULL; +} + +void +attr_erase_from_map_rev(void *m, JSValueConst value) +{ + struct hash *hash = (struct hash *)m; + + if (hash) { + char *key = memacpy((const char *)&value, sizeof(value)); + + if (key) { + struct hash_item *item = get_hash_item(hash, key, sizeof(value)); + + if (item) { + mem_free_set(&item->key, NULL); + del_hash_item(hash, item); + } + mem_free(key); + } + } +} + +static int +explode(char *s, const char c, char **header, char **value) +{ + char *next; + char *colon = strchr(s, c); + + if (!colon) { + return 0; + } + *header = memacpy(s, colon - s); + next = colon + 1; + colon = strchr(next, c); + + if (colon) { + return 1; + } + *value = stracpy(next); + + return 2; +} + +static void * +get_requestHeaders(void *h) +{ + return h; +} + +static void * +get_responseHeaders(void *h) +{ + return h; +} + +void +process_xhr_headers(char *head, struct Xhr *x) +{ + char *next, *next2, *line; + char *headers = stracpy(head); + char *space; + char *statusText; + char *newline; + char *stat; + int status; + + if (!headers) { + return; + } + newline = strchr(headers, '\n'); + + if (newline) { + *newline = '\0'; + } + space = strchr(headers, ' '); + if (!space) { + return; + } + stat = space + 1; + space = strchr(stat, ' '); + if (space) { + *space = '\0'; + statusText = space + 1; + } else { + statusText = NULL; + } + status = atoi(stat); + struct hash *responseHeaders = get_responseHeaders(x->responseHeaders); + struct hash_item *item; + + if (newline) { + next = newline + 1; + next2 = strchr(next, '\n'); + } else { + next = next2 = NULL; + } + + while (1) { + char *value = NULL; + char *header = NULL; + int size; + + if (!next) { + break; + } + line = next; + + if (!next2) { + next = NULL; + } else { + next = next2 + 1; + next2 = strchr(next, '\n'); + } + next = next2 + 1; + size = explode(line, ':', &header, &value); + + if (size == 0) { + continue; + } + + if (size == 1 || !value) { + mem_free_set(&header, NULL); + continue; + } + + if (!header) { + mem_free(value); + continue; + } + char *normalized_value = normalize(value); + item = get_hash_item(responseHeaders, header, strlen(header)); + + if (item) { + struct string hh; + + if (init_string(&hh)) { + add_to_string(&hh, (char *)item->value); + add_to_string(&hh, ", "); + add_to_string(&hh, normalized_value); + mem_free_set(&item->value, hh.source); + } + } else { + add_hash_item(responseHeaders, header, strlen(header), stracpy(normalized_value)); + } + mem_free(header); + mem_free(value); + } + x->status = status; + mem_free_set(&x->status_text, null_or_stracpy(statusText)); +} + +void +set_xhr_header(char *normalized_value, const char *h_name, struct Xhr *x) +{ + struct hash *requestHeaders = get_requestHeaders(x->requestHeaders); + struct hash_item *item; + char *key; + + if (!requestHeaders || !h_name) { + return; + } + item = get_hash_item(requestHeaders, h_name, strlen(h_name)); + + if (item) { + struct string hh; + + if (init_string(&hh)) { + add_to_string(&hh, item->value); + add_to_string(&hh, ", "); + add_to_string(&hh, normalized_value); + mem_free_set(&item->value, hh.source); + } + return; + } + key = stracpy(h_name); + + if (key) { + add_hash_item(requestHeaders, key, strlen(key), stracpy(normalized_value)); + } +} + +char * +get_output_headers(struct Xhr *x) +{ + struct string output; + struct hash *hash = (struct hash *)get_responseHeaders(x->responseHeaders);; + struct hash_item *item; + int i; + + if (!hash || !init_string(&output)) { + return NULL; + } + foreach_hash_item (item, *hash, i) { + add_to_string(&output, item->key); + add_to_string(&output, ": "); + add_to_string(&output, item->value); + add_to_string(&output, "\r\n"); + } + + return output.source; +} + +char * +get_output_header(const char *header_name, struct Xhr *x) +{ + struct hash *hash = get_responseHeaders(x->responseHeaders); + struct hash_item *item; + + if (!hash || !header_name) { + return NULL; + } + item = get_hash_item(hash, header_name, strlen(header_name)); + + if (!item) { + return NULL; + } + + return null_or_stracpy(item->value); +} + +const char *good[] = { "background", + "background-color", + "color", + "display", + "font-style", + "font-weight", + "list-style", + "list-style-type", + "text-align", + "text-decoration", + "white-space", + NULL +}; + +bool +isGood(const char *param) +{ + int i; + + for (i = 0; good[i]; i++) { + if (!strcmp(param, good[i])) { + return true; + } + } + + return false; +} + +char * +trimString(char *str) +{ + char *whitespace = " \t\n\r\f\v"; + char *end = strchr(str, '\0') - 1; + + str += strspn(str, whitespace); + while (end > str) { + char *s; + int bad = 0; + for (s = whitespace; *s; s++) { + if (*end == *s) { + bad = 1; + *end = '\0'; + break; + } + } + if (!bad) { + break; + } + end--; + } + return str; +} + +void * +set_elstyle(const char *text) +{ + char *str, *param, *value, *next, *next2; + struct hash *css = NULL; + + if (!text || !*text) { + return NULL; + } + str = stracpy(text); + next = str; + + while (next) { + char *semicolon = strchr(str, ';'); + char *colon; + char *params; + + if (semicolon) { + *semicolon = '\0'; + next2 = semicolon + 1; + } else { + next2 = NULL; + } + params = next; + colon = strchr(params, ':'); + + if (!colon) { + goto next_iter; + } + *colon = '\0'; + param = trimString(params); + params = colon + 1; + colon = strchr(params, ':'); + + if (colon) { + *colon = '\0'; + } + value = trimString(params); + + if (isGood(param)) { + if (!css) { + css = init_hash8(); + } + if (css) { + char *key = stracpy(param); + + if (key) { + add_hash_item(css, key, strlen(key), stracpy(value)); + } + } + } +next_iter: + next = next2; + } + + return (void *)css; +} + +char * +get_elstyle(void *m) +{ + struct hash *css = (struct hash *)m; + char *delimiter = ""; + struct hash_item *item; + struct string output; + int i; + + if (!init_string(&output)) { + delete_map_str(css); + return NULL; + } + + foreach_hash_item (item, *css, i) { + add_to_string(&output, delimiter); + add_to_string(&output, item->key); + add_char_to_string(&output, ':'); + add_to_string(&output, item->value); + delimiter = ";"; + } + delete_map_str(css); + + return output.source; +} + +char * +get_css_value(const char *text, const char *param) +{ + void *m = set_elstyle(text); + char *res = NULL; + struct hash *css; + struct hash_item *item; + + if (!m) { + return stracpy(""); + } + css = (struct hash *)m; + item = get_hash_item(css, param, strlen(param)); + + if (item) { + res = stracpy(item->value); + } else { + res = stracpy(""); + } + delete_map_str(css); + + return res; +} + +char * +set_css_value(const char *text, const char *param, const char *value) +{ + void *m = set_elstyle(text); + + if (m) { + if (isGood(param)) { + struct hash *hash = (struct hash *)m; + char *key = stracpy(param); + + if (key) { + add_hash_item(hash, key, strlen(key), stracpy(value)); + } + } + return get_elstyle(m); + } + + if (isGood(param)) { + struct hash *css = init_hash8(); + char *key; + + if (!css) { + return stracpy(""); + } + key = stracpy(param); + + if (key) { + add_hash_item(css, key, strlen(key), stracpy(value)); + } + return get_elstyle((void *)css); + } + return stracpy(""); +} diff --git a/src/ecmascript/quickjs/mapa.cpp b/src/ecmascript/quickjs/mapa.cpp deleted file mode 100644 index 3fd8e325..00000000 --- a/src/ecmascript/quickjs/mapa.cpp +++ /dev/null @@ -1,607 +0,0 @@ -/* map temporary file */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include "elinks.h" - -#include "ecmascript/quickjs.h" -#include "ecmascript/quickjs/mapa.h" -#include "ecmascript/quickjs/xhr.h" -#include "util/memory.h" -#include "util/string.h" - -#include -#include -#include -#include -#include -#include - -void -attr_save_in_map(void *m, void *node, JSValueConst value) -{ - std::map *mapa = static_cast *>(m); - (*mapa)[node] = value; -} - -void attr_save_in_map_void(void *m, void *node, void *value) -{ - std::map *mapa = static_cast *>(m); - (*mapa)[node] = value; -} - -void * -attr_create_new_attrs_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_attributes_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_attributes_map_rev(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_collections_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_doctypes_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_elements_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_privates_map_void(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_form_elements_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_form_elements_map_rev(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_form_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_form_map_rev(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_forms_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_forms_map_rev(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_input_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_collections_map_rev(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_nodelist_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -struct classcomp { - bool operator() (const std::string& lhs, const std::string& rhs) const - { - return strcasecmp(lhs.c_str(), rhs.c_str()) < 0; - } -}; - -void * -attr_create_new_requestHeaders_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_responseHeaders_map(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void * -attr_create_new_nodelist_map_rev(void) -{ - std::map *mapa = new std::map; - - return (void *)mapa; -} - -void -attr_clear_map(void *m) -{ - std::map *mapa = static_cast *>(m); - mapa->clear(); -} - -void -attr_clear_map_rev(void *m) -{ - std::map *mapa = static_cast *>(m); - mapa->clear(); -} - -void -attr_clear_map_void(void *m) -{ - std::map *mapa = static_cast *>(m); - mapa->clear(); -} - - -void -attr_clear_map_str(void *m) -{ - std::map *mapa = static_cast *>(m); - mapa->clear(); -} - -void -delete_map_str(void *m) -{ - std::map *mapa = static_cast *>(m); - - if (mapa) { - delete(mapa); - } -} - -void -attr_delete_map(void *m) -{ - std::map *mapa = static_cast *>(m); - - if (mapa) { - delete(mapa); - } -} - -void -attr_delete_map_rev(void *m) -{ - std::map *mapa = static_cast *>(m); - - if (mapa) { - delete(mapa); - } -} - -void -attr_delete_map_void(void *m) -{ - std::map *mapa = static_cast *>(m); - - if (mapa) { - delete(mapa); - } -} - -JSValue -attr_find_in_map(void *m, void *node) -{ - std::map *mapa = static_cast *>(m); - - if (!mapa) { - return JS_NULL; - } - auto value = (*mapa).find(node); - - if (value == (*mapa).end()) { - return JS_NULL; - } - return value->second; -} - -void * -attr_find_in_map_void(void *m, void *node) -{ - std::map *mapa = static_cast *>(m); - - if (!mapa) { - return NULL; - } - auto value = (*mapa).find(node); - - if (value == (*mapa).end()) { - return NULL; - } - return value->second; -} - -void -attr_erase_from_map(void *m, void *node) -{ - std::map *mapa = static_cast *>(m); - mapa->erase(node); -} - -void -attr_save_in_map_rev(void *m, JSValueConst value, void *node) -{ - std::map *mapa = static_cast *>(m); - (*mapa)[value] = node; -} - -void * -attr_find_in_map_rev(void *m, JSValueConst value) -{ - std::map *mapa = static_cast *>(m); - - if (!mapa) { - return NULL; - } - auto v = (*mapa).find(value); - - if (v == (*mapa).end()) { - return NULL; - } - return v->second; -} - -void -attr_erase_from_map_rev(void *m, JSValueConst value) -{ - std::map *mapa = static_cast *>(m); - mapa->erase(value); -} - -static const std::vector -explode(const std::string& s, const char& c) -{ - std::string buff(""); - std::vector v; - - bool found = false; - for (auto n:s) { - if (found) { - buff += n; - continue; - } - if (n != c) { - buff += n; - } - else if (n == c && buff != "") { - v.push_back(buff); - buff = ""; - found = true; - } - } - - if (buff != "") { - v.push_back(buff); - } - - return v; -} - -static std::map * -get_requestHeaders(void *h) -{ - return static_cast *>(h); -} - -static std::map * -get_responseHeaders(void *h) -{ - return static_cast *>(h); -} - -void -process_xhr_headers(char *head, struct Xhr *x) -{ - std::istringstream headers(head); - std::string http; - int status; - std::string statusText; - std::string line; - std::getline(headers, line); - std::istringstream linestream(line); - linestream >> http >> status >> statusText; - - auto responseHeaders = get_responseHeaders(x->responseHeaders); - - while (1) { - std::getline(headers, line); - - if (line.empty()) { - break; - } - std::vector v = explode(line, ':'); - - if (v.size() == 2) { - char *value = stracpy(v[1].c_str()); - - if (!value) { - continue; - } - char *header = stracpy(v[0].c_str()); - - if (!header) { - mem_free(value); - continue; - } - char *normalized_value = normalize(value); - bool found = false; - - for (auto h: *responseHeaders) { - const std::string hh = h.first; - - if (!strcasecmp(hh.c_str(), header)) { - (*responseHeaders)[hh] = (*responseHeaders)[hh] + ", " + normalized_value; - found = true; - break; - } - } - - if (!found) { - (*responseHeaders)[header] = normalized_value; - } - mem_free(header); - mem_free(value); - } - } - x->status = status; - mem_free_set(&x->status_text, stracpy(statusText.c_str())); -} - -void -set_xhr_header(char *normalized_value, const char *h_name, struct Xhr *x) -{ - bool found = false; - auto requestHeaders = get_requestHeaders(x->requestHeaders); - - for (auto h: *requestHeaders) { - const std::string hh = h.first; - - if (!strcasecmp(hh.c_str(), h_name)) { - (*requestHeaders)[hh] = (*requestHeaders)[hh] + ", " + normalized_value; - found = true; - break; - } - } - - if (!found) { - (*requestHeaders)[h_name] = normalized_value; - } -} - -char * -get_output_headers(struct Xhr *x) -{ - std::string output = ""; - auto responseHeaders = get_responseHeaders(x->responseHeaders); - - for (auto h: *responseHeaders) { - output += h.first + ": " + h.second + "\r\n"; - } - - return memacpy(output.c_str(), output.length()); -} - -char * -get_output_header(const char *header_name, struct Xhr *x) -{ - std::string output = ""; - auto responseHeaders = get_responseHeaders(x->responseHeaders); - - for (auto h: *responseHeaders) { - if (!strcasecmp(header_name, h.first.c_str())) { - output = h.second; - break; - } - } - - if (!output.empty()) { - return memacpy(output.c_str(), output.length()); - } - - return NULL; -} - -const std::map good = { - { "background", true }, - { "background-color", true }, - { "color", true }, - { "display", true }, - { "font-style", true }, - { "font-weight", true }, - { "list-style", true }, - { "list-style-type", true }, - { "text-align", true }, - { "text-decoration", true }, - { "white-space", true } -}; - -static std::string -trimString(std::string str) -{ - const std::string whiteSpaces = " \t\n\r\f\v"; - // Remove leading whitespace - size_t first_non_space = str.find_first_not_of(whiteSpaces); - str.erase(0, first_non_space); - // Remove trailing whitespace - size_t last_non_space = str.find_last_not_of(whiteSpaces); - str.erase(last_non_space + 1); - - return str; -} - -void * -set_elstyle(const char *text) -{ - if (!text || !*text) { - return NULL; - } - std::stringstream str(text); - std::string word; - std::string param, value; - std::map *css = NULL; - - while (!str.eof()) { - getline(str, word, ';'); - std::stringstream params(word); - getline(params, param, ':'); - getline(params, value, ':'); - param = trimString(param); - value = trimString(value); - - if (good.find(param) != good.end()) { - if (!css) { - css = new std::map; - } - if (css) { - (*css)[param] = value; - } - } - } - - return (void *)css; -} - -char * -get_elstyle(void *m) -{ - std::map *css = static_cast *>(m); - std::string delimiter(""); - std::stringstream output(""); - std::map::iterator it; - - for (it = css->begin(); it != css->end(); it++) { - output << delimiter << it->first << ":" << it->second; - delimiter = ";"; - } - return stracpy(output.str().c_str()); -} - -char * -get_css_value(const char *text, const char *param) -{ - void *m = set_elstyle(text); - char *res = NULL; - - if (!m) { - return stracpy(""); - } - - std::map *css = static_cast *>(m); - - if (css->find(param) != css->end()) { - res = stracpy((*css)[param].c_str()); - } else { - res = stracpy(""); - } - css->clear(); - delete css; - - return res; -} - -char * -set_css_value(const char *text, const char *param, const char *value) -{ - void *m = set_elstyle(text); - std::map *css = NULL; - - if (m) { - css = static_cast *>(m); - - if (good.find(param) != good.end()) { - (*css)[param] = value; - } - return get_elstyle(m); - } - - if (good.find(param) != good.end()) { - css = new std::map; - if (!css) { - return stracpy(""); - } - (*css)[param] = value; - return get_elstyle((void *)css); - } - return stracpy(""); -} diff --git a/src/ecmascript/quickjs/mapa.h b/src/ecmascript/quickjs/mapa.h index dad85e62..1b13ce41 100644 --- a/src/ecmascript/quickjs/mapa.h +++ b/src/ecmascript/quickjs/mapa.h @@ -51,10 +51,10 @@ void *attr_create_new_nodelist_map_rev(void); void *attr_create_new_requestHeaders_map(void); void *attr_create_new_responseHeaders_map(void); -void attr_clear_map(void *m); -void attr_clear_map_rev(void *m); -void attr_clear_map_void(void *m); -void attr_clear_map_str(void *m); +//void attr_clear_map(void *m); +//void attr_clear_map_rev(void *m); +//void attr_clear_map_void(void *m); +//void attr_clear_map_str(void *m); void delete_map_str(void *m); void attr_delete_map(void *m); void attr_delete_map_rev(void *m); @@ -66,7 +66,7 @@ void *attr_find_in_map_void(void *m, void *node); void attr_erase_from_map(void *m, void *node); void attr_save_in_map_rev(void *m, JSValueConst value, void *node); -void attr_clear_map_rev(void *m); +//void attr_clear_map_rev(void *m); void *attr_find_in_map_rev(void *m, JSValueConst value); void attr_erase_from_map_rev(void *m, JSValueConst value); diff --git a/src/ecmascript/quickjs/meson.build b/src/ecmascript/quickjs/meson.build index b4fa0710..e032b019 100644 --- a/src/ecmascript/quickjs/meson.build +++ b/src/ecmascript/quickjs/meson.build @@ -1,3 +1,3 @@ srcs += files('attr.c', 'attributes.c', 'collection.c', 'console.c', 'document.c', 'element.c', 'form.c', 'forms.c', 'heartbeat.c', 'history.c', 'implementation.c', 'input.c', 'keyboard.c', 'localstorage.c', 'location.c', -'mapa.cpp', 'message.c', 'navigator.c', 'nodelist.c', 'screen.c', 'style.c', 'unibar.c', 'window.c', 'xhr.c') +'mapa.c', 'message.c', 'navigator.c', 'nodelist.c', 'screen.c', 'style.c', 'unibar.c', 'window.c', 'xhr.c') diff --git a/src/ecmascript/quickjs/xhr.c b/src/ecmascript/quickjs/xhr.c index d75a823f..e8da44bc 100644 --- a/src/ecmascript/quickjs/xhr.c +++ b/src/ecmascript/quickjs/xhr.c @@ -322,9 +322,6 @@ xhr_finalizer(JSRuntime *rt, JSValue val) mem_free_if(x->responseURL); mem_free_if(x->status_text); - attr_clear_map_str(x->responseHeaders); - attr_clear_map_str(x->requestHeaders); - struct xhr_listener *l; foreach(l, x->listeners) { @@ -1119,8 +1116,10 @@ xhr_open(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) x->uri = get_uri(url2, URI_DIR_LOCATION | URI_PATH | URI_USER | URI_PASSWORD); mem_free(url2); - attr_clear_map_str(x->requestHeaders); - attr_clear_map_str(x->responseHeaders); + delete_map_str(x->requestHeaders); + delete_map_str(x->responseHeaders); + x->requestHeaders = attr_create_new_requestHeaders_map(); + x->responseHeaders = attr_create_new_responseHeaders_map(); x->ready_state = XHR_RSTATE_OPENED; register_bottom_half(onreadystatechange_run, x);