Changeset 92249 in webkit


Ignore:
Timestamp:
Aug 2, 2011 5:04:06 PM (13 years ago)
Author:
jpfau@apple.com
Message:

Add namespace prefix support in XML tokenizer
https://bugs.webkit.org/show_bug.cgi?id=65578

Reviewed by Adam Barth.

This also changes markup debug printing to print to stderr instead of stdout

  • xml/parser/MarkupTokenBase.h:

(WebCore::MarkupTokenBase::printString):

  • xml/parser/XMLToken.h:

(WebCore::XMLToken::XMLDeclarationData::XMLDeclarationData):
(WebCore::XMLToken::clear):
(WebCore::XMLToken::appendToName):
(WebCore::XMLToken::name):
(WebCore::XMLToken::target):
(WebCore::XMLToken::data):
(WebCore::XMLToken::prefix):
(WebCore::XMLToken::xmlDeclarationData):
(WebCore::XMLToken::endPrefix):
(WebCore::XMLToken::hasPrefix):
(WebCore::XMLToken::endAttributePrefix):
(WebCore::XMLToken::attributeHasPrefix):
(WebCore::XMLToken::printAttrs):
(WebCore::XMLToken::print):

  • xml/parser/XMLTokenizer.cpp:

(WebCore::XMLTokenizer::nextToken):

Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r92248 r92249  
     12011-08-02  Jeffrey Pfau  <jpfau@apple.com>
     2
     3        Add namespace prefix support in XML tokenizer
     4        https://bugs.webkit.org/show_bug.cgi?id=65578
     5
     6        Reviewed by Adam Barth.
     7
     8        This also changes markup debug printing to print to stderr instead of stdout
     9
     10        * xml/parser/MarkupTokenBase.h:
     11        (WebCore::MarkupTokenBase::printString):
     12        * xml/parser/XMLToken.h:
     13        (WebCore::XMLToken::XMLDeclarationData::XMLDeclarationData):
     14        (WebCore::XMLToken::clear):
     15        (WebCore::XMLToken::appendToName):
     16        (WebCore::XMLToken::name):
     17        (WebCore::XMLToken::target):
     18        (WebCore::XMLToken::data):
     19        (WebCore::XMLToken::prefix):
     20        (WebCore::XMLToken::xmlDeclarationData):
     21        (WebCore::XMLToken::endPrefix):
     22        (WebCore::XMLToken::hasPrefix):
     23        (WebCore::XMLToken::endAttributePrefix):
     24        (WebCore::XMLToken::attributeHasPrefix):
     25        (WebCore::XMLToken::printAttrs):
     26        (WebCore::XMLToken::print):
     27        * xml/parser/XMLTokenizer.cpp:
     28        (WebCore::XMLTokenizer::nextToken):
     29
    1302011-08-02  Zhenyao Mo  <zmo@google.com>
    231
  • trunk/Source/WebCore/xml/parser/MarkupTokenBase.h

    r91643 r92249  
    5252    WTF::Vector<UChar> m_systemIdentifier;
    5353};
    54    
    55 template<typename TypeSet, typename DoctypeData = DoctypeDataBase>
     54
     55class AttributeBase {
     56public:
     57    class Range {
     58    public:
     59        int m_start;
     60        int m_end;
     61    };
     62
     63    Range m_nameRange;
     64    Range m_valueRange;
     65    WTF::Vector<UChar, 32> m_name;
     66    WTF::Vector<UChar, 32> m_value;
     67};
     68
     69template<typename TypeSet, typename DoctypeData = DoctypeDataBase, typename AttributeType = AttributeBase>
    5670class MarkupTokenBase {
    5771    WTF_MAKE_NONCOPYABLE(MarkupTokenBase);
     
    5973public:
    6074    typedef TypeSet Type;
    61 
    62     class Range {
    63     public:
    64         int m_start;
    65         int m_end;
    66     };
    67 
    68     class Attribute {
    69     public:
    70         Range m_nameRange;
    71         Range m_valueRange;
    72         WTF::Vector<UChar, 32> m_name;
    73         WTF::Vector<UChar, 32> m_value;
    74     };
     75    typedef AttributeType Attribute;
    7576
    7677    typedef WTF::Vector<Attribute, 10> AttributeList;
     
    335336        DataVector::const_iterator iter = string.begin();
    336337        for (; iter != string.end(); ++iter)
    337             printf("%lc", wchar_t(*iter));
    338     }
    339    
    340     void printAttrs() const
    341     {
    342         typename AttributeList::const_iterator iter = m_attributes.begin();
    343         for (; iter != m_attributes.end(); ++iter) {
    344             printf(" ");
    345             printString(iter->m_name);
    346             printf("=\"");
    347             printString(iter->m_value);
    348             printf("\"");
    349         }
     338            fprintf(stderr, "%lc", wchar_t(*iter));
    350339    }
    351340#endif // NDEBUG
     
    368357
    369358    typename Type::Type m_type;
    370     Range m_range; // Always starts at zero.
     359    typename Attribute::Range m_range; // Always starts at zero.
    371360    int m_baseOffset;
    372361    DataVector m_data;
  • trunk/Source/WebCore/xml/parser/XMLToken.h

    r91811 r92249  
    2828#define XMLToken_h
    2929
     30#include "Element.h"
    3031#include "MarkupTokenBase.h"
    3132
     
    3940        XMLDeclaration,
    4041        DOCTYPE,
    41         AttributeListDeclaration,
    42         ElementDeclaration,
    43         EntityDeclaration,
    4442        CDATA,
    4543        StartTag,
     
    5250};
    5351
    54 class XMLToken : public MarkupTokenBase<XMLTokenTypes> {
     52class PrefixedAttribute : public AttributeBase {
    5553public:
    56     virtual void clear()
    57     {
    58         MarkupTokenBase<XMLTokenTypes>::clear();
    59         m_target.clear();
    60     }
    61    
    62     void appendToName(UChar character)
    63     {
    64         ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity);
    65         MarkupTokenBase<XMLTokenTypes>::appendToName(character);
    66     }
    67    
    68     const DataVector& name() const
    69     {
    70         ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity);
    71         return MarkupTokenBase<XMLTokenTypes>::name();
    72     }
    73 
    74     void beginDOCTYPE()
    75     {
    76         ASSERT(m_type == XMLTokenTypes::Uninitialized);
    77         m_type = XMLTokenTypes::DOCTYPE;
    78         m_doctypeData = adoptPtr(new DoctypeData());
    79     }
    80 
    81     void beginDOCTYPE(UChar character)
    82     {
    83         ASSERT(character);
    84         beginDOCTYPE();
    85         m_data.append(character);
    86     }
    87 
    88     void beginXMLDeclaration()
    89     {
    90         ASSERT(m_type == XMLTokenTypes::Uninitialized);
    91         m_type = XMLTokenTypes::XMLDeclaration;
    92         m_xmlDeclarationData = adoptPtr(new XMLDeclarationData());
    93     }
    94    
    95     void appendToXMLVersion(UChar character)
    96     {
    97         ASSERT(character);
    98         ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
    99         ASSERT(m_xmlDeclarationData);
    100         m_xmlDeclarationData->m_version.append(character);
    101     }
    102 
    103     void beginXMLEncoding(UChar character)
    104     {
    105         ASSERT(character);
    106         ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
    107         ASSERT(m_xmlDeclarationData);
    108         m_xmlDeclarationData->m_hasEncoding = true;
    109         m_xmlDeclarationData->m_encoding.append(character);
    110     }
    111 
    112     void appendToXMLEncoding(UChar character)
    113     {
    114         ASSERT(character);
    115         ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
    116         ASSERT(m_xmlDeclarationData);
    117         ASSERT(m_xmlDeclarationData->m_hasEncoding);
    118         m_xmlDeclarationData->m_encoding.append(character);
    119     }
    120 
    121     void setXMLStandalone(bool standalone)
    122     {
    123         ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
    124         ASSERT(m_xmlDeclarationData);
    125         m_xmlDeclarationData->m_hasStandalone = true;
    126         m_xmlDeclarationData->m_standalone = standalone;
    127     }
    128 
    129     void beginProcessingInstruction()
    130     {
    131         ASSERT(m_type == XMLTokenTypes::Uninitialized);
    132         m_type = XMLTokenTypes::ProcessingInstruction;
    133     }
    134 
    135     void beginProcessingInstruction(UChar character)
    136     {
    137         ASSERT(character);
    138         beginProcessingInstruction();
    139         m_target.append(character);
    140     }
    141 
    142     void appendToProcessingInstructionTarget(UChar character)
    143     {
    144         ASSERT(m_type == XMLTokenTypes::ProcessingInstruction);
    145         ASSERT(character);
    146         m_target.append(character);
    147     }
    148 
    149     void appendToProcessingInstructionData(UChar character)
    150     {
    151         ASSERT(m_type == XMLTokenTypes::ProcessingInstruction);
    152         ASSERT(character);
    153         m_data.append(character);
    154     }
    155 
    156     void beginCDATA()
    157     {
    158         ASSERT(m_type == XMLTokenTypes::Uninitialized);
    159         m_type = XMLTokenTypes::CDATA;
    160     }
    161 
    162     void appendToCDATA(UChar character)
    163     {
    164         ASSERT(m_type == XMLTokenTypes::CDATA);
    165         ASSERT(character);
    166         m_data.append(character);
    167     }
    168 
    169     void beginEntity()
    170     {
    171         ASSERT(m_type == XMLTokenTypes::Uninitialized);
    172         m_type = XMLTokenTypes::Entity;
    173     }
    174 
    175     void beginEntity(UChar character)
    176     {
    177         ASSERT(character);
    178         beginEntity();
    179         m_data.append(character);
    180     }
    181 
    182 #ifndef NDEBUG
    183     void print() const
    184     {
    185         switch (m_type) {
    186         case XMLTokenTypes::Uninitialized:
    187             printf("UNITIALIZED");
    188             break;
    189 
    190         case XMLTokenTypes::ProcessingInstruction:
    191             printf("ProcessingInstruction: ");
    192             printf("<?");
    193             printString(m_target);
    194             printf(" ");
    195             printString(m_data);
    196             printf("?>");
    197             break;
    198 
    199         case XMLTokenTypes::XMLDeclaration:
    200             printf("XML Declaration: ");
    201             printf("<?xml version=\"");
    202             ASSERT(m_xmlDeclarationData);
    203             printString(m_xmlDeclarationData->m_version);
    204             printf("\"");
    205             if (m_xmlDeclarationData->m_hasEncoding) {
    206                 printf(" encoding=\"");
    207                 printString(m_xmlDeclarationData->m_encoding);
    208                 printf("\"");
    209             }
    210             if (m_xmlDeclarationData->m_hasStandalone)
    211                 printf(" standalone=\"%s\"", m_xmlDeclarationData->m_standalone ? "yes" : "no");
    212             printf("?>");
    213             break;
    214 
    215         case XMLTokenTypes::DOCTYPE:
    216             printf("DOCTYPE: ");
    217             ASSERT(m_doctypeData);
    218             printf("<!DOCTYPE ");
    219             printString(m_data);
    220             if (m_doctypeData->m_hasPublicIdentifier) {
    221                 printf(" PUBLIC \"");
    222                 printString(m_doctypeData->m_publicIdentifier);
    223                 printf("\"");
    224                 if (m_doctypeData->m_hasSystemIdentifier) {
    225                     printf(" \"");
    226                     printString(m_doctypeData->m_systemIdentifier);
    227                     printf("\"");
    228                 }
    229             } else if (m_doctypeData->m_hasSystemIdentifier) {
    230                 printf(" SYSTEM \"");
    231                 printString(m_doctypeData->m_systemIdentifier);
    232                 printf("\"");
    233             }
    234             printf(">");
    235             break;
    236 
    237         case XMLTokenTypes::AttributeListDeclaration:
    238             printf("Attribute List: ");
    239             printf("<!ATTLIST>");
    240             break;
    241 
    242         case XMLTokenTypes::ElementDeclaration:
    243             printf("Element Declaration: ");
    244             printf("<!ELEMENT>");
    245             break;
    246 
    247         case XMLTokenTypes::EntityDeclaration:
    248             printf("Entity Declaration: ");
    249             printf("<!ENTITY>");
    250             break;
    251 
    252         case XMLTokenTypes::CDATA:
    253             printf("CDATA: ");
    254             printf("<![CDATA[");
    255             printString(m_data);
    256             printf("]]>");
    257             break;
    258 
    259         case XMLTokenTypes::StartTag:
    260             printf("Start Tag: ");
    261             printf("<");
    262             printString(m_data);
    263             printAttrs();
    264             if (selfClosing())
    265                 printf("/");
    266             printf(">");
    267             break;
    268 
    269         case XMLTokenTypes::EndTag:
    270             printf("End Tag: ");
    271             printf("</");
    272             printString(m_data);
    273             printf(">");
    274             break;
    275 
    276         case XMLTokenTypes::Comment:
    277             printf("Comment: ");
    278             printf("<!--");
    279             printString(m_data);
    280             printf("-->");
    281             break;
    282 
    283         case XMLTokenTypes::Character:
    284             printf("Characters: ");
    285             printString(m_data);
    286             break;
    287 
    288         case XMLTokenTypes::Entity:
    289             printf("Entity: ");
    290             printf("&");
    291             printString(m_data);
    292             printf(";");
    293             break;
    294 
    295         case XMLTokenTypes::EndOfFile:
    296             printf("EOF");
    297             break;
    298         }
    299 
    300         printf("\n");
    301     }
    302 #endif // NDEBUG
    303 
    304 private:
    305     typedef DoctypeDataBase DoctypeData;
    306 
     54    Range m_prefixRange;
     55    WTF::Vector<UChar, 32> m_prefix;
     56};
     57
     58class XMLToken : public MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute> {
     59public:
    30760    class XMLDeclarationData {
    30861        WTF_MAKE_NONCOPYABLE(XMLDeclarationData);
     
    31467        {
    31568        }
    316        
     69
    31770        bool m_hasStandalone;
    31871        bool m_hasEncoding;
     
    32275    };
    32376
    324     // "target" for ProcessingInstruction
     77    virtual void clear()
     78    {
     79        MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute>::clear();
     80        m_target.clear();
     81    }
     82
     83    void appendToName(UChar character)
     84    {
     85        ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity);
     86        MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute>::appendToName(character);
     87    }
     88
     89    const DataVector& name() const
     90    {
     91        ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag || m_type == XMLTokenTypes::DOCTYPE || m_type == XMLTokenTypes::Entity);
     92        return MarkupTokenBase<XMLTokenTypes, DoctypeDataBase, PrefixedAttribute>::name();
     93    }
     94
     95    const DataVector& target() const
     96    {
     97        ASSERT(m_type == XMLTokenTypes::ProcessingInstruction);
     98        return m_target;
     99    }
     100
     101    const DataVector& data() const
     102    {
     103        ASSERT(m_type == XMLTokenTypes::CDATA || m_type == XMLTokenTypes::ProcessingInstruction);
     104        return m_data;
     105    }
     106
     107    const DataVector& prefix() const
     108    {
     109        ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag);
     110        return m_target;
     111    }
     112
     113    const XMLDeclarationData& xmlDeclarationData() const
     114    {
     115        ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
     116        ASSERT(m_xmlDeclarationData);
     117        return *m_xmlDeclarationData.get();
     118    }
     119
     120    void beginDOCTYPE()
     121    {
     122        ASSERT(m_type == XMLTokenTypes::Uninitialized);
     123        m_type = XMLTokenTypes::DOCTYPE;
     124        m_doctypeData = adoptPtr(new DoctypeData());
     125    }
     126
     127    void beginDOCTYPE(UChar character)
     128    {
     129        ASSERT(character);
     130        beginDOCTYPE();
     131        m_data.append(character);
     132    }
     133
     134    void beginXMLDeclaration()
     135    {
     136        ASSERT(m_type == XMLTokenTypes::Uninitialized);
     137        m_type = XMLTokenTypes::XMLDeclaration;
     138        m_xmlDeclarationData = adoptPtr(new XMLDeclarationData());
     139    }
     140   
     141    void appendToXMLVersion(UChar character)
     142    {
     143        ASSERT(character);
     144        ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
     145        ASSERT(m_xmlDeclarationData);
     146        m_xmlDeclarationData->m_version.append(character);
     147    }
     148
     149    void beginXMLEncoding(UChar character)
     150    {
     151        ASSERT(character);
     152        ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
     153        ASSERT(m_xmlDeclarationData);
     154        m_xmlDeclarationData->m_hasEncoding = true;
     155        m_xmlDeclarationData->m_encoding.append(character);
     156    }
     157
     158    void appendToXMLEncoding(UChar character)
     159    {
     160        ASSERT(character);
     161        ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
     162        ASSERT(m_xmlDeclarationData);
     163        ASSERT(m_xmlDeclarationData->m_hasEncoding);
     164        m_xmlDeclarationData->m_encoding.append(character);
     165    }
     166
     167    void setXMLStandalone(bool standalone)
     168    {
     169        ASSERT(m_type == XMLTokenTypes::XMLDeclaration);
     170        ASSERT(m_xmlDeclarationData);
     171        m_xmlDeclarationData->m_hasStandalone = true;
     172        m_xmlDeclarationData->m_standalone = standalone;
     173    }
     174
     175    void beginProcessingInstruction()
     176    {
     177        ASSERT(m_type == XMLTokenTypes::Uninitialized);
     178        m_type = XMLTokenTypes::ProcessingInstruction;
     179    }
     180
     181    void beginProcessingInstruction(UChar character)
     182    {
     183        ASSERT(character);
     184        beginProcessingInstruction();
     185        m_target.append(character);
     186    }
     187
     188    void appendToProcessingInstructionTarget(UChar character)
     189    {
     190        ASSERT(m_type == XMLTokenTypes::ProcessingInstruction);
     191        ASSERT(character);
     192        m_target.append(character);
     193    }
     194
     195    void appendToProcessingInstructionData(UChar character)
     196    {
     197        ASSERT(m_type == XMLTokenTypes::ProcessingInstruction);
     198        ASSERT(character);
     199        m_data.append(character);
     200    }
     201
     202    void endPrefix()
     203    {
     204        ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag);
     205        ASSERT(m_target.isEmpty());
     206        // FIXME: see if we can avoid the copy inherent with this swap
     207        m_target.swap(m_data);
     208    }
     209
     210    bool hasPrefix() const
     211    {
     212        ASSERT(m_type == XMLTokenTypes::StartTag || m_type == XMLTokenTypes::EndTag);
     213        return m_target.size();
     214    }
     215
     216    void beginCDATA()
     217    {
     218        ASSERT(m_type == XMLTokenTypes::Uninitialized);
     219        m_type = XMLTokenTypes::CDATA;
     220    }
     221
     222    void appendToCDATA(UChar character)
     223    {
     224        ASSERT(m_type == XMLTokenTypes::CDATA);
     225        ASSERT(character);
     226        m_data.append(character);
     227    }
     228
     229    void beginEntity()
     230    {
     231        ASSERT(m_type == XMLTokenTypes::Uninitialized);
     232        m_type = XMLTokenTypes::Entity;
     233    }
     234
     235    void beginEntity(UChar character)
     236    {
     237        ASSERT(character);
     238        beginEntity();
     239        m_data.append(character);
     240    }
     241
     242    void endAttributePrefix(int offset)
     243    {
     244        ASSERT(m_type == XMLTokenTypes::StartTag);
     245        int index = offset - m_baseOffset;
     246        m_currentAttribute->m_prefix.swap(m_currentAttribute->m_name);
     247        m_currentAttribute->m_prefixRange.m_start = m_currentAttribute->m_valueRange.m_start;
     248        m_currentAttribute->m_prefixRange.m_end = index;
     249        m_currentAttribute->m_nameRange.m_start = index;
     250        m_currentAttribute->m_nameRange.m_end = index;
     251    }
     252
     253    bool attributeHasPrefix()
     254    {
     255        ASSERT(m_type == XMLTokenTypes::StartTag);
     256        return !m_currentAttribute->m_prefix.isEmpty();
     257    }
     258
     259#ifndef NDEBUG
     260    void printAttrs() const
     261    {
     262        AttributeList::const_iterator iter = m_attributes.begin();
     263        for (; iter != m_attributes.end(); ++iter) {
     264            fprintf(stderr, " ");
     265            if (!iter->m_prefix.isEmpty()) {
     266                printString(iter->m_prefix);
     267                fprintf(stderr, ":");
     268            }
     269            printString(iter->m_name);
     270            fprintf(stderr, "=\"");
     271            printString(iter->m_value);
     272            fprintf(stderr, "\"");
     273        }
     274    }
     275
     276    void print() const
     277    {
     278        switch (m_type) {
     279        case XMLTokenTypes::Uninitialized:
     280            fprintf(stderr, "UNITIALIZED");
     281            break;
     282
     283        case XMLTokenTypes::ProcessingInstruction:
     284            fprintf(stderr, "ProcessingInstruction: ");
     285            fprintf(stderr, "<?");
     286            printString(m_target);
     287            fprintf(stderr, " ");
     288            printString(m_data);
     289            fprintf(stderr, "?>");
     290            break;
     291
     292        case XMLTokenTypes::XMLDeclaration:
     293            fprintf(stderr, "XML Declaration: ");
     294            fprintf(stderr, "<?xml version=\"");
     295            ASSERT(m_xmlDeclarationData);
     296            printString(m_xmlDeclarationData->m_version);
     297            fprintf(stderr, "\"");
     298            if (m_xmlDeclarationData->m_hasEncoding) {
     299                fprintf(stderr, " encoding=\"");
     300                printString(m_xmlDeclarationData->m_encoding);
     301                fprintf(stderr, "\"");
     302            }
     303            if (m_xmlDeclarationData->m_hasStandalone)
     304                fprintf(stderr, " standalone=\"%s\"", m_xmlDeclarationData->m_standalone ? "yes" : "no");
     305            fprintf(stderr, "?>");
     306            break;
     307
     308        case XMLTokenTypes::DOCTYPE:
     309            fprintf(stderr, "DOCTYPE: ");
     310            ASSERT(m_doctypeData);
     311            fprintf(stderr, "<!DOCTYPE ");
     312            printString(m_data);
     313            if (m_doctypeData->m_hasPublicIdentifier) {
     314                fprintf(stderr, " PUBLIC \"");
     315                printString(m_doctypeData->m_publicIdentifier);
     316                fprintf(stderr, "\"");
     317                if (m_doctypeData->m_hasSystemIdentifier) {
     318                    fprintf(stderr, " \"");
     319                    printString(m_doctypeData->m_systemIdentifier);
     320                    fprintf(stderr, "\"");
     321                }
     322            } else if (m_doctypeData->m_hasSystemIdentifier) {
     323                fprintf(stderr, " SYSTEM \"");
     324                printString(m_doctypeData->m_systemIdentifier);
     325                fprintf(stderr, "\"");
     326            }
     327            fprintf(stderr, ">");
     328            break;
     329
     330        case XMLTokenTypes::CDATA:
     331            fprintf(stderr, "CDATA: ");
     332            fprintf(stderr, "<![CDATA[");
     333            printString(m_data);
     334            fprintf(stderr, "]]>");
     335            break;
     336
     337        case XMLTokenTypes::StartTag:
     338            fprintf(stderr, "Start Tag: ");
     339            fprintf(stderr, "<");
     340            if (hasPrefix()) {
     341                printString(m_target);
     342                fprintf(stderr, ":");
     343            }
     344            printString(m_data);
     345            printAttrs();
     346            if (selfClosing())
     347                fprintf(stderr, "/");
     348            fprintf(stderr, ">");
     349            break;
     350
     351        case XMLTokenTypes::EndTag:
     352            fprintf(stderr, "End Tag: ");
     353            fprintf(stderr, "</");
     354            if (hasPrefix()) {
     355                printString(m_target);
     356                fprintf(stderr, ":");
     357            }
     358            printString(m_data);
     359            fprintf(stderr, ">");
     360            break;
     361
     362        case XMLTokenTypes::Comment:
     363            fprintf(stderr, "Comment: ");
     364            fprintf(stderr, "<!--");
     365            printString(m_data);
     366            fprintf(stderr, "-->");
     367            break;
     368
     369        case XMLTokenTypes::Character:
     370            fprintf(stderr, "Characters: ");
     371            printString(m_data);
     372            break;
     373
     374        case XMLTokenTypes::Entity:
     375            fprintf(stderr, "Entity: ");
     376            fprintf(stderr, "&");
     377            printString(m_data);
     378            fprintf(stderr, ";");
     379            break;
     380
     381        case XMLTokenTypes::EndOfFile:
     382            fprintf(stderr, "EOF");
     383            break;
     384        }
     385
     386        fprintf(stderr, "\n");
     387    }
     388#endif // NDEBUG
     389
     390private:
     391
     392    typedef DoctypeDataBase DoctypeData;
     393
     394    // "target" for ProcessingInstruction, "prefix" for StartTag and EndTag
    325395    DataVector m_target;
    326    
     396
    327397    // For XML Declaration
    328398    OwnPtr<XMLDeclarationData> m_xmlDeclarationData;
  • trunk/Source/WebCore/xml/parser/XMLTokenizer.cpp

    r91811 r92249  
    115115    if (cc < 0x30)
    116116        return false;
    117     if (cc < 0x3B)
     117    if (cc < 0x3A)
    118118        return true;
    119119    if (cc < 0x0300)
     
    302302            m_token->appendToName(cc);
    303303            XML_ADVANCE_TO(TagNameState);
     304        } else if (cc == ':' && !m_token->hasPrefix()) {
     305            m_token->endPrefix();
     306            XML_ADVANCE_TO(TagNameState);
    304307        } else {
    305308            parseError();
     
    316319        else if (isValidNameChar(cc)) {
    317320            m_token->appendToName(cc);
     321            XML_ADVANCE_TO(EndTagNameState);
     322        } else if (cc == ':' && !m_token->hasPrefix()) {
     323            m_token->endPrefix();
    318324            XML_ADVANCE_TO(EndTagNameState);
    319325        } else {
     
    364370        } else if (isValidNameChar(cc)) {
    365371            m_token->appendToAttributeName(cc);
     372            XML_ADVANCE_TO(AttributeNameState);
     373        } else if (cc == ':' && !m_token->attributeHasPrefix()) {
     374            m_token->endAttributePrefix(source.numberOfCharactersConsumed());
    366375            XML_ADVANCE_TO(AttributeNameState);
    367376        } else {
Note: See TracChangeset for help on using the changeset viewer.