WebCore:
[WebKit-https.git] / WebCore / html / HTMLDocument.cpp
1 /**
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
6  * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  *
23  * Portions are Copyright (C) 2002 Netscape Communications Corporation.
24  * Other contributors: David Baron <dbaron@fas.harvard.edu>
25  *
26  * This library is free software; you can redistribute it and/or
27  * modify it under the terms of the GNU Lesser General Public
28  * License as published by the Free Software Foundation; either
29  * version 2.1 of the License, or (at your option) any later version.
30  *
31  * This library is distributed in the hope that it will be useful,
32  * but WITHOUT ANY WARRANTY; without even the implied warranty of
33  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
34  * Lesser General Public License for more details.
35  *
36  * You should have received a copy of the GNU Lesser General Public
37  * License along with this library; if not, write to the Free Software
38  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
39  *
40  * Alternatively, the document type parsing portions of this file may be used
41  * under the terms of either the Mozilla Public License Version 1.1, found at
42  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
43  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
44  * (the "GPL"), in which case the provisions of the MPL or the GPL are
45  * applicable instead of those above.  If you wish to allow use of your
46  * version of this file only under the terms of one of those two
47  * licenses (the MPL or the GPL) and not to allow others to use your
48  * version of this file under the LGPL, indicate your decision by
49  * deleting the provisions above and replace them with the notice and
50  * other provisions required by the MPL or the GPL, as the case may be.
51  * If you do not delete the provisions above, a recipient may use your
52  * version of this file under any of the LGPL, the MPL or the GPL.
53  */
54
55 #include "config.h"
56 #include "HTMLDocument.h"
57
58 #include "CSSPropertyNames.h"
59 #include "CString.h"
60 #include "CookieJar.h"
61 #include "DocumentType.h"
62 #include "ExceptionCode.h"
63 #include "Frame.h"
64 #include "HTMLElement.h"
65 #include "HTMLElementFactory.h"
66 #include "HTMLNames.h"
67 #include "HTMLTokenizer.h"
68 #include "cssstyleselector.h"
69
70 #include "DocTypeStrings.cpp"
71
72 namespace WebCore {
73
74 using namespace HTMLNames;
75
76 HTMLDocument::HTMLDocument(DOMImplementation *_implementation, FrameView *v)
77   : Document(_implementation, v)
78 {
79     bodyElement = 0;
80     htmlElement = 0;
81 }
82
83 HTMLDocument::~HTMLDocument()
84 {
85 }
86
87 String HTMLDocument::lastModified() const
88 {
89     if ( frame() )
90         return frame()->lastModified();
91     return String();
92 }
93
94 String HTMLDocument::cookie() const
95 {
96     return cookies(URL());
97 }
98
99 void HTMLDocument::setCookie(const String& value)
100 {
101     setCookies(URL(), m_policyBaseURL.deprecatedString(), value);
102 }
103
104 void HTMLDocument::setBody(HTMLElement *_body, ExceptionCode& ec)
105 {
106     if (!_body) { 
107         ec = HIERARCHY_REQUEST_ERR;
108         return;
109     }
110     HTMLElement* b = body();
111     if (!b)
112         documentElement()->appendChild(_body, ec);
113     else
114         documentElement()->replaceChild(_body, b, ec);
115 }
116
117 Tokenizer *HTMLDocument::createTokenizer()
118 {
119     return new HTMLTokenizer(this);
120 }
121
122 // --------------------------------------------------------------------------
123 // not part of the DOM
124 // --------------------------------------------------------------------------
125
126 bool HTMLDocument::childAllowed( Node *newChild )
127 {
128     return newChild->hasTagName(htmlTag) || newChild->isCommentNode();
129 }
130
131 PassRefPtr<Element> HTMLDocument::createElement(const String &name, ExceptionCode& ec)
132 {
133     String lowerName(name.lower());
134     if (!isValidName(lowerName)) {
135         ec = INVALID_CHARACTER_ERR;
136         return 0;
137     }
138     return HTMLElementFactory::createHTMLElement(AtomicString(lowerName), this, 0, false);
139 }
140
141 static void addItemToMap(HTMLDocument::NameCountMap& map, const String& name)
142 {
143     if (name.length() == 0)
144         return;
145  
146     HTMLDocument::NameCountMap::iterator it = map.find(name.impl()); 
147     if (it == map.end())
148         map.set(name.impl(), 1);
149     else
150         ++(it->second);
151 }
152
153 static void removeItemFromMap(HTMLDocument::NameCountMap& map, const String& name)
154 {
155     if (name.length() == 0)
156         return;
157  
158     HTMLDocument::NameCountMap::iterator it = map.find(name.impl()); 
159     if (it == map.end())
160         return;
161
162     int oldVal = it->second;
163     assert(oldVal != 0);
164     int newVal = oldVal - 1;
165     if (newVal == 0)
166         map.remove(it);
167     else
168         it->second = newVal;
169 }
170
171 void HTMLDocument::addNamedItem(const String& name)
172 {
173     addItemToMap(namedItemCounts, name);
174 }
175
176 void HTMLDocument::removeNamedItem(const String &name)
177
178     removeItemFromMap(namedItemCounts, name);
179 }
180
181 bool HTMLDocument::hasNamedItem(const String& name)
182 {
183     return namedItemCounts.get(name.impl()) != 0;
184 }
185
186 void HTMLDocument::addDocExtraNamedItem(const String& name)
187 {
188     addItemToMap(docExtraNamedItemCounts, name);
189 }
190
191 void HTMLDocument::removeDocExtraNamedItem(const String& name)
192
193     removeItemFromMap(docExtraNamedItemCounts, name);
194 }
195
196 bool HTMLDocument::hasDocExtraNamedItem(const String& name)
197 {
198     return docExtraNamedItemCounts.get(name.impl()) != 0;
199 }
200
201 const int PARSEMODE_HAVE_DOCTYPE        =       (1<<0);
202 const int PARSEMODE_HAVE_PUBLIC_ID      =       (1<<1);
203 const int PARSEMODE_HAVE_SYSTEM_ID      =       (1<<2);
204 const int PARSEMODE_HAVE_INTERNAL       =       (1<<3);
205
206 static int parseDocTypePart(const String& buffer, int index)
207 {
208     while (true) {
209         UChar ch = buffer[index];
210         if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')
211             ++index;
212         else if (ch == '-') {
213             int tmpIndex=index;
214             if (buffer[index+1] == '-' &&
215                 ((tmpIndex=buffer.find("--", index+2)) != -1))
216                 index = tmpIndex+2;
217             else
218                 return index;
219         }
220         else
221             return index;
222     }
223 }
224
225 static bool containsString(const char* str, const String& buffer, int offset)
226 {
227     String startString(str);
228     if (offset + startString.length() > buffer.length())
229         return false;
230     
231     String bufferString = buffer.substring(offset, startString.length()).lower();
232     String lowerStart = startString.lower();
233
234     return bufferString.startsWith(lowerStart);
235 }
236
237 static bool parseDocTypeDeclaration(const String& buffer,
238                                     int* resultFlags,
239                                     String& name,
240                                     String& publicID,
241                                     String& systemID)
242 {
243     bool haveDocType = false;
244     *resultFlags = 0;
245
246     // Skip through any comments and processing instructions.
247     int index = 0;
248     do {
249         index = buffer.find('<', index);
250         if (index == -1) break;
251         UChar nextChar = buffer[index+1];
252         if (nextChar == '!') {
253             if (containsString("doctype", buffer, index+2)) {
254                 haveDocType = true;
255                 index += 9; // Skip "<!DOCTYPE"
256                 break;
257             }
258             index = parseDocTypePart(buffer,index);
259             index = buffer.find('>', index);
260         }
261         else if (nextChar == '?')
262             index = buffer.find('>', index);
263         else
264             break;
265     } while (index != -1);
266
267     if (!haveDocType)
268         return true;
269     *resultFlags |= PARSEMODE_HAVE_DOCTYPE;
270
271     index = parseDocTypePart(buffer, index);
272     if (!containsString("html", buffer, index))
273         return false;
274     
275     name = buffer.substring(index, 4);
276     index = parseDocTypePart(buffer, index+4);
277     bool hasPublic = containsString("public", buffer, index);
278     if (hasPublic) {
279         index = parseDocTypePart(buffer, index+6);
280
281         // We've read <!DOCTYPE HTML PUBLIC (not case sensitive).
282         // Now we find the beginning and end of the public identifers
283         // and system identifiers (assuming they're even present).
284         UChar theChar = buffer[index];
285         if (theChar != '\"' && theChar != '\'')
286             return false;
287         
288         // |start| is the first character (after the quote) and |end|
289         // is the final quote, so there are |end|-|start| characters.
290         int publicIDStart = index+1;
291         int publicIDEnd = buffer.find(theChar, publicIDStart);
292         if (publicIDEnd == -1)
293             return false;
294         index = parseDocTypePart(buffer, publicIDEnd+1);
295         UChar next = buffer[index];
296         if (next == '>') {
297             // Public identifier present, but no system identifier.
298             // Do nothing.  Note that this is the most common
299             // case.
300         }
301         else if (next == '\"' || next == '\'') {
302             // We have a system identifier.
303             *resultFlags |= PARSEMODE_HAVE_SYSTEM_ID;
304             int systemIDStart = index+1;
305             int systemIDEnd = buffer.find(next, systemIDStart);
306             if (systemIDEnd == -1)
307                 return false;
308             systemID = buffer.substring(systemIDStart, systemIDEnd - systemIDStart);
309         }
310         else if (next == '[') {
311             // We found an internal subset.
312             *resultFlags |= PARSEMODE_HAVE_INTERNAL;
313         }
314         else
315             return false; // Something's wrong.
316
317         // We need to trim whitespace off the public identifier.
318         publicID = buffer.substring(publicIDStart, publicIDEnd - publicIDStart);
319         publicID = publicID.stripWhiteSpace();
320         *resultFlags |= PARSEMODE_HAVE_PUBLIC_ID;
321     } else {
322         if (containsString("system", buffer, index)) {
323             // Doctype has a system ID but no public ID
324             *resultFlags |= PARSEMODE_HAVE_SYSTEM_ID;
325             index = parseDocTypePart(buffer, index+6);
326             UChar next = buffer[index];
327             if (next != '\"' && next != '\'')
328                 return false;
329             int systemIDStart = index+1;
330             int systemIDEnd = buffer.find(next, systemIDStart);
331             if (systemIDEnd == -1)
332                 return false;
333             systemID = buffer.substring(systemIDStart, systemIDEnd - systemIDStart);
334             index = parseDocTypePart(buffer, systemIDEnd+1);
335         }
336
337         UChar nextChar = buffer[index];
338         if (nextChar == '[')
339             *resultFlags |= PARSEMODE_HAVE_INTERNAL;
340         else if (nextChar != '>')
341             return false;
342     }
343
344     return true;
345 }
346
347 void HTMLDocument::determineParseMode(const String& str)
348 {
349     // This code more or less mimics Mozilla's implementation (specifically the
350     // doctype parsing implemented by David Baron in Mozilla's nsParser.cpp).
351     //
352     // There are three possible parse modes:
353     // COMPAT - quirks mode emulates WinIE
354     // and NS4.  CSS parsing is also relaxed in this mode, e.g., unit types can
355     // be omitted from numbers.
356     // ALMOST STRICT - This mode is identical to strict mode
357     // except for its treatment of line-height in the inline box model.  For
358     // now (until the inline box model is re-written), this mode is identical
359     // to STANDARDS mode.
360     // STRICT - no quirks apply.  Web pages will obey the specifications to
361     // the letter.
362
363     String name, systemID, publicID;
364     int resultFlags = 0;
365     if (parseDocTypeDeclaration(str, &resultFlags, name, publicID, systemID)) {
366         if (resultFlags & PARSEMODE_HAVE_DOCTYPE)
367             setDocType(new DocumentType(this, name, publicID, systemID));
368         if (!(resultFlags & PARSEMODE_HAVE_DOCTYPE)) {
369             // No doctype found at all.  Default to quirks mode and Html4.
370             pMode = Compat;
371             hMode = Html4;
372         }
373         else if ((resultFlags & PARSEMODE_HAVE_INTERNAL) ||
374                  !(resultFlags & PARSEMODE_HAVE_PUBLIC_ID)) {
375             // Internal subsets always denote full standards, as does
376             // a doctype without a public ID.
377             pMode = Strict;
378             hMode = Html4;
379         }
380         else {
381             // We have to check a list of public IDs to see what we
382             // should do.
383             String lowerPubID = publicID.lower();
384             CString pubIDStr = lowerPubID.latin1();
385            
386             // Look up the entry in our gperf-generated table.
387             const PubIDInfo* doctypeEntry = findDoctypeEntry(pubIDStr, pubIDStr.length());
388             if (!doctypeEntry) {
389                 // The DOCTYPE is not in the list.  Assume strict mode.
390                 pMode = Strict;
391                 hMode = Html4;
392                 return;
393             }
394
395             switch ((resultFlags & PARSEMODE_HAVE_SYSTEM_ID) ?
396                     doctypeEntry->mode_if_sysid :
397                     doctypeEntry->mode_if_no_sysid)
398             {
399                 case PubIDInfo::eQuirks3:
400                     pMode = Compat;
401                     hMode = Html3;
402                     break;
403                 case PubIDInfo::eQuirks:
404                     pMode = Compat;
405                     hMode = Html4;
406                     break;
407                 case PubIDInfo::eAlmostStandards:
408                     pMode = AlmostStrict;
409                     hMode = Html4;
410                     break;
411                  default:
412                     assert(false);
413             }
414         }   
415     }
416     else {
417         // Malformed doctype implies quirks mode.
418         pMode = Compat;
419         hMode = Html3;
420     }
421   
422     m_styleSelector->strictParsing = !inCompatMode();
423  
424 }
425     
426 }