Fixes after check by the Coverity Scan

44 files changed, 732 insertions, 257 deletions

diff --git a/source/modest/finder/pseudo_class.c b/source/modest/finder/pseudo_class.c
index 5dcd8e7..8e5bc80 100644
--- a/source/modest/finder/pseudo_class.c
+++ b/source/modest/finder/pseudo_class.c
@@ -569,7 +569,7 @@ bool modest_finder_selector_sub_type_pseudo_class_empty(modest_finder_t* finder,
 
 bool modest_finder_selector_sub_type_pseudo_class_enabled(modest_finder_t* finder, myhtml_tree_node_t* base_node, mycss_selectors_entry_t* selector, mycss_selectors_specificity_t* spec)
 {
-    return ~modest_finder_selector_sub_type_pseudo_class_disabled(finder, base_node, selector, spec);
+    return !modest_finder_selector_sub_type_pseudo_class_disabled(finder, base_node, selector, spec);
 }
 
 bool modest_finder_selector_sub_type_pseudo_class_first_child(modest_finder_t* finder, myhtml_tree_node_t* base_node, mycss_selectors_entry_t* selector, mycss_selectors_specificity_t* spec)
@@ -692,7 +692,7 @@ bool modest_finder_selector_sub_type_pseudo_class_optional(modest_finder_t* find
        base_node->tag_id == MyHTML_TAG_TEXTAREA)
     {
         if(base_node->token)
-            return ~modest_finder_match_attribute_only_key(base_node->token->attr_first, "required", 8);
+            return !modest_finder_match_attribute_only_key(base_node->token->attr_first, "required", 8);
         else
             return true;
     }
@@ -738,7 +738,7 @@ bool modest_finder_selector_sub_type_pseudo_class_read_write(modest_finder_t* fi
         if(modest_finder_match_attribute_only_key(base_node->token->attr_first, "readonly", 8))
             return false;
         
-        return ~modest_finder_selector_sub_type_pseudo_class_disabled(finder, base_node, selector, spec);
+        return !modest_finder_selector_sub_type_pseudo_class_disabled(finder, base_node, selector, spec);
     }
     
     return false;
diff --git a/source/modest/finder/thread.c b/source/modest/finder/thread.c
index 87276e5..9ca10a2 100644
--- a/source/modest/finder/thread.c
+++ b/source/modest/finder/thread.c
@@ -227,6 +227,7 @@ modest_finder_thread_context_t * modest_finder_thread_create_context(modest_find
                 mcobject_async_node_delete(finder_thread->entry_obj, ctx[i].entry_node_id);
             }
             
+            myhtml_free(ctx);
             return NULL;
         }
     }
@@ -246,6 +247,7 @@ modest_finder_thread_context_t * modest_finder_thread_create_context(modest_find
                 mcobject_async_node_delete(finder_thread->declaration_obj, ctx[i].declaration_node_id);
             }
             
+            myhtml_free(ctx);
             return NULL;
         }
     }
diff --git a/source/modest/layer/binding.c b/source/modest/layer/binding.c
deleted file mode 100644
index a1a026a..0000000
--- a/source/modest/layer/binding.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- Copyright (C) 2016 Alexander Borisov
- 
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- 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,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
- 
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- 
- Author: lex.borisov@gmail.com (Alexander Borisov)
-*/
-
-#include "modest/layer/binding.h"
-
-modest_layer_t * modest_layer_binding(modest_t* modest, myhtml_tree_t* html_tree)
-{
-    modest_layer_t *root = modest_layer_create(modest->layout);
-    return root;
-}
-
-void modest_layer_binding_html_node(modest_t* modest, myhtml_tree_node_t* html_node)
-{
-    modest_node_t *m_node = html_node->data;
-    
-    //m_node->layer
-}
diff --git a/source/modest/layer/layout.c b/source/modest/layer/layout.c
deleted file mode 100644
index c2af6fd..0000000
--- a/source/modest/layer/layout.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- Copyright (C) 2016 Alexander Borisov
- 
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- 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,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
- 
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- 
- Author: lex.borisov@gmail.com (Alexander Borisov)
-*/
-
-#include "modest/layer/layer.h"
-
-modest_layout_t * modest_layers_create(void)
-{
-    return myhtml_calloc(1, sizeof(modest_layout_t));
-}
-
-modest_status_t modest_layers_init(modest_layout_t* layout)
-{
-    layout->mc_nodes = mcobject_create();
-    if(layout->mc_nodes == NULL)
-        return MODEST_STATUS_ERROR_MEMORY_ALLOCATION;
-    
-    myhtml_status_t myhtml_status = mcobject_init(layout->mc_nodes, 1024, sizeof(modest_layer_t));
-    if(myhtml_status)
-        return MODEST_STATUS_ERROR;
-    
-    return MODEST_STATUS_OK;
-}
-
-void modest_layers_clean_all(modest_layout_t* layout)
-{
-    mcobject_clean(layout->mc_nodes);
-}
-
-modest_layout_t * modest_layers_destroy(modest_layout_t* layout, bool self_destroy)
-{
-    if(layout == NULL)
-        return NULL;
-    
-    layout->mc_nodes = mcobject_destroy(layout->mc_nodes, true);
-    
-    if(self_destroy) {
-        myhtml_free(layout);
-        return NULL;
-    }
-    
-    return layout;
-}
-
-
diff --git a/source/modest/modest.c b/source/modest/modest.c
index d77109c..056228d 100644
--- a/source/modest/modest.c
+++ b/source/modest/modest.c
@@ -79,15 +79,7 @@ modest_status_t modest_init(modest_t* modest)
     if(myhtml_status)
         return MODEST_STATUS_OK;
     
-    /* layers */
-    modest->layout = modest_layers_create();
-    if(modest->layout == NULL)
-        return MODEST_STATUS_ERROR_MEMORY_ALLOCATION;
-    
-    modest_status_t modest_status = modest_layers_init(modest->layout);
-    if(modest_status)
-        return MODEST_STATUS_ERROR;
-    
+    /* styles tree */
     modest->style_avl_tree = myhtml_utils_avl_tree_create();
     if(modest->style_avl_tree == NULL)
         return MODEST_STATUS_ERROR_MEMORY_ALLOCATION;
@@ -103,7 +95,6 @@ void modest_clean(modest_t* modest)
 {
     mcobject_async_clean(modest->mnode_obj);
     mcobject_async_clean(modest->mstylesheet_obj);
-    modest_layers_clean_all(modest->layout);
     myhtml_utils_avl_tree_clean(modest->style_avl_tree);
 }
 
@@ -114,7 +105,6 @@ modest_t * modest_destroy(modest_t* modest, bool self_destroy)
     
     modest->mnode_obj = mcobject_async_destroy(modest->mnode_obj, true);
     modest->mstylesheet_obj = mcobject_async_destroy(modest->mstylesheet_obj, true);
-    modest->layout = modest_layers_destroy(modest->layout, true);
     modest->style_avl_tree = myhtml_utils_avl_tree_destroy(modest->style_avl_tree, true);
     
     if(self_destroy) {
diff --git a/source/modest/node/node.h b/source/modest/node/node.h
index 00f2e11..3de5b9c 100644
--- a/source/modest/node/node.h
+++ b/source/modest/node/node.h
@@ -25,7 +25,7 @@
 #include "modest/myosi.h"
 #include "modest/modest.h"
 #include "modest/style/raw.h"
-#include "modest/layer/layer.h"
+#include "modest/render/tree_node.h"
 #include "myhtml/utils/avl_tree.h"
 
 #ifdef __cplusplus
@@ -40,7 +40,7 @@ struct modest_node {
     modest_style_raw_declaration_t * raw_declaration[MyCSS_PROPERTY_TYPE_LAST_ENTRY];
 #endif /* MODEST_NODE_FULL_RAW */
     
-    modest_layer_t* layer;
+    modest_render_tree_node_t* render_node;
 };
 
 modest_node_t * modest_node_create(modest_t* modest);
diff --git a/source/modest/render/begin.c b/source/modest/render/begin.c
index 1691720..55784c7 100644
--- a/source/modest/render/begin.c
+++ b/source/modest/render/begin.c
@@ -21,3 +21,5 @@
 #include "modest/render/begin.h"
 
 
+
+
diff --git a/source/modest/render/begin.h b/source/modest/render/begin.h
index 94673d3..53a2b99 100644
--- a/source/modest/render/begin.h
+++ b/source/modest/render/begin.h
@@ -22,9 +22,9 @@
 #define MODEST_RENDER_BEGIN_H
 #pragma once
 
-#include "modest/myosi.h"
 #include "modest/modest.h"
 #include "modest/style/type.h"
+#include "modest/render/tree.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/source/modest/render/binding.c b/source/modest/render/binding.c
new file mode 100644
index 0000000..b767619
--- /dev/null
+++ b/source/modest/render/binding.c
@@ -0,0 +1,95 @@
+/*
+ Copyright (C) 2016 Alexander Borisov
+ 
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ 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,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ 
+ Author: lex.borisov@gmail.com (Alexander Borisov)
+*/
+
+#include "modest/render/binding.h"
+
+modest_render_tree_node_t * modest_render_binding_create_viewport(modest_t* modest, modest_render_tree_t* render_tree)
+{
+    modest_render_tree_node_t* render_node = modest_render_tree_node_create_and_init(render_tree);
+    render_node->type = MODEST_RENDER_TREE_NODE_TYPE_VIEWPORT;
+    
+    return render_node;
+}
+
+modest_render_tree_node_t * modest_render_binding(modest_t* modest, modest_render_tree_t* render_tree, myhtml_tree_t* html_tree)
+{
+    myhtml_tree_node_t* html_node = html_tree->node_html;
+    myhtml_tree_node_t* html_scope = html_node;
+    
+    modest_node_t *m_node = html_node->data;
+    
+    modest_render_tree_node_t *render_root = modest_render_binding_create_viewport(modest, render_tree);
+    modest_render_tree_node_t *render_node = render_root;
+    
+    while(html_node) {
+        render_node = modest_layer_binding_node(modest, render_tree, render_node, html_node);
+        
+        if(render_node == NULL && html_node->next) {
+            modest_node_t *m_node = html_node->parent->data;
+            render_node = m_node->render_node;
+            
+            html_node = html_node->next;
+        }
+        else if(render_node && html_node->child)
+            html_node = html_node->child;
+        else {
+            while(html_node != html_scope && html_node->next == NULL) {
+                html_node = html_node->parent;
+            }
+            
+            if(html_node == html_scope)
+                break;
+            
+            modest_node_t *m_node = html_node->parent->data;
+            render_node = m_node->render_node;
+            
+            html_node = html_node->next;
+        }
+    }
+    
+    return render_root;
+}
+
+modest_render_tree_node_t * modest_layer_binding_node(modest_t* modest, modest_render_tree_t* render_tree,
+                                                      modest_render_tree_node_t* render_root, myhtml_tree_node_t* html_node)
+{
+    if(html_node->data == NULL)
+        return NULL;
+    
+    mycss_declaration_entry_t *display = modest_declaration_by_type(modest, html_node, MyCSS_PROPERTY_TYPE_DISPLAY);
+    
+    if(display->value_type == MyCSS_PROPERTY_DISPLAY_NONE)
+        return NULL;
+    
+    modest_node_t *m_node = html_node->data;
+    
+    if(m_node->render_node == NULL) {
+        m_node->render_node = modest_render_tree_node_create_and_init(render_tree);
+    }
+    
+    modest_render_tree_node_t* render_node = m_node->render_node;
+    modest_render_tree_node_append(render_root, render_node);
+    
+    render_node->html_node = html_node;
+    
+    return render_node;
+}
+
+
diff --git a/source/modest/layer/binding.h b/source/modest/render/binding.h
index c0b5d00..2f6ad5a 100644
--- a/source/modest/layer/binding.h
+++ b/source/modest/render/binding.h
@@ -18,13 +18,16 @@
  Author: lex.borisov@gmail.com (Alexander Borisov)
 */
 
-#ifndef MODEST_LAYER_BINDING_H
-#define MODEST_LAYER_BINDING_H
+#ifndef MODEST_RENDER_BINDING_H
+#define MODEST_RENDER_BINDING_H
 #pragma once
 
 #include "modest/myosi.h"
 #include "modest/modest.h"
 #include "modest/node/node.h"
+#include "modest/render/tree.h"
+#include "modest/render/tree_node.h"
+#include "modest/declaration.h"
 
 #include "myhtml/tree.h"
 
@@ -32,10 +35,12 @@
 extern "C" {
 #endif
 
-modest_layer_t * modest_layer_binding(modest_t* modest, myhtml_tree_t* html_tree);
-
+modest_render_tree_node_t * modest_render_binding(modest_t* modest, modest_render_tree_t* render_tree, myhtml_tree_t* html_tree);
+modest_render_tree_node_t * modest_layer_binding_node(modest_t* modest, modest_render_tree_t* render_tree,
+                                                      modest_render_tree_node_t* render_root, myhtml_tree_node_t* html_node);
+    
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 
-#endif /* MODEST_LAYER_BINDING_H */
+#endif /* MODEST_RENDER_BINDING_H */
diff --git a/source/modest/render/tree.c b/source/modest/render/tree.c
new file mode 100644
index 0000000..e7cc9d9
--- /dev/null
+++ b/source/modest/render/tree.c
@@ -0,0 +1,94 @@
+/*
+ Copyright (C) 2016 Alexander Borisov
+ 
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ 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,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ 
+ Author: lex.borisov@gmail.com (Alexander Borisov)
+*/
+
+#include "modest/render/tree.h"
+
+modest_render_tree_t * modest_render_tree_create(void)
+{
+    return myhtml_calloc(1, sizeof(modest_render_tree_t));
+}
+
+modest_status_t modest_render_tree_init(modest_render_tree_t* render_tree)
+{
+    render_tree->mc_nodes = mcobject_create();
+    if(render_tree->mc_nodes == NULL)
+        return MODEST_STATUS_ERROR_MEMORY_ALLOCATION;
+    
+    myhtml_status_t myhtml_status = mcobject_init(render_tree->mc_nodes, 1024, sizeof(modest_render_tree_node_t));
+    if(myhtml_status)
+        return MODEST_STATUS_ERROR;
+    
+    return MODEST_STATUS_OK;
+}
+
+void modest_render_tree_clean_all(modest_render_tree_t* render_tree)
+{
+    memset(render_tree, 0, sizeof(modest_render_tree_t));
+}
+
+modest_render_tree_t * modest_render_tree_destroy(modest_render_tree_t* render_tree, bool self_destroy)
+{
+    if(render_tree == NULL)
+        return NULL;
+    
+    render_tree->mc_nodes = mcobject_destroy(render_tree->mc_nodes, true);
+    
+    if(self_destroy) {
+        myhtml_free(render_tree);
+        return NULL;
+    }
+    
+    return render_tree;
+}
+
+void modest_render_tree_serialization(myhtml_tree_t* html_tree, modest_render_tree_t* tree,
+                                      modest_render_tree_node_t* scope_node, mycss_callback_serialization_f callback, void* context)
+{
+    modest_render_tree_node_t* node = scope_node;
+    size_t depth = 0;
+    
+    while(node) {
+        for(size_t i = 0; i < depth; i++)
+            callback("\t", 1, context);
+        
+        modest_render_tree_node_serialization(html_tree, node, callback, context);
+        callback("\n", 1, context);
+        
+        if(node->child) {
+            depth++;
+            node = node->child;
+        }
+        else {
+            while(node != scope_node && node->next == NULL) {
+                depth--;
+                node = node->parent;
+            }
+            
+            if(node == scope_node)
+                break;
+            
+            node = node->next;
+        }
+    }
+    
+    
+}
+
+
diff --git a/source/modest/render/tree.h b/source/modest/render/tree.h
new file mode 100644
index 0000000..1c3966e
--- /dev/null
+++ b/source/modest/render/tree.h
@@ -0,0 +1,51 @@
+/*
+ Copyright (C) 2016 Alexander Borisov
+ 
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ 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,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ 
+ Author: lex.borisov@gmail.com (Alexander Borisov)
+*/
+
+#ifndef MODEST_RENDER_TREE_H
+#define MODEST_RENDER_TREE_H
+#pragma once
+
+typedef struct modest_render_tree modest_render_tree_t;
+
+#include "modest/modest.h"
+#include "myhtml/utils/mcobject.h"
+#include "modest/render/tree_node.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct modest_render_tree {
+    mcobject_t* mc_nodes;
+};
+
+modest_render_tree_t * modest_render_tree_create(void);
+modest_status_t modest_render_tree_init(modest_render_tree_t* render_tree);
+void modest_render_tree_clean_all(modest_render_tree_t* render_tree);
+modest_render_tree_t * modest_render_tree_destroy(modest_render_tree_t* render_tree, bool self_destroy);
+
+void modest_render_tree_serialization(myhtml_tree_t* html_tree, modest_render_tree_t* tree,
+                                      modest_render_tree_node_t* scope_node, mycss_callback_serialization_f callback, void* context);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* MODEST_RENDER_TREE_H */
diff --git a/source/modest/render/tree_node.c b/source/modest/render/tree_node.c
new file mode 100644
index 0000000..37eb736
--- /dev/null
+++ b/source/modest/render/tree_node.c
@@ -0,0 +1,157 @@
+/*
+ Copyright (C) 2016 Alexander Borisov
+ 
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ 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,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ 
+ Author: lex.borisov@gmail.com (Alexander Borisov)
+*/
+
+#include "modest/render/tree_node.h"
+
+modest_render_tree_node_t * modest_render_tree_node_create_and_init(modest_render_tree_t* render_tree)
+{
+    void *render_node = mcobject_malloc(render_tree->mc_nodes, NULL);
+    
+    if(render_node) {
+        memset(render_node, 0, sizeof(modest_render_tree_node_t));
+    }
+    
+    return render_node;
+}
+
+void modest_render_tree_node_clean_all(modest_render_tree_node_t* render_node)
+{
+    memset(render_node, 0, sizeof(modest_render_tree_node_t));
+}
+
+modest_render_tree_node_t * modest_render_tree_node_destroy(modest_render_tree_t* render_tree, modest_render_tree_node_t* render_node, bool self_destroy)
+{
+    if(render_node == NULL)
+        return NULL;
+    
+    if(self_destroy) {
+        mcobject_free(render_tree->mc_nodes, render_node);
+        return NULL;
+    }
+    
+    return render_node;
+}
+
+void modest_render_tree_node_append(modest_render_tree_node_t* to, modest_render_tree_node_t* node)
+{
+    if(to->child_last) {
+        to->child_last->next = node;
+        node->prev = to->child_last;
+    }
+    else {
+        to->child = node;
+        node->prev = NULL;
+    }
+    
+    node->parent = to;
+    node->next = NULL;
+    
+    to->child_last = node;
+}
+
+void modest_render_tree_node_remove(modest_render_tree_node_t* node)
+{
+    if(node->parent) {
+        if(node->next == NULL)
+            node->parent->child_last = node->prev;
+        else
+            node->next->prev = node->prev;
+        
+        if(node->prev == NULL)
+            node->parent->child = node->next;
+        else
+            node->prev->next = node->next;
+    }
+    else {
+        if(node->next)
+            node->next->prev = node->prev;
+        
+        if(node->prev)
+            node->prev->next = node->next;
+    }
+}
+
+void modest_render_tree_node_append_after(modest_render_tree_node_t* target, modest_render_tree_node_t* node)
+{
+    if(target->next) {
+        target->next->prev = node;
+    }
+    else {
+        if(target->parent)
+            target->parent->child_last = node;
+    }
+    
+    node->next = target->next;
+    node->prev = target;
+    node->parent = target->parent;
+    
+    target->next = node;
+}
+
+void modest_render_tree_node_append_before(modest_render_tree_node_t* target, modest_render_tree_node_t* node)
+{
+    if(target->prev) {
+        target->prev->next = node;
+    }
+    else {
+        if(target->parent)
+            target->parent->child = node;
+    }
+    
+    node->next = target;
+    node->prev = target->prev;
+    node->parent = target->parent;
+    
+    target->prev = node;
+}
+
+void modest_render_tree_node_serialization(myhtml_tree_t* html_tree, modest_render_tree_node_t* node, mycss_callback_serialization_f callback, void* context)
+{
+    callback("<", 1, context);
+    
+    switch (node->type) {
+        case MODEST_RENDER_TREE_NODE_TYPE_BLOCK:
+            callback("block", 5, context);
+            break;
+            
+        case MODEST_RENDER_TREE_NODE_TYPE_VIEWPORT:
+            callback("viewport", 8, context);
+            break;
+            
+        case MODEST_RENDER_TREE_NODE_TYPE_ANONYMOUS:
+            callback("anonymous", 9, context);
+            break;
+            
+        default:
+            break;
+    }
+    
+    if(node->html_node) {
+        size_t tag_length = 0;
+        const char *tag_name = myhtml_tag_name_by_id(html_tree, node->html_node->tag_id, &tag_length);
+        
+        callback(" ", 1, context);
+        callback(tag_name, tag_length, context);
+    }
+    
+    callback(">", 1, context);
+}
+
+
diff --git a/source/modest/render/tree_node.h b/source/modest/render/tree_node.h
new file mode 100644
index 0000000..15593df
--- /dev/null
+++ b/source/modest/render/tree_node.h
@@ -0,0 +1,71 @@
+/*
+ Copyright (C) 2016 Alexander Borisov
+ 
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ 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,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+ 
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ 
+ Author: lex.borisov@gmail.com (Alexander Borisov)
+*/
+
+#ifndef MODEST_RENDER_TREE_NODE_H
+#define MODEST_RENDER_TREE_NODE_H
+#pragma once
+
+typedef struct modest_render_tree_node modest_render_tree_node_t;
+
+#include "modest/modest.h"
+#include "modest/render/tree.h"
+
+#include "myhtml/tree.h"
+#include "myhtml/utils/mcobject.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum modest_render_tree_node_type {
+    MODEST_RENDER_TREE_NODE_TYPE_BLOCK     = 0,
+    MODEST_RENDER_TREE_NODE_TYPE_VIEWPORT  = 1,
+    MODEST_RENDER_TREE_NODE_TYPE_ANONYMOUS = 3
+}
+typedef modest_render_tree_node_type_t;
+
+struct modest_render_tree_node {
+    myhtml_tree_node_t* html_node;
+    modest_render_tree_node_type_t type;
+    
+    /* navigation */
+    modest_render_tree_node_t* next;
+    modest_render_tree_node_t* prev;
+    modest_render_tree_node_t* child;
+    modest_render_tree_node_t* child_last;
+    modest_render_tree_node_t* parent;
+};
+
+modest_render_tree_node_t * modest_render_tree_node_create_and_init(modest_render_tree_t* render_tree);
+void modest_render_tree_node_clean_all(modest_render_tree_node_t* render_node);
+modest_render_tree_node_t * modest_render_tree_node_destroy(modest_render_tree_t* render_tree, modest_render_tree_node_t* render_node, bool self_destroy);
+
+void modest_render_tree_node_append(modest_render_tree_node_t* to, modest_render_tree_node_t* node);
+void modest_render_tree_node_remove(modest_render_tree_node_t* node);
+void modest_render_tree_node_append_after(modest_render_tree_node_t* target, modest_render_tree_node_t* node);
+void modest_render_tree_node_append_before(modest_render_tree_node_t* target, modest_render_tree_node_t* node);
+
+void modest_render_tree_node_serialization(myhtml_tree_t* html_tree, modest_render_tree_node_t* node, mycss_callback_serialization_f callback, void* context);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* MODEST_RENDER_TREE_NODE_H */
diff --git a/source/modest/style/map.c b/source/modest/style/map.c
index 47990b5..9a355fa 100644
--- a/source/modest/style/map.c
+++ b/source/modest/style/map.c
@@ -57,7 +57,6 @@ void modest_style_map_collate_declaration_padding(modest_t* modest, myhtml_tree_
         return;
     
     mycss_values_shorthand_four_t *val_four = (mycss_values_shorthand_four_t*)decl->value;
-    mycss_declaration_t* declaration = modest->mycss_entry->declaration;
     
     if(val_four->two == NULL) {
         modest_style_map_collate_declaration_for_all(modest, node, val_four->one, MyCSS_PROPERTY_TYPE_PADDING_TOP, spec);
@@ -92,7 +91,6 @@ void modest_style_map_collate_declaration_margin(modest_t* modest, myhtml_tree_n
         return;
     
     mycss_values_shorthand_four_t *val_four = (mycss_values_shorthand_four_t*)decl->value;
-    mycss_declaration_t* declaration = modest->mycss_entry->declaration;
     
     if(val_four->two == NULL) {
         modest_style_map_collate_declaration_for_all(modest, node, val_four->one, MyCSS_PROPERTY_TYPE_MARGIN_LEFT, spec);
@@ -127,7 +125,6 @@ void modest_style_map_collate_declaration_border_width(modest_t* modest, myhtml_
         return;
     
     mycss_values_shorthand_four_t *val_four = (mycss_values_shorthand_four_t*)decl->value;
-    mycss_declaration_t* declaration = modest->mycss_entry->declaration;
     
     if(val_four->two == NULL) {
         modest_style_map_collate_declaration_for_all(modest, node, val_four->one, MyCSS_PROPERTY_TYPE_BORDER_TOP_WIDTH, spec);
diff --git a/source/mycss/convert.c b/source/mycss/convert.c
index 1422fd2..724fe13 100644
--- a/source/mycss/convert.c
+++ b/source/mycss/convert.c
@@ -37,7 +37,7 @@ size_t mycss_convert_data_to_double(const char *data, size_t size, double *retur
     *return_num = 0.0f;
     
     switch (data[offset]) {
-        case '-': is_negative = true;
+        case '-': is_negative = true; /* fall through */
         case '+': offset++;
     }
     
@@ -108,7 +108,7 @@ size_t mycss_convert_data_to_double(const char *data, size_t size, double *retur
     {
         ++offset;
         
-        if(offset >= size || ((data[offset] != '-' || data[offset] != '+') &&
+        if(offset >= size || ((data[offset] != '-' || data[offset] != '+') ||
                               (data[offset] < '0' || data[offset] > '9'))) {
             offset--;
         }
@@ -117,7 +117,7 @@ size_t mycss_convert_data_to_double(const char *data, size_t size, double *retur
             is_negative = false;
             
             switch(data[offset]) {
-                case '-': is_negative = true;
+                case '-': is_negative = true; /* fall through */
                 case '+': offset++;
             }
             
diff --git a/source/mycss/declaration/init.c b/source/mycss/declaration/init.c
index 6572ef9..056e14c 100644
--- a/source/mycss/declaration/init.c
+++ b/source/mycss/declaration/init.c
@@ -142,6 +142,7 @@ mycss_declaration_entry_t * mycss_declaration_parse(mycss_declaration_t* declara
         if(out_status)
             *out_status = status;
         
+        entry->token_ready_callback = tmp_token_ready_callback;
         return NULL;
     }
     
diff --git a/source/mycss/declaration/serialization.c b/source/mycss/declaration/serialization.c
index a0a1009..508b36b 100644
--- a/source/mycss/declaration/serialization.c
+++ b/source/mycss/declaration/serialization.c
@@ -335,9 +335,7 @@ bool mycss_declaration_serialization_font(mycss_entry_t* entry, mycss_declaratio
     }
     
     if(font->family) {
-        if(set_ws == false)
-            set_ws = true;
-        else
+        if(set_ws == true)
             callback(" ", 1, context);
         
         mycss_declaration_serialization_font_family(entry, font->family, callback, context);
@@ -381,7 +379,7 @@ bool mycss_declaration_serialization_border_radius(mycss_entry_t* entry, mycss_d
     }
     
     if(value->four && ((mycss_values_shorthand_two_type_t*)(value->four->value))->one) {
-        if(o_e) callback(" ", 1, context); else o_e = true;
+        if(o_e) callback(" ", 1, context);
         
         short_two_type = value->four->value;
         mycss_property_serialization_value(short_two_type->type_one, short_two_type->one, callback, context);
@@ -399,7 +397,9 @@ bool mycss_declaration_serialization_border_radius(mycss_entry_t* entry, mycss_d
     
     if(value->two && ((mycss_values_shorthand_two_type_t*)(value->two->value))->two) {
         if(o_e == false) callback(" / ", 3, context);
-        if(o_e) callback(" ", 1, context); else o_e = true;
+        else callback(" ", 1, context);
+        
+        o_e = true;
         
         short_two_type = value->two->value;
         mycss_property_serialization_value(short_two_type->type_two, short_two_type->two, callback, context);
@@ -407,7 +407,9 @@ bool mycss_declaration_serialization_border_radius(mycss_entry_t* entry, mycss_d
     
     if(value->three && ((mycss_values_shorthand_two_type_t*)(value->three->value))->two) {
         if(o_e == false) callback(" / ", 3, context);
-        if(o_e) callback(" ", 1, context); else o_e = true;
+        else callback(" ", 1, context);
+        
+        o_e = true;
         
         short_two_type = value->three->value;
         mycss_property_serialization_value(short_two_type->type_two, short_two_type->two, callback, context);
@@ -415,7 +417,7 @@ bool mycss_declaration_serialization_border_radius(mycss_entry_t* entry, mycss_d
     
     if(value->four && ((mycss_values_shorthand_two_type_t*)(value->four->value))->two) {
         if(o_e == false) callback(" / ", 3, context);
-        if(o_e) callback(" ", 1, context); else o_e = true;
+        else callback(" ", 1, context);
         
         short_two_type = value->four->value;
         mycss_property_serialization_value(short_two_type->type_two, short_two_type->two, callback, context);
@@ -599,7 +601,8 @@ bool mycss_declaration_serialization_background_position(mycss_entry_t* entry, m
     }
     
     if(position->four.type) {
-        if(o_e) callback(" ", 1, context); else o_e = true;
+        if(o_e) callback(" ", 1, context);
+        
         mycss_property_serialization_value(position->four.type, position->four.length, callback, context);
     }
     
diff --git a/source/mycss/declaration/state.c b/source/mycss/declaration/state.c
index 9f2c583..04f0512 100644
--- a/source/mycss/declaration/state.c
+++ b/source/mycss/declaration/state.c
@@ -74,7 +74,7 @@ bool mycss_declaration_state_ident(mycss_entry_t* entry, mycss_token_t* token, b
 bool mycss_declaration_state_colon_before_important(mycss_entry_t* entry, mycss_token_t* token, bool last_response)
 {
     if(token->type == MyCSS_TOKEN_TYPE_WHITESPACE)
-        return token;
+        return true;
     else if(token->type == MyCSS_TOKEN_TYPE_SEMICOLON) {
         entry->parser = mycss_declaration_state_data;
         return true;
diff --git a/source/mycss/mycss.c b/source/mycss/mycss.c
index fda514d..ab307ff 100644
--- a/source/mycss/mycss.c
+++ b/source/mycss/mycss.c
@@ -203,9 +203,6 @@ myhtml_encoding_t mycss_encoding_check_charset_rule(const char* css, size_t size
     size_t begin = 10;
     size_t length = begin;
     
-    if(begin >= size)
-        return MyHTML_ENCODING_UTF_8;
-    
     while(length < size) {
         if(css[length] == '"')
         {
diff --git a/source/mycss/namespace/init.c b/source/mycss/namespace/init.c
index 7283328..017449f 100644
--- a/source/mycss/namespace/init.c
+++ b/source/mycss/namespace/init.c
@@ -112,9 +112,15 @@ void mycss_namespace_entry_append_to_current(mycss_namespace_t* ns, mycss_namesp
 
 mycss_status_t mycss_namespace_stylesheet_init(mycss_namespace_stylesheet_t* ns_stylesheet, mycss_entry_t* entry)
 {
-    ns_stylesheet->name_tree     = mctree_create(14);
+    ns_stylesheet->name_tree = mctree_create(14);
+    if(ns_stylesheet->name_tree == NULL)
+        return MyCSS_STATUS_ERROR_NAMESPACE_CREATE;
+    
     ns_stylesheet->ns_id_counter = 0;
+    
     ns_stylesheet->entry_default = mycss_namespace_entry_create(entry->ns);
+    if(ns_stylesheet->entry_default == NULL)
+        return MyCSS_STATUS_ERROR_NAMESPACE_ENTRIES_CREATE;
     
     mycss_namespace_entry_clean(ns_stylesheet->entry_default);
     mycss_namespace_entry_clean(&ns_stylesheet->entry_undef);
@@ -132,9 +138,6 @@ mycss_status_t mycss_namespace_stylesheet_init(mycss_namespace_stylesheet_t* ns_
     myhtml_string_append(ns_stylesheet->entry_any.name, "*", 1);
     ns_stylesheet->entry_any.ns_id = MyHTML_NAMESPACE_ANY;
     
-    if(ns_stylesheet->entry_default == NULL)
-        return MyCSS_STATUS_ERROR_NAMESPACE_ENTRIES_CREATE;
-    
     mycss_namespace_stylesheet_init_default(ns_stylesheet, entry, NULL, 0, MyHTML_NAMESPACE_ANY);
     
     return MyCSS_STATUS_OK;
diff --git a/source/mycss/namespace/parser.c b/source/mycss/namespace/parser.c
index f00f88e..c442316 100644
--- a/source/mycss/namespace/parser.c
+++ b/source/mycss/namespace/parser.c
@@ -72,6 +72,9 @@ void mycss_namespace_parser_end(mycss_entry_t* entry, mycss_token_t* token)
 
 void mycss_namespace_parser_expectations_error(mycss_entry_t* entry, mycss_token_t* token)
 {
+    if(entry->ns->entry_last == NULL)
+        return;
+    
     mycss_namespace_entry_t *ns_entry = entry->ns->entry_last;
     mycss_namespace_entry_destroy(ns_entry, entry, false);
     
@@ -83,10 +86,7 @@ void mycss_namespace_parser_expectations_error(mycss_entry_t* entry, mycss_token
         entry->ns->entry_last = NULL;
     }
     
-    if(ns_entry)
-        mcobject_free(entry->ns->mcobject_entries, ns_entry);
-    
-    printf("Expectations error: Namespace!\n");
+    mcobject_free(entry->ns->mcobject_entries, ns_entry);
 }
 
 
diff --git a/source/mycss/property/parser.c b/source/mycss/property/parser.c
index 93e099b..3c0e4a6 100644
--- a/source/mycss/property/parser.c
+++ b/source/mycss/property/parser.c
@@ -1106,12 +1106,8 @@ bool mycss_property_parser_border_color(mycss_entry_t* entry, mycss_token_t* tok
         unsigned int value_type = 0;
         if(mycss_property_shared_default(entry, token, &value_type, &str))
         {
-            if(value == NULL) {
-                dec_entry->value_type = value_type;
-                return mycss_property_parser_destroy_string(&str, mycss_property_shared_switch_to_find_important(entry));
-            }
-            
-            return mycss_property_parser_destroy_string(&str, mycss_property_shared_switch_to_parse_error(entry));
+            dec_entry->value_type = value_type;
+            return mycss_property_parser_destroy_string(&str, mycss_property_shared_switch_to_find_important(entry));
         }
         
         mycss_declaration_entry_t* shared_declr;
@@ -2055,7 +2051,7 @@ bool mycss_property_parser_font_step_one(mycss_entry_t* entry, mycss_token_t* to
     
     if(mycss_property_shared_font_style(entry, token, &value_type, &str))
     {
-        if(   font->style)
+        if(font->style)
             return mycss_property_parser_destroy_string(&str, mycss_property_shared_switch_to_parse_error(entry));
         
         font->style = mycss_declaration_entry_create(entry->declaration, NULL);
diff --git a/source/mycss/property/shared.c b/source/mycss/property/shared.c
index bfe7727..25b77b4 100644
--- a/source/mycss/property/shared.c
+++ b/source/mycss/property/shared.c
@@ -375,6 +375,7 @@ bool mycss_property_shared_text_decoration_line(mycss_entry_t* entry, mycss_toke
                 *value_type = text_dec_type;
                 return true;
             }
+            /* fall through */
             
         default:
             *value_type = MyCSS_PROPERTY_VALUE_UNDEF;
diff --git a/source/mycss/selectors/function_parser.c b/source/mycss/selectors/function_parser.c
index 0f37d08..3850954 100644
--- a/source/mycss/selectors/function_parser.c
+++ b/source/mycss/selectors/function_parser.c
@@ -137,10 +137,10 @@ bool mycss_selectors_function_parser_not_or_matches_or_current_parser(mycss_entr
     selectors_list = mycss_selectors_parser_check_selector_list(selectors, selectors_list);
     
     if(selectors_list == NULL) {
-        if(selectors->entry_last)
+        if(selectors->entry_last) {
             selectors->entry_last->value = NULL;
-        
-        selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
+            selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
+        }
     }
     else if((selectors_list->flags & MyCSS_SELECTORS_FLAGS_SELECTOR_BAD) && selectors->entry_last) {
         selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
@@ -198,10 +198,10 @@ bool mycss_selectors_function_parser_has(mycss_entry_t* entry, mycss_token_t* to
     selectors_list = mycss_selectors_parser_check_selector_list(selectors, selectors_list);
     
     if(selectors_list == NULL) {
-        if(selectors->entry_last)
+        if(selectors->entry_last) {
             selectors->entry_last->value = NULL;
-        
-        selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
+            selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
+        }
     }
     else if((selectors_list->flags & MyCSS_SELECTORS_FLAGS_SELECTOR_BAD) && selectors->entry_last) {
         selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
@@ -324,9 +324,8 @@ bool mycss_selectors_function_parser_nth_with_selectors_need_of_after(mycss_entr
     if(selectors_list == NULL) {
         if(selectors->entry_last) {
             mycss_selector_value_an_plus_b(selectors->entry_last->value)->of = NULL;
+            selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
         }
-        
-        selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
     }
     else if((selectors_list->flags & MyCSS_SELECTORS_FLAGS_SELECTOR_BAD) && selectors->entry_last) {
         selectors->entry_last->flags |= MyCSS_SELECTORS_FLAGS_SELECTOR_BAD;
diff --git a/source/mycss/selectors/myosi.h b/source/mycss/selectors/myosi.h
index 81be9ea..e3d7e36 100644
--- a/source/mycss/selectors/myosi.h
+++ b/source/mycss/selectors/myosi.h
@@ -213,7 +213,7 @@ struct mycss_selectors {
 
 struct mycss_selectors_entry {
     mycss_selectors_type_t type;
-    int sub_type;
+    unsigned int sub_type;
     mycss_selectors_flags_t flags;
     
     mycss_namespace_entry_t* ns_entry;
diff --git a/source/mycss/selectors/serialization.c b/source/mycss/selectors/serialization.c
index 81498f2..00933ad 100644
--- a/source/mycss/selectors/serialization.c
+++ b/source/mycss/selectors/serialization.c
@@ -228,6 +228,10 @@ bool mycss_selectors_serialization_selector(mycss_selectors_t* selectors, mycss_
                     break;
                 }
                     
+                case MyCSS_SELECTORS_SUB_TYPE_PSEUDO_CLASS_FUNCTION_UNKNOWN:
+                    callback("^UST", 4, context);
+                    break;
+                    
                 default:
                     break;
             }
@@ -263,9 +267,6 @@ bool mycss_selectors_serialization_selector(mycss_selectors_t* selectors, mycss_
         }
     };
     
-    if(selector->sub_type == MyCSS_SELECTORS_SUB_TYPE_UNKNOWN)
-        callback("^UST", 4, context);
-    
     if(selector->flags & MyCSS_SELECTORS_FLAGS_SELECTOR_BAD)
         callback("^B", 2, context);
     
diff --git a/source/mycss/tokenizer.c b/source/mycss/tokenizer.c
index e6fd62a..522c60d 100644
--- a/source/mycss/tokenizer.c
+++ b/source/mycss/tokenizer.c
@@ -124,6 +124,9 @@ size_t mycss_tokenizer_state_set_current_buffer_for_continue(mycss_entry_t* entr
     while(buffer && buffer->offset > position)
         buffer = buffer->prev;
     
+    if(buffer == NULL)
+        return 0;
+    
     entry->current_buffer = buffer;
     
     return (position - buffer->offset);
diff --git a/source/mycss/values/color.c b/source/mycss/values/color.c
index de3c488..cb22714 100644
--- a/source/mycss/values/color.c
+++ b/source/mycss/values/color.c
@@ -63,7 +63,7 @@ mycss_values_color_id_t mycss_values_color_id_by_name(const char *name, size_t l
 
 const char * mycss_values_color_name_by_id(mycss_values_color_id_t color_id, size_t *length)
 {
-    if(color_id > MyCSS_VALUES_COLOR_ID_LAST_ENTRY) {
+    if(color_id >= MyCSS_VALUES_COLOR_ID_LAST_ENTRY) {
         if(length)
             *length = 0;
         
@@ -119,7 +119,7 @@ mycss_values_color_function_id_t mycss_values_color_function_id_by_name(const ch
 
 const char * mycss_values_color_function_name_by_id(mycss_values_color_function_id_t color_function_id, size_t *length)
 {
-    if(color_function_id > MyCSS_VALUES_COLOR_FUNCTION_ID_LAST_ENTRY) {
+    if(color_function_id >= MyCSS_VALUES_COLOR_FUNCTION_ID_LAST_ENTRY) {
         if(length)
             *length = 0;
         
diff --git a/source/mycss/values/color_parser.c b/source/mycss/values/color_parser.c
index 9cb1c92..661da53 100644
--- a/source/mycss/values/color_parser.c
+++ b/source/mycss/values/color_parser.c
@@ -284,6 +284,7 @@ bool mycss_values_color_parser_rgb_before_alpha_percentage(mycss_entry_t* entry,
                 entry->parser = mycss_values_color_parser_rgb_alpha_percentage;
                 return true;
             }
+            /* fall through */
             
         default:
             mycss_values_color_parser_switch_parser(entry);
@@ -432,6 +433,7 @@ bool mycss_values_color_parser_rgb_before_alpha_number(mycss_entry_t* entry, myc
                 entry->parser = mycss_values_color_parser_rgb_alpha_number;
                 return true;
             }
+            /* fall through */
             
         default:
             mycss_values_color_parser_switch_parser(entry);
@@ -640,6 +642,7 @@ bool mycss_values_color_parser_hsl_before_alpha(mycss_entry_t* entry, mycss_toke
                 entry->parser = mycss_values_color_parser_hsl_alpha;
                 return true;
             }
+            /* fall through */
             
         default:
             mycss_values_color_parser_switch_parser(entry);
@@ -911,6 +914,7 @@ bool mycss_values_color_parser_hwb_before_alpha(mycss_entry_t* entry, mycss_toke
                 entry->parser = mycss_values_color_parser_hwb_alpha;
                 return true;
             }
+            /* fall through */
             
         default:
             mycss_values_color_parser_switch_parser(entry);
@@ -1000,6 +1004,7 @@ bool mycss_values_color_parser_gray_before_alpha(mycss_entry_t* entry, mycss_tok
                 entry->parser = mycss_values_color_parser_gray_alpha;
                 return true;
             }
+            /* fall through */
             
         default:
             mycss_values_color_parser_switch_parser(entry);
diff --git a/source/mycss/values/serialization.c b/source/mycss/values/serialization.c
index 99a73c7..f46b2e4 100644
--- a/source/mycss/values/serialization.c
+++ b/source/mycss/values/serialization.c
@@ -586,7 +586,7 @@ void mycss_values_serialization_border(mycss_values_border_t* border, mycss_call
     }
     
     if(border->color) {
-        if(o_e) callback(" ", 1, context); else o_e = true;
+        if(o_e) callback(" ", 1, context);
         mycss_declaration_serialization_entry_only_value(NULL, border->color, callback, context);
     }
 }
diff --git a/source/myfont/cmap.c b/source/myfont/cmap.c
index a101404..0bce7c2 100644
--- a/source/myfont/cmap.c
+++ b/source/myfont/cmap.c
@@ -232,7 +232,7 @@ myfont_status_t myfont_load_table_cmap(myfont_font_t *mf)
     if(table_offset == 0)
         return MyFONT_STATUS_OK;
     
-    if(mf->file_size < (table_offset + 4))
+    if((table_offset + 4) > mf->file_size)
         return MyFONT_STATUS_ERROR_TABLE_UNEXPECTED_ENDING;
     
     /* get current data */
diff --git a/source/myfont/glyf.c b/source/myfont/glyf.c
index 856ad9f..2b5851e 100644
--- a/source/myfont/glyf.c
+++ b/source/myfont/glyf.c
@@ -66,14 +66,14 @@ myfont_status_t myfont_glyf_load_data(myfont_font_t *mf, myfont_table_glyph_t *g
 {
     memset(&glyph->head, 0, sizeof(myfont_table_glyf_head_t));
     
-    /* get current data */
-    uint8_t *data = &mf->file_data[offset];
-    
     // load head
     offset += 10;
     if(offset > mf->file_size)
         return MyFONT_STATUS_ERROR_TABLE_UNEXPECTED_ENDING;
     
+    /* get current data */
+    uint8_t *data = &mf->file_data[offset];
+    
     glyph->head.numberOfContours = myfont_read_16(&data);
     glyph->head.xMin = myfont_read_16(&data);
     glyph->head.yMin = myfont_read_16(&data);
diff --git a/source/myfont/myfont.c b/source/myfont/myfont.c
index 4c021d8..b3de3a6 100644
--- a/source/myfont/myfont.c
+++ b/source/myfont/myfont.c
@@ -22,11 +22,12 @@
 
 const char myfont_table_name[][5] = {
     "cmap", "head", "hhea", "hmtx", "maxp", "name",
-    "OS/2", "post", "cvt ", "fpgm", "glyf", "loca",
-    "prep", "CFF ", "VORG", "EBDT", "EBLC", "EBSC",
-    "BASE", "GDEF", "GPOS", "GSUB", "JSTF", "DSIG",
-    "gasp", "hdmx", "kern", "LTSH", "PCLT", "VDMX",
-    "vhea", "vmtx"
+    "OS/2", "post", "cvt" , "fpgm", "glyf", "loca",
+    "prep", "gasp", "CFF" , "VORG", "SVG" , "EBDT",
+    "EBLC", "EBSC", "CBDT", "CBLC", "BASE", "GDEF",
+    "GPOS", "GSUB", "JSTF", "MATH", "DSIG", "hdmx",
+    "kern", "LTSH", "PCLT", "VDMX", "vhea", "vmtx",
+    "COLR", "CPAL"
 };
 
 myfont_font_t * myfont_create(void)
@@ -152,7 +153,7 @@ myfont_status_t myfont_load(myfont_font_t *mf, const char *filepath)
     if(mf->file_size < 12)
         return MyFONT_STATUS_ERROR_TABLE_UNEXPECTED_ENDING;
     
-    uint8_t *data = (uint8_t*)mf->file_data;
+    uint8_t *data = mf->file_data;
     
     mf->header.version_major = myfont_read_u16(&data);
     mf->header.version_minor = myfont_read_u16(&data);
@@ -286,7 +287,7 @@ void myfont_font_print_exists_table(myfont_font_t *mf, FILE *file)
 {
     size_t i;
     for(i = 0; i < MyFONT_TKEY_LAST_KEY; i++)
-    {
+    { 
         if(mf->cache.tables_offset[i]) {
             fprintf(file, "%s = %u\n", myfont_table_name[i], mf->cache.tables_offset[i]);
         }
diff --git a/source/myhtml/Makefile b/source/myhtml/Makefile
new file mode 100644
index 0000000..f24973c
--- /dev/null
+++ b/source/myhtml/Makefile
@@ -0,0 +1,53 @@
+TARGET := source/myhtml
+SRCDIR := source/myhtml
+
+CC ?= gcc
+
+LIBPOSTFIX := .so
+LIBNAME    := myhtml
+LIBSTATIC_POSTFIX  := _static
+
+MyHTML_OPTIMIZATION_LEVEL ?= -O2
+
+CFLAGS ?= -Wall -Werror
+CFLAGS += $(MyHTML_OPTIMIZATION_LEVEL) -fPIC --std=c99 -I..
+
+MyHTML_BUILD_WITHOUT_THREADS ?= NO
+ifeq ($(MyHTML_BUILD_WITHOUT_THREADS),YES)
+    $(info Build without POSIX Threads)
+	CFLAGS += -DMyHTML_BUILD_WITHOUT_THREADS
+else
+    $(info Build with POSIX Threads)
+	CFLAGS += -pthread
+endif
+
+ifeq ($(OS),Windows_NT)
+else
+	UNAM := $(shell uname -s)
+	ifeq ($(UNAM),Darwin)
+		LIBPOSTFIX := .dylib
+	else
+		CFLAGS += -D_POSIX_C_SOURCE=199309L
+	endif
+endif
+
+SRCS := $(wildcard *.c)
+SRCS += $(wildcard utils/*.c)
+HDRS := $(wildcard *.h)
+HDRS += $(wildcard utils/*.h)
+OBJS := $(patsubst %.c, %.o, $(SRCS))
+
+all: shared static
+
+shared: $(OBJS) $(HDRS)
+	$(CC) -shared $(LDFLAGS) $(OBJS) -o lib$(LIBNAME)$(LIBPOSTFIX)
+
+static: shared
+	$(AR) crus lib$(LIBNAME)$(LIBSTATIC_POSTFIX).a $(OBJS)
+
+clean:
+	rm -rf *.o
+	rm -rf utils/*.o
+	rm -rf *lib$(LIBNAME)*
+
+.PHONY: all clean
diff --git a/source/myhtml/api.h b/source/myhtml/api.h
index ad94e84..794b9c7 100644..100755
--- a/source/myhtml/api.h
+++ b/source/myhtml/api.h
@@ -36,7 +36,7 @@
 
 #define MyHTML_VERSION_MAJOR 1
 #define MyHTML_VERSION_MINOR 0
-#define MyHTML_VERSION_PATCH 4
+#define MyHTML_VERSION_PATCH 5
 
 #include <stdbool.h>
 #include <stddef.h>
@@ -577,6 +577,7 @@ typedef myhtml_version_t;
 // callback functions
 typedef void* (*myhtml_callback_token_f)(myhtml_tree_t* tree, myhtml_token_node_t* token, void* ctx);
 typedef void (*myhtml_callback_tree_node_f)(myhtml_tree_t* tree, myhtml_tree_node_t* node, void* ctx);
+typedef void (*myhtml_callback_serialize_f)(const char* buffer, size_t size, void* ctx);
 
 /***********************************************************************************
  *
@@ -2714,28 +2715,74 @@ myhtml_strncasecmp(const char* str1, const char* str2, size_t size);
  ***********************************************************************************/
 
 /**
- * Tree fragment serialization
+ * Tree fragment serialization 
+ * The same as myhtml_serialization_tree_buffer function
+ */
+bool
+myhtml_serialization(myhtml_tree_t* tree, myhtml_tree_node_t* scope_node,
+                     myhtml_string_raw_t* str);
+
+/**
+ * Only one tree node serialization
+ * The same as myhtml_serialization_node_buffer function
+ */
+bool
+myhtml_serialization_node(myhtml_tree_t* tree, myhtml_tree_node_t* node,
+                          myhtml_string_raw_t* str);
+
+/**
+ * Serialize tree to an output string
  *
  * @param[in] myhtml_tree_t*
- * @param[in] scope node, myhtml_tree_node_t*
- * @param[in] myhtml_string_raw_t* (date to be created if str_raw.data == NULL)
+ * @param[in] scope node
+ * @param[in] myhtml_string_raw_t*
  *
  * @return true if successful, otherwise false
  */
 bool
-myhtml_serialization(myhtml_tree_t* tree, myhtml_tree_node_t* scope_node, myhtml_string_raw_t* str);
+myhtml_serialization_tree_buffer(myhtml_tree_t* tree, myhtml_tree_node_t* scope_node,
+                                 myhtml_string_raw_t* str);
 
 /**
- * Only one tree node serialization
+ * Serialize node to an output string
  *
  * @param[in] myhtml_tree_t*
- * @param[in] myhtml_tree_node_t*
- * @param[in] myhtml_string_raw_t* (date to be created if str_raw.data == NULL)
+ * @param[in] node
+ * @param[in] myhtml_string_raw_t*
+ *
+ * @return true if successful, otherwise false
+ */
+bool
+myhtml_serialization_node_buffer(myhtml_tree_t* tree, myhtml_tree_node_t* node,
+                                 myhtml_string_raw_t* str);
+
+/**
+ * The serialize function for an entire tree
+ *
+ * @param[in] tree        the tree to be serialized
+ * @param[in] scope_node  the scope_node
+ * @param[in] callback    function that will be called for all strings that have to be printed
+ * @param[in] ptr         user-supplied pointer
+ *
+ * @return true if successful, otherwise false
+ */
+bool
+myhtml_serialization_tree_callback(myhtml_tree_t* tree, myhtml_tree_node_t* scope_node,
+                                   myhtml_callback_serialize_f callback, void* ptr);
+
+/**
+ * The serialize function for a single node
+ *
+ * @param[in] tree        the tree to be serialized
+ * @param[in] node        the node that is going to be serialized
+ * @param[in] callback    function that will be called for all strings that have to be printed
+ * @param[in] ptr         user-supplied pointer
  *
  * @return true if successful, otherwise false
  */
 bool
-myhtml_serialization_node(myhtml_tree_t* tree, myhtml_tree_node_t* node, myhtml_string_raw_t* str);
+myhtml_serialization_node_callback(myhtml_tree_t* tree, myhtml_tree_node_t* node,
+                                   myhtml_callback_serialize_f callback, void* ptr);
 
 /***********************************************************************************
  *
diff --git a/source/myhtml/encoding.c b/source/myhtml/encoding.c
index 1c7560a..078ac5c 100644
--- a/source/myhtml/encoding.c
+++ b/source/myhtml/encoding.c
@@ -398,7 +398,7 @@ unsigned long myhtml_encoding_index_gb18030_ranges_code_point(unsigned long poin
         return 0xe7c7;
     
     // step 3
-    unsigned long offset = sizeof(myhtml_encoding_map_gb18030_ranges) / sizeof(unsigned long);
+    unsigned long offset = sizeof(myhtml_encoding_map_gb18030_ranges) / (sizeof(unsigned long) * 2);
     
     unsigned long code_point_offset = 0;
     while (offset) {
diff --git a/source/myhtml/myhtml.c b/source/myhtml/myhtml.c
index 7edeaf1..6b3bbd2 100644
--- a/source/myhtml/myhtml.c
+++ b/source/myhtml/myhtml.c
@@ -1434,35 +1434,50 @@ void myhtml_queue_add(myhtml_tree_t *tree, size_t begin, myhtml_token_node_t* to
         }
     }
     
-    qnode->token = token;
-    
 #ifndef MyHTML_BUILD_WITHOUT_THREADS
     
     if(tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) {
-        myhtml_parser_worker(0, qnode);
-        myhtml_parser_stream(0, qnode);
+        if(qnode) {
+            qnode->token = token;
+            
+            myhtml_parser_worker(0, qnode);
+            myhtml_parser_stream(0, qnode);
+        }
         
         tree->current_qnode = mythread_queue_node_malloc_limit(tree->myhtml->thread, tree->queue, 4, NULL);
     }
     else {
+        if(qnode)
+            qnode->token = token;
+            
         tree->current_qnode = mythread_queue_node_malloc_round(tree->myhtml->thread, tree->queue_entry, NULL);
     }
     
 #else
     
-    myhtml_parser_worker(0, qnode);
-    myhtml_parser_stream(0, qnode);
+    f(qnode) {
+        qnode->token = token;
+        
+        myhtml_parser_worker(0, qnode);
+        myhtml_parser_stream(0, qnode);
+    }
     
     tree->current_qnode = mythread_queue_node_malloc_limit(tree->myhtml->thread, tree->queue, 4, NULL);
     
 #endif /* MyHTML_BUILD_WITHOUT_THREADS */
     
+    if(tree->current_qnode == NULL) {
+        // TODO: add return status
+        return;
+    }
+    
     tree->current_qnode->tree = tree;
     tree->current_qnode->prev = qnode;
     
-    if(qnode)
+    if(qnode && token)
         myhtml_tokenizer_calc_current_namespace(tree, token);
     
+    // TODO: add check created node
     myhtml_token_node_malloc(tree->token, tree->current_token_node, tree->token->mcasync_token_id);
     
     tree->current_token_node->raw_begin = tree->current_token_node->element_begin = (tree->global_offset + begin);
diff --git a/source/myhtml/myosi.h b/source/myhtml/myosi.h
index 530dd72..4c516a8 100644
--- a/source/myhtml/myosi.h
+++ b/source/myhtml/myosi.h
@@ -31,7 +31,7 @@
 
 #define MyHTML_VERSION_MAJOR 1
 #define MyHTML_VERSION_MINOR 0
-#define MyHTML_VERSION_PATCH 4
+#define MyHTML_VERSION_PATCH 5
 
 #if (defined(_WIN32) || defined(_WIN64)) && !defined(__WINPTHREADS_VERSION)
 #define IS_OS_WINDOWS
diff --git a/source/myhtml/serialization.c b/source/myhtml/serialization.c
index ef76b94..9685cd0 100644..100755
--- a/source/myhtml/serialization.c
+++ b/source/myhtml/serialization.c
@@ -269,9 +269,15 @@ void myhtml_serialization_append(const char *data, size_t size, myhtml_callback_
             notwritten = 0;
             break;
         case 0xA0:
-            if (notwritten) callback(data + i - notwritten, notwritten, ptr);
-            callback("&nbsp;", 6, ptr);
-            notwritten = 0;
+            if(i > 0 && (unsigned char)(data[(i - 1)]) == 0xC2) {
+                if (notwritten) callback(data + i - notwritten, (notwritten - 1), ptr);
+                callback("&nbsp;", 6, ptr);
+                notwritten = 0;
+            }
+            else {
+                ++notwritten;
+            }
+            
             break;
         default:
             ++notwritten;
@@ -308,9 +314,15 @@ void myhtml_serialization_append_attr(const char* data, size_t size, myhtml_call
             notwritten = 0;
             break;
         case 0xA0:
-            if (notwritten) callback(data + i - notwritten, notwritten, ptr);
-            callback("&nbsp;", 6, ptr);
-            notwritten = 0;
+            if(i > 0 && (unsigned char)(data[(i - 1)]) == 0xC2) {
+                if (notwritten) callback(data + i - notwritten, (notwritten - 1), ptr);
+                callback("&nbsp;", 6, ptr);
+                notwritten = 0;
+            }
+            else {
+                ++notwritten;
+            }
+            
             break;
         default:
             ++notwritten;
diff --git a/source/myhtml/tree.c b/source/myhtml/tree.c
index cd5e929..6bf7772 100644
--- a/source/myhtml/tree.c
+++ b/source/myhtml/tree.c
@@ -71,14 +71,6 @@ myhtml_status_t myhtml_tree_init(myhtml_tree_t* tree, myhtml_t* myhtml)
     if(mcstatus)
         return MyHTML_STATUS_TREE_ERROR_MCOBJECT_INIT;
     
-    if(status) {
-        myhtml->parse_state_func = NULL;
-        myhtml->insertion_func = NULL;
-        myhtml->thread = NULL;
-        
-        return status;
-    }
-    
     tree->mchar              = mchar_async_create(128, (4096 * 5));
     tree->active_formatting  = myhtml_tree_active_formatting_init(tree);
     tree->open_elements      = myhtml_tree_open_elements_init(tree);
@@ -880,7 +872,7 @@ void myhtml_tree_list_insert_by_index(myhtml_tree_list_t* list, myhtml_tree_node
     
     myhtml_tree_node_t** node_list = list->list;
     
-    memmove(&node_list[(index + 1)], &node_list[index], sizeof(myhtml_tree_node_t**) * (list->length - index));
+    memmove(&node_list[(index + 1)], &node_list[index], sizeof(myhtml_tree_node_t*) * (list->length - index));
     
     list->list[index] = node;
     list->length++;
@@ -961,7 +953,7 @@ void myhtml_tree_open_elements_remove(myhtml_tree_t* tree, myhtml_tree_node_t* n
         
         if(list[el_idx] == node)
         {
-            memmove(&list[el_idx], &list[el_idx + 1], sizeof(myhtml_tree_node_t**) * (tree->open_elements->length - el_idx));
+            memmove(&list[el_idx], &list[el_idx + 1], sizeof(myhtml_tree_node_t*) * (tree->open_elements->length - el_idx));
             tree->open_elements->length--;
             
             break;
@@ -1451,7 +1443,7 @@ void myhtml_tree_active_formatting_remove(myhtml_tree_t* tree, myhtml_tree_node_
         
         if(list[el_idx] == node)
         {
-            memmove(&list[el_idx], &list[el_idx + 1], sizeof(myhtml_tree_node_t**) * (tree->active_formatting->length - el_idx));
+            memmove(&list[el_idx], &list[el_idx + 1], sizeof(myhtml_tree_node_t*) * (tree->active_formatting->length - el_idx));
             tree->active_formatting->length--;
             
             break;
@@ -1469,7 +1461,7 @@ void myhtml_tree_active_formatting_remove_by_index(myhtml_tree_t* tree, size_t i
 {
     myhtml_tree_node_t** list = tree->active_formatting->list;
     
-    memmove(&list[idx], &list[idx + 1], sizeof(myhtml_tree_node_t**) * (tree->active_formatting->length - idx));
+    memmove(&list[idx], &list[idx + 1], sizeof(myhtml_tree_node_t*) * (tree->active_formatting->length - idx));
     tree->active_formatting->length--;
     
 #ifdef DEBUG_MODE
diff --git a/source/myhtml/utils.c b/source/myhtml/utils.c
index 2134270..eb5c741 100644
--- a/source/myhtml/utils.c
+++ b/source/myhtml/utils.c
@@ -54,14 +54,8 @@ static const unsigned char myhtml_utils_chars_map[] = {
 
 size_t myhtml_strncasecmp(const char* str1, const char* str2, size_t size)
 {
-    if(str1 == NULL) {
-        if(str2 == NULL)
-            return 0;
-        
-        return 1;
-    }
-    else if(str2 == NULL) {
-        if(str1 == NULL)
+    if(str1 == NULL || str2 == NULL) {
+        if(str1 == str2)
             return 0;
         
         return 1;
@@ -86,14 +80,8 @@ size_t myhtml_strncasecmp(const char* str1, const char* str2, size_t size)
 
 size_t myhtml_strcasecmp(const char* str1, const char* str2)
 {
-    if(str1 == NULL) {
-        if(str2 == NULL)
-            return 0;
-        
-        return 1;
-    }
-    else if(str2 == NULL) {
-        if(str1 == NULL)
+    if(str1 == NULL || str2 == NULL) {
+        if(str1 == str2)
             return 0;
         
         return 1;
@@ -119,14 +107,8 @@ size_t myhtml_strcasecmp(const char* str1, const char* str2)
 
 size_t myhtml_strncmp(const char* str1, const char* str2, size_t size)
 {
-    if(str1 == NULL) {
-        if(str2 == NULL)
-            return 0;
-        
-        return 1;
-    }
-    else if(str2 == NULL) {
-        if(str1 == NULL)
+    if(str1 == NULL || str2 == NULL) {
+        if(str1 == str2)
             return 0;
         
         return 1;
@@ -151,14 +133,8 @@ size_t myhtml_strncmp(const char* str1, const char* str2, size_t size)
 
 size_t myhtml_strcmp(const char* str1, const char* str2)
 {
-    if(str1 == NULL) {
-        if(str2 == NULL)
-            return 0;
-        
-        return 1;
-    }
-    else if(str2 == NULL) {
-        if(str1 == NULL)
+    if(str1 == NULL || str2 == NULL) {
+        if(str1 == str2)
             return 0;
         
         return 1;
@@ -184,14 +160,8 @@ size_t myhtml_strcmp(const char* str1, const char* str2)
 
 size_t myhtml_strcmp_ws(const char* str1, const char* str2)
 {
-    if(str1 == NULL) {
-        if(str2 == NULL)
-            return 0;
-        
-        return 1;
-    }
-    else if(str2 == NULL) {
-        if(str1 == NULL)
+    if(str1 == NULL || str2 == NULL) {
+        if(str1 == str2)
             return 0;
         
         return 1;
diff --git a/source/myhtml/utils/mcobject_async.c b/source/myhtml/utils/mcobject_async.c
index c62b4d8..21e36e8 100644
--- a/source/myhtml/utils/mcobject_async.c
+++ b/source/myhtml/utils/mcobject_async.c
@@ -354,13 +354,20 @@ void mcobject_async_node_delete(mcobject_async_t *mcobj_async, size_t node_idx)
     while (chunk)
     {
         if(mcobj_async->chunk_cache_length >= mcobj_async->chunk_cache_size) {
-            mcobj_async->chunk_cache_size <<= 1;
+            size_t new_size = mcobj_async->chunk_cache_size << 1;
             
             mcobject_async_chunk_t **tmp = (mcobject_async_chunk_t**)myhtml_realloc(mcobj_async->chunk_cache,
-                                                                               sizeof(mcobject_async_chunk_t*) * mcobj_async->chunk_cache_size);
+                                                                               sizeof(mcobject_async_chunk_t*) * new_size);
             
-            if(tmp)
+            if(tmp) {
+                mcobj_async->chunk_cache_size = new_size;
                 mcobj_async->chunk_cache = tmp;
+            }
+            else {
+                // TODO: add return status
+                mcsync_unlock(mcobj_async->mcsync);
+                return;
+            }
         }
         
         mcobj_async->chunk_cache[ mcobj_async->chunk_cache_length ] = chunk;
diff --git a/source/myhtml/utils/mctree.h b/source/myhtml/utils/mctree.h
index e3c2b42..bd3054f 100644
--- a/source/myhtml/utils/mctree.h
+++ b/source/myhtml/utils/mctree.h
@@ -45,8 +45,8 @@ extern "C" {
 
 #define mctree_node_add(mctree)                                     \
     mctree->nodes_length++;                                         \
-    if(mctree->nodes_length == mctree->nodes_size) {                \
-        mctree->nodes_size += 4096;                                 \
+    if(mctree->nodes_length >= mctree->nodes_size) {                \
+        mctree->nodes_size = mctree->nodes_length + 4096;           \
         mctree->nodes = (mctree_node_t*)myhtml_realloc(mctree->nodes,    \
             sizeof(mctree_node_t) * mctree->nodes_size);            \
     }                                                               \