habaki 0.5.0

data/ext/katana/src/selector.c

@@ -0,0 +1,659 @@
+/**
+ * Copyright (c) 2015 QFish <im@qfi.sh>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "selector.h"
+#include <string.h>
+#include <assert.h>
+#include <strings.h>
+
+#undef	assert
+#define assert(x)
+
+// Refs:
+// http://www.w3.org/TR/css3-selectors/
+//
+
+static KatanaPseudoType name_to_pseudo_type(const char* name, bool hasArguments);
+
+bool katana_selector_crosses_tree_scopes(const KatanaSelector* selector)
+{
+    // TODO: To be supported
+    return false;
+}
+
+// bool katana_is_attribute_selector(const KatanaSelector* selector)
+// {
+//     return selector->match == KatanaSelectorMatchAttributeExact
+//     || selector->match == KatanaSelectorMatchAttributeSet
+//     || selector->match == KatanaSelectorMatchAttributeList
+//     || selector->match == KatanaSelectorMatchAttributeHyphen
+//     || selector->match == KatanaSelectorMatchAttributeContain
+//     || selector->match == KatanaSelectorMatchAttributeBegin
+//     || selector->match == KatanaSelectorMatchAttributeEnd;
+// }
+
+KatanaPseudoType katana_parse_pseudo_type(const char* name, bool hasArguments)
+{
+    KatanaPseudoType pseudoType = name_to_pseudo_type(name, hasArguments);
+    if (pseudoType != KatanaPseudoUnknown)
+        return pseudoType;
+    
+    if (katana_string_has_prefix(name, "-webkit-"))
+        return KatanaPseudoWebKitCustomElement;
+    
+    return KatanaPseudoUnknown;
+}
+
+void katana_selector_extract_pseudo_type(KatanaSelector* selector)
+{
+    if (selector->pseudo == KatanaPseudoNotParsed)
+        selector->pseudo = KatanaPseudoUnknown;
+    
+    if (selector->match != KatanaSelectorMatchPseudoClass && selector->match != KatanaSelectorMatchPseudoElement && selector->match != KatanaSelectorMatchPagePseudoClass)
+        return;
+    bool hasArguments = (NULL != selector->data->argument) || (NULL != selector->data->selectors);    
+    selector->pseudo = katana_parse_pseudo_type(selector->data->value, hasArguments);
+    
+    bool element = false; // pseudo-element
+    bool compat = false; // single colon compatbility mode
+    bool isPagePseudoClass = false; // Page pseudo-class
+    
+    switch (selector->pseudo) {
+        case KatanaPseudoAfter:
+        case KatanaPseudoBefore:
+        case KatanaPseudoFirstLetter:
+        case KatanaPseudoFirstLine:
+            compat = true;
+        case KatanaPseudoBackdrop:
+        case KatanaPseudoCue:
+        case KatanaPseudoResizer:
+        case KatanaPseudoScrollbar:
+        case KatanaPseudoScrollbarCorner:
+        case KatanaPseudoScrollbarButton:
+        case KatanaPseudoScrollbarThumb:
+        case KatanaPseudoScrollbarTrack:
+        case KatanaPseudoScrollbarTrackPiece:
+        case KatanaPseudoSelection:
+        case KatanaPseudoWebKitCustomElement:
+        case KatanaPseudoContent:
+        case KatanaPseudoShadow:
+            element = true;
+            break;
+        case KatanaPseudoUnknown:
+        case KatanaPseudoEmpty:
+        case KatanaPseudoFirstChild:
+        case KatanaPseudoFirstOfType:
+        case KatanaPseudoLastChild:
+        case KatanaPseudoLastOfType:
+        case KatanaPseudoOnlyChild:
+        case KatanaPseudoOnlyOfType:
+        case KatanaPseudoNthChild:
+        case KatanaPseudoNthOfType:
+        case KatanaPseudoNthLastChild:
+        case KatanaPseudoNthLastOfType:
+        case KatanaPseudoLink:
+        case KatanaPseudoVisited:
+        case KatanaPseudoAny:
+        case KatanaPseudoAnyLink:
+        case KatanaPseudoAutofill:
+        case KatanaPseudoHover:
+        case KatanaPseudoDrag:
+        case KatanaPseudoFocus:
+        case KatanaPseudoActive:
+        case KatanaPseudoChecked:
+        case KatanaPseudoEnabled:
+        case KatanaPseudoFullPageMedia:
+        case KatanaPseudoDefault:
+        case KatanaPseudoDisabled:
+        case KatanaPseudoOptional:
+        case KatanaPseudoRequired:
+        case KatanaPseudoReadOnly:
+        case KatanaPseudoReadWrite:
+        case KatanaPseudoScope:
+        case KatanaPseudoValid:
+        case KatanaPseudoInvalid:
+        case KatanaPseudoIndeterminate:
+        case KatanaPseudoTarget:
+        case KatanaPseudoLang:
+        case KatanaPseudoNot:
+        case KatanaPseudoRoot:
+        case KatanaPseudoWindowInactive:
+        case KatanaPseudoCornerPresent:
+        case KatanaPseudoDecrement:
+        case KatanaPseudoIncrement:
+        case KatanaPseudoHorizontal:
+        case KatanaPseudoVertical:
+        case KatanaPseudoStart:
+        case KatanaPseudoEnd:
+        case KatanaPseudoDoubleButton:
+        case KatanaPseudoSingleButton:
+        case KatanaPseudoNoButton:
+        case KatanaPseudoNotParsed:
+        case KatanaPseudoFullScreen:
+        case KatanaPseudoFullScreenDocument:
+        case KatanaPseudoFullScreenAncestor:
+        case KatanaPseudoInRange:
+        case KatanaPseudoOutOfRange:
+        case KatanaPseudoFutureCue:
+        case KatanaPseudoPastCue:
+        case KatanaPseudoHost:
+        case KatanaPseudoHostContext:
+        case KatanaPseudoUnresolved:
+        case KatanaPseudoSpatialNavigationFocus:
+        case KatanaPseudoListBox:
+            break;
+        case KatanaPseudoFirstPage:
+        case KatanaPseudoLeftPage:
+        case KatanaPseudoRightPage:
+            isPagePseudoClass = true;
+            break;
+    }
+    
+    bool matchPagePseudoClass = (selector->match == KatanaSelectorMatchPagePseudoClass);
+    if (matchPagePseudoClass != isPagePseudoClass)
+        selector->pseudo = KatanaPseudoUnknown;
+    else if (selector->match == KatanaSelectorMatchPseudoClass && element) {
+        if (!compat)
+            selector->pseudo = KatanaPseudoUnknown;
+        else
+            selector->match = KatanaSelectorMatchPseudoElement;
+    } else if (selector->match == KatanaSelectorMatchPseudoElement && !element)
+        selector->pseudo = KatanaPseudoUnknown;
+}
+
+bool katana_selector_matches_pseudo_element(KatanaSelector* selector)
+{
+    if (selector->pseudo == KatanaPseudoUnknown)
+        katana_selector_extract_pseudo_type(selector);
+    return selector->match == KatanaSelectorMatchPseudoElement;
+}
+
+bool katana_selector_is_custom_pseudo_element(KatanaSelector* selector)
+{
+    return selector->match == KatanaSelectorMatchPseudoElement && selector->pseudo == KatanaPseudoWebKitCustomElement;
+}
+
+bool katana_selector_is_direct_adjacent(KatanaSelector* selector)
+{
+    return selector->relation == KatanaSelectorRelationDirectAdjacent || selector->relation == KatanaSelectorRelationIndirectAdjacent;
+}
+
+bool katana_selector_is_adjacent(KatanaSelector* selector)
+{
+    return selector->relation == KatanaSelectorRelationDirectAdjacent;
+}
+
+bool katana_selector_is_shadow(KatanaSelector* selector)
+{
+    return selector->relation == KatanaSelectorRelationShadowPseudo || selector->relation == KatanaSelectorRelationShadowDeep;
+}
+
+bool katana_selector_is_sibling(KatanaSelector* selector)
+{
+    katana_selector_extract_pseudo_type(selector);
+
+    KatanaPseudoType type = selector->pseudo;
+    return selector->relation == KatanaSelectorRelationDirectAdjacent
+        || selector->relation == KatanaSelectorRelationIndirectAdjacent
+        || type == KatanaPseudoEmpty
+        || type == KatanaPseudoFirstChild
+        || type == KatanaPseudoFirstOfType
+        || type == KatanaPseudoLastChild
+        || type == KatanaPseudoLastOfType
+        || type == KatanaPseudoOnlyChild
+        || type == KatanaPseudoOnlyOfType
+        || type == KatanaPseudoNthChild
+        || type == KatanaPseudoNthOfType
+        || type == KatanaPseudoNthLastChild
+        || type == KatanaPseudoNthLastOfType;
+}
+
+bool katana_selector_is_attribute(const KatanaSelector* selector)
+{
+    return selector->match >= KatanaSelectorMatchFirstAttribute;
+}
+
+bool katana_selector_is_content_pseudo_element(KatanaSelector* selector)
+{
+    katana_selector_extract_pseudo_type(selector);
+    return selector->match == KatanaSelectorMatchPseudoElement && selector->pseudo == KatanaPseudoContent;
+}
+
+bool katana_selector_is_shadow_pseudo_element(KatanaSelector* selector)
+{
+    return selector->match == KatanaSelectorMatchPseudoElement
+            && selector->pseudo == KatanaPseudoShadow;
+}
+
+bool katana_selector_is_host_pseudo_class(KatanaSelector* selector)
+{
+    return selector->match == KatanaSelectorMatchPseudoClass && (selector->pseudo == KatanaPseudoHost || selector->pseudo == KatanaPseudoHostContext);
+}
+
+bool katana_selector_is_tree_boundary_crossing(KatanaSelector* selector)
+{
+    katana_selector_extract_pseudo_type(selector);
+    return selector->match == KatanaSelectorMatchPseudoClass && (selector->pseudo == KatanaPseudoHost || selector->pseudo == KatanaPseudoHostContext);
+}
+
+bool katana_selector_is_insertion_point_crossing(KatanaSelector* selector)
+{
+    katana_selector_extract_pseudo_type(selector);
+    return (selector->match == KatanaSelectorMatchPseudoClass && selector->pseudo == KatanaPseudoHostContext)
+        || (selector->match == KatanaSelectorMatchPseudoElement && selector->pseudo == KatanaPseudoContent);
+}
+
+KatanaParserString* katana_build_relation_selector_string(KatanaParser* parser, const char* relation, KatanaParserString* string, KatanaParserString* next, KatanaSelector* tagHistory)
+{
+    if ( NULL != relation ) {
+        katana_string_prepend_characters(parser, relation, string);
+    }
+    
+    if ( NULL != next ) {
+        katana_string_append_string(parser, next, string);
+    }
+    
+    KatanaParserString * result = katana_selector_to_string(parser, tagHistory, (KatanaParserString*)string);
+    katana_parser_deallocate(parser, (void*) string->data);
+    katana_parser_deallocate(parser, (void*) string);
+    return result;
+}
+
+KatanaParserString* katana_selector_to_string(KatanaParser* parser, KatanaSelector* selector, KatanaParserString* next)
+{
+    KatanaParserString* string = katana_parser_allocate(parser, sizeof(KatanaParserString));
+    katana_string_init(parser, string);
+    
+    bool tag_is_implicit = true;
+    
+    if (selector->match == KatanaSelectorMatchTag && tag_is_implicit)
+    {
+        if ( NULL == selector->tag->prefix )
+            katana_string_append_characters(parser, selector->tag->local, string);
+        else {
+            katana_string_append_characters(parser, selector->tag->prefix, string);
+            katana_string_append_characters(parser, "|", string);
+            katana_string_append_characters(parser, selector->tag->local, string);
+        }
+    }
+
+    const KatanaSelector* cs = selector;
+
+    while (true) {
+        if (cs->match == KatanaSelectorMatchId) {
+            katana_string_append_characters(parser, "#", string);
+            katana_string_append_characters(parser, cs->data->value, string);
+        } else if (cs->match == KatanaSelectorMatchClass) {
+            katana_string_append_characters(parser, ".", string);
+            katana_string_append_characters(parser, cs->data->value, string);
+        } else if (cs->match == KatanaSelectorMatchPseudoClass || cs->match == KatanaSelectorMatchPagePseudoClass) {
+            katana_string_append_characters(parser, ":", string);
+            katana_string_append_characters(parser, cs->data->value, string);
+            
+            switch (cs->pseudo) {
+                case KatanaPseudoAny:
+                case KatanaPseudoNot:
+                case KatanaPseudoHost:
+                case KatanaPseudoHostContext: {
+                    if ( cs->data->selectors ) {
+                        KatanaArray* sels = cs->data->selectors;
+                        for (size_t i=0; i<sels->length; i++) {
+                            KatanaParserString* str = katana_selector_to_string(parser, sels->data[i], NULL);
+                            katana_string_append_string(parser, str, string);
+                            katana_parser_deallocate(parser, (void*) str->data);
+                            katana_parser_deallocate(parser, (void*) str);
+                            if ( i != sels->length -1 ) {
+                                katana_string_append_characters(parser, ", ", string);
+                            }
+                        }
+                        katana_string_append_characters(parser, ")", string);
+                    }
+                }
+                    break;
+                case KatanaPseudoLang:
+                case KatanaPseudoNthChild:
+                case KatanaPseudoNthLastChild:
+                case KatanaPseudoNthOfType:
+                case KatanaPseudoNthLastOfType: {
+                    katana_string_append_characters(parser, cs->data->argument, string);
+                    katana_string_append_characters(parser, ")", string);
+                }
+                    break;
+                default:
+                    break;
+            }
+        } else if (cs->match == KatanaSelectorMatchPseudoElement) {
+            katana_string_append_characters(parser, "::", string);
+            katana_string_append_characters(parser, cs->data->value, string);
+        } else if (katana_selector_is_attribute(cs)) {
+            katana_string_append_characters(parser, "[", string);
+            if (NULL != cs->data->attribute->prefix) {
+                katana_string_append_characters(parser, cs->data->attribute->prefix, string);
+                katana_string_append_characters(parser, "|", string);
+            }
+            katana_string_append_characters(parser, cs->data->attribute->local, string);
+            switch (cs->match) {
+                case KatanaSelectorMatchAttributeExact:
+                    katana_string_append_characters(parser, "=", string);
+                    break;
+                case KatanaSelectorMatchAttributeSet:
+                    katana_string_append_characters(parser, "]", string);
+                    break;
+                case KatanaSelectorMatchAttributeList:
+                    katana_string_append_characters(parser, "~=", string);
+                    break;
+                case KatanaSelectorMatchAttributeHyphen:
+                    katana_string_append_characters(parser, "|=", string);
+                    break;
+                case KatanaSelectorMatchAttributeBegin:
+                    katana_string_append_characters(parser, "^=", string);
+                    break;
+                case KatanaSelectorMatchAttributeEnd:
+                    katana_string_append_characters(parser, "$=", string);
+                    break;
+                case KatanaSelectorMatchAttributeContain:
+                    katana_string_append_characters(parser, "*=", string);
+                    break;
+                default:
+                    break;
+            }
+            if (cs->match != KatanaSelectorMatchAttributeSet) {
+                katana_string_append_characters(parser, "\"", string);
+                katana_string_append_characters(parser, cs->data->value, string);
+                katana_string_append_characters(parser, "\"", string);
+                if (cs->data->bits.attributeMatchType == KatanaAttributeMatchTypeCaseInsensitive)
+                    katana_string_append_characters(parser, " i", string);
+                katana_string_append_characters(parser, "]", string);
+            }
+        }
+        if (cs->relation != KatanaSelectorRelationSubSelector || !cs->tagHistory)
+            break;
+        cs = cs->tagHistory;
+    }
+
+    KatanaSelector* tagHistory = cs->tagHistory;
+
+    if ( NULL != tagHistory ) {
+        switch (cs->relation) {
+            case KatanaSelectorRelationDescendant:
+            {
+                return katana_build_relation_selector_string(parser, " ", string, next, tagHistory);
+            }
+            case KatanaSelectorRelationChild:
+            {
+                return katana_build_relation_selector_string(parser, " > ", string, next, tagHistory);
+            }
+            case KatanaSelectorRelationShadowDeep:
+            {
+                return katana_build_relation_selector_string(parser, " /deep/ ", string, next, tagHistory);
+            }
+            case KatanaSelectorRelationDirectAdjacent:
+            {
+                return katana_build_relation_selector_string(parser, " + ", string, next, tagHistory);
+            }
+            case KatanaSelectorRelationIndirectAdjacent:
+            {
+                return katana_build_relation_selector_string(parser, " ~ ", string, next, tagHistory);
+            }
+            case KatanaSelectorRelationSubSelector:
+            {
+                return NULL;
+            }
+            case KatanaSelectorRelationShadowPseudo:
+            {
+                return katana_build_relation_selector_string(parser, NULL, string, next, tagHistory);
+            }
+        }
+    }
+    
+    if ( NULL != next ) {
+        katana_string_append_string(parser, (KatanaParserString*)next, string);
+    }
+    
+    return (KatanaParserString*)string;
+}
+
+unsigned calc_specificity_for_one_selector(const KatanaSelector* selector)
+{
+    switch ( selector->match ) {
+        case KatanaSelectorMatchId:
+            return 0x10000;
+            
+        case KatanaSelectorMatchPseudoClass:
+        case KatanaSelectorMatchAttributeExact:
+        case KatanaSelectorMatchClass:
+        case KatanaSelectorMatchAttributeSet:
+        case KatanaSelectorMatchAttributeList:
+        case KatanaSelectorMatchAttributeHyphen:
+        case KatanaSelectorMatchPseudoElement:
+        case KatanaSelectorMatchAttributeContain:
+        case KatanaSelectorMatchAttributeBegin:
+        case KatanaSelectorMatchAttributeEnd:
+            return 0x100;
+            
+        case KatanaSelectorMatchTag:
+            return !strcasecmp(selector->tag->local, "*") ? 0 : 1;
+        case KatanaSelectorMatchUnknown:
+        case KatanaSelectorMatchPagePseudoClass:
+            return 0;
+    }
+    
+    return 0;
+}
+
+unsigned katana_calc_specificity_for_selector(KatanaSelector* selector)
+{
+    if ( NULL == selector ) {
+        return 0;
+    }
+    
+    static const unsigned idMask = 0xff0000;
+    static const unsigned classMask = 0xff00;
+    static const unsigned elementMask = 0xff;
+    
+    unsigned total = 0;
+    unsigned temp = 0;
+    
+    for (const KatanaSelector * next = selector; next; next = next->tagHistory)
+    {
+        temp = total + calc_specificity_for_one_selector(next);
+
+        if ((temp & idMask) < (total & idMask))
+            total |= idMask;
+        else if ((temp & classMask) < (total & classMask))
+            total |= classMask;
+        else if ((temp & elementMask) < (total & elementMask))
+            total |= elementMask;
+        else
+            total = temp;
+    }
+        
+    return total;
+}
+
+// Could be made smaller and faster by replacing pointer with an
+// offset into a string buffer and making the bit fields smaller but
+// that could not be maintained by hand.
+typedef struct {
+    const char* string;
+    unsigned type:8;
+} KatanaNameToPseudoStruct;
+
+// These tables should be kept sorted.
+const static KatanaNameToPseudoStruct kPseudoTypeWithoutArgumentsMap[] = {
+    {"-internal-list-box",            KatanaPseudoListBox},
+    {"-internal-media-controls-cast-button", KatanaPseudoWebKitCustomElement},
+    {"-internal-media-controls-overlay-cast-button", KatanaPseudoWebKitCustomElement},
+    {"-internal-spatial-navigation-focus", KatanaPseudoSpatialNavigationFocus},
+    {"-webkit-any-link",              KatanaPseudoAnyLink},
+    {"-webkit-autofill",              KatanaPseudoAutofill},
+    {"-webkit-drag",                  KatanaPseudoDrag},
+    {"-webkit-full-page-media",       KatanaPseudoFullPageMedia},
+    {"-webkit-full-screen",           KatanaPseudoFullScreen},
+    {"-webkit-full-screen-ancestor",  KatanaPseudoFullScreenAncestor},
+    {"-webkit-full-screen-document",  KatanaPseudoFullScreenDocument},
+    {"-webkit-resizer",               KatanaPseudoResizer},
+    {"-webkit-scrollbar",             KatanaPseudoScrollbar},
+    {"-webkit-scrollbar-button",      KatanaPseudoScrollbarButton},
+    {"-webkit-scrollbar-corner",      KatanaPseudoScrollbarCorner},
+    {"-webkit-scrollbar-thumb",       KatanaPseudoScrollbarThumb},
+    {"-webkit-scrollbar-track",       KatanaPseudoScrollbarTrack},
+    {"-webkit-scrollbar-track-piece", KatanaPseudoScrollbarTrackPiece},
+    {"active",                        KatanaPseudoActive},
+    {"after",                         KatanaPseudoAfter},
+    {"backdrop",                      KatanaPseudoBackdrop},
+    {"before",                        KatanaPseudoBefore},
+    {"checked",                       KatanaPseudoChecked},
+    {"content",                       KatanaPseudoContent},
+    {"corner-present",                KatanaPseudoCornerPresent},
+    {"cue",                           KatanaPseudoWebKitCustomElement},
+    {"decrement",                     KatanaPseudoDecrement},
+    {"default",                       KatanaPseudoDefault},
+    {"disabled",                      KatanaPseudoDisabled},
+    {"double-button",                 KatanaPseudoDoubleButton},
+    {"empty",                         KatanaPseudoEmpty},
+    {"enabled",                       KatanaPseudoEnabled},
+    {"end",                           KatanaPseudoEnd},
+    {"first",                         KatanaPseudoFirstPage},
+    {"first-child",                   KatanaPseudoFirstChild},
+    {"first-letter",                  KatanaPseudoFirstLetter},
+    {"first-line",                    KatanaPseudoFirstLine},
+    {"first-of-type",                 KatanaPseudoFirstOfType},
+    {"focus",                         KatanaPseudoFocus},
+    {"future",                        KatanaPseudoFutureCue},
+    {"horizontal",                    KatanaPseudoHorizontal},
+    {"host",                          KatanaPseudoHost},
+    {"hover",                         KatanaPseudoHover},
+    {"in-range",                      KatanaPseudoInRange},
+    {"increment",                     KatanaPseudoIncrement},
+    {"indeterminate",                 KatanaPseudoIndeterminate},
+    {"invalid",                       KatanaPseudoInvalid},
+    {"last-child",                    KatanaPseudoLastChild},
+    {"last-of-type",                  KatanaPseudoLastOfType},
+    {"left",                          KatanaPseudoLeftPage},
+    {"link",                          KatanaPseudoLink},
+    {"no-button",                     KatanaPseudoNoButton},
+    {"only-child",                    KatanaPseudoOnlyChild},
+    {"only-of-type",                  KatanaPseudoOnlyOfType},
+    {"optional",                      KatanaPseudoOptional},
+    {"out-of-range",                  KatanaPseudoOutOfRange},
+    {"past",                          KatanaPseudoPastCue},
+    {"read-only",                     KatanaPseudoReadOnly},
+    {"read-write",                    KatanaPseudoReadWrite},
+    {"required",                      KatanaPseudoRequired},
+    {"right",                         KatanaPseudoRightPage},
+    {"root",                          KatanaPseudoRoot},
+    {"scope",                         KatanaPseudoScope},
+    {"selection",                     KatanaPseudoSelection},
+    {"shadow",                        KatanaPseudoShadow},
+    {"single-button",                 KatanaPseudoSingleButton},
+    {"start",                         KatanaPseudoStart},
+    {"target",                        KatanaPseudoTarget},
+    {"unresolved",                    KatanaPseudoUnresolved},
+    {"valid",                         KatanaPseudoValid},
+    {"vertical",                      KatanaPseudoVertical},
+    {"visited",                       KatanaPseudoVisited},
+    {"window-inactive",               KatanaPseudoWindowInactive},
+};
+
+const static KatanaNameToPseudoStruct kPseudoTypeWithArgumentsMap[] = {
+    {"-webkit-any(",      KatanaPseudoAny},
+    {"cue(",              KatanaPseudoCue},
+    {"host(",             KatanaPseudoHost},
+    {"host-context(",     KatanaPseudoHostContext},
+    {"lang(",             KatanaPseudoLang},
+    {"not(",              KatanaPseudoNot},
+    {"nth-child(",        KatanaPseudoNthChild},
+    {"nth-last-child(",   KatanaPseudoNthLastChild},
+    {"nth-last-of-type(", KatanaPseudoNthLastOfType},
+    {"nth-of-type(",      KatanaPseudoNthOfType},
+};
+
+static const KatanaNameToPseudoStruct* lower_bound(const KatanaNameToPseudoStruct *map,
+                                                   size_t count, const char* key);
+
+static KatanaPseudoType name_to_pseudo_type(const char* name, bool hasArguments)
+{
+    if (NULL == name)
+        return KatanaPseudoUnknown;
+    
+    const KatanaNameToPseudoStruct* pseudoTypeMap;
+    size_t count;
+    
+    if (hasArguments) {
+        pseudoTypeMap = kPseudoTypeWithArgumentsMap;
+        count = sizeof(kPseudoTypeWithArgumentsMap) / sizeof(KatanaNameToPseudoStruct);
+    } else {
+        pseudoTypeMap = kPseudoTypeWithoutArgumentsMap;
+        count = sizeof(kPseudoTypeWithoutArgumentsMap) / sizeof(KatanaNameToPseudoStruct);
+    }
+    
+    const KatanaNameToPseudoStruct* match = lower_bound(pseudoTypeMap, count, name);
+    if ( match == (pseudoTypeMap + count)
+         || 0 != strcasecmp(match->string, name) )
+        return KatanaPseudoUnknown;
+    
+    return match->type;
+}
+
+static const KatanaNameToPseudoStruct* lower_bound(const KatanaNameToPseudoStruct *array,
+                                                   size_t size, const char* key) {
+    const KatanaNameToPseudoStruct* it;
+    const KatanaNameToPseudoStruct* first = array;
+    size_t count = size, step;
+    while (count > 0) {
+        it = first;
+        step = count / 2;
+        it += step;
+        if (strncmp(it->string, key, strlen(key)) < 0) {
+            first = ++it;
+            count -= step + 1;
+        } else count = step;
+    }
+    return first;
+}
+
+#if KATANA_PARSER_DEBUG
+
+void test_lower_bound()
+{
+    const KatanaNameToPseudoStruct* pseudoTypeMap;
+    size_t count;
+    
+    pseudoTypeMap = kPseudoTypeWithArgumentsMap;
+    count = sizeof(kPseudoTypeWithArgumentsMap) / sizeof(KatanaNameToPseudoStruct);
+    
+    for ( size_t i = 0; i < count; i++ ) {
+        const KatanaNameToPseudoStruct* res = lower_bound(pseudoTypeMap, count, pseudoTypeMap[i].string);
+        assert(pseudoTypeMap[i].type == res->type);
+    }
+    
+    pseudoTypeMap = kPseudoTypeWithoutArgumentsMap;
+    count = sizeof(kPseudoTypeWithoutArgumentsMap) / sizeof(KatanaNameToPseudoStruct);
+    
+    for ( size_t i = 0; i < count; i++ ) {
+        const KatanaNameToPseudoStruct* res = lower_bound(pseudoTypeMap, count, pseudoTypeMap[i].string);
+        assert(pseudoTypeMap[i].type == res->type);
+    }
+}
+
+#endif // #if KATANA_PARSER_DEBUG