parser/html/nsHtml5Parser.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Henri Sivonen <hsivonen@iki.fi>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #ifndef NS_HTML5_PARSER__
  40 #define NS_HTML5_PARSER__
  41
  42 #include "nsAutoPtr.h"
  43 #include "nsIParser.h"
  44 #include "nsDeque.h"
  45 #include "nsIURL.h"
  46 #include "nsParserCIID.h"
  47 #include "nsITokenizer.h"
  48 #include "nsThreadUtils.h"
  49 #include "nsIContentSink.h"
  50 #include "nsIParserFilter.h"
  51 #include "nsIRequest.h"
  52 #include "nsIChannel.h"
  53 #include "nsCOMArray.h"
  54 #include "nsContentSink.h"
  55 #include "nsIHTMLDocument.h"
  56 #include "nsIUnicharStreamListener.h"
  57 #include "nsCycleCollectionParticipant.h"
  58 #include "nsIInputStream.h"
  59 #include "nsDetectionConfident.h"
  60 #include "nsHtml5UTF16Buffer.h"
  61 #include "nsHtml5TreeOpExecutor.h"
  62 #include "nsHtml5StreamParser.h"
  63 #include "nsHtml5AtomTable.h"
  64 #include "nsWeakReference.h"
  65 #include "nsAHtml5FragmentParser.h"
  66
  67 class nsHtml5Parser : public nsAHtml5FragmentParser, // inherits nsIParser
  68                       public nsSupportsWeakReference
  69 {
  70   public:
  71     NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
  72     NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  73
  74     NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsHtml5Parser, nsIParser)
  75
  76     nsHtml5Parser();
  77     virtual ~nsHtml5Parser();
  78
  79     /* Start nsIParser */
  80     /**
  81      * No-op for backwards compat.
  82      */
  83     NS_IMETHOD_(void) SetContentSink(nsIContentSink* aSink);
  84
  85     /**
  86      * Returns the tree op executor for backwards compat.
  87      */
  88     NS_IMETHOD_(nsIContentSink*) GetContentSink();
  89
  90     /**
  91      * Always returns "view" for backwards compat.
  92      */
  93     NS_IMETHOD_(void) GetCommand(nsCString& aCommand);
  94
  95     /**
  96      * No-op for backwards compat.
  97      */
  98     NS_IMETHOD_(void) SetCommand(const char* aCommand);
  99
 100     /**
 101      * No-op for backwards compat.
 102      */
 103     NS_IMETHOD_(void) SetCommand(eParserCommands aParserCommand);
 104
 105     /**
 106      *  Call this method once you've created a parser, and want to instruct it
 107      *  about what charset to load
 108      *
 109      *  @param   aCharset the charset of a document
 110      *  @param   aCharsetSource the source of the charset
 111      */
 112     NS_IMETHOD_(void) SetDocumentCharset(const nsACString& aCharset, PRInt32 aSource);
 113
 114     /**
 115      * Don't call. For interface compat only.
 116      */
 117     NS_IMETHOD_(void) GetDocumentCharset(nsACString& aCharset, PRInt32& aSource)
 118     {
 119       NS_NOTREACHED("No one should call this.");
 120     }
 121
 122     /**
 123      * No-op for backwards compat.
 124      */
 125     NS_IMETHOD_(void) SetParserFilter(nsIParserFilter* aFilter);
 126
 127     /**
 128      * Get the channel associated with this parser
 129      * @param aChannel out param that will contain the result
 130      * @return NS_OK if successful or NS_NOT_AVAILABLE if not
 131      */
 132     NS_IMETHOD GetChannel(nsIChannel** aChannel);
 133
 134     /**
 135      * Return |this| for backwards compat.
 136      */
 137     NS_IMETHOD GetDTD(nsIDTD** aDTD);
 138
 139     /**
 140      * Get the stream parser for this parser
 141      */
 142     NS_IMETHOD GetStreamListener(nsIStreamListener** aListener);
 143
 144     /**
 145      * Don't call. For interface compat only.
 146      */
 147     NS_IMETHOD ContinueInterruptedParsing();
 148
 149     /**
 150      * Blocks the parser.
 151      */
 152     NS_IMETHOD_(void) BlockParser();
 153
 154     /**
 155      * Unblocks the parser.
 156      */
 157     NS_IMETHOD_(void) UnblockParser();
 158
 159     /**
 160      * Query whether the parser is enabled (i.e. not blocked) or not.
 161      */
 162     NS_IMETHOD_(PRBool) IsParserEnabled();
 163
 164     /**
 165      * Query whether the parser thinks it's done with parsing.
 166      */
 167     NS_IMETHOD_(PRBool) IsComplete();
 168
 169     /**
 170      * Set up request observer.
 171      *
 172      * @param   aURL ignored (for interface compat only)
 173      * @param   aListener a listener to forward notifications to
 174      * @param   aKey the root context key (used for document.write)
 175      * @param   aMode ignored (for interface compat only)
 176      */
 177     NS_IMETHOD Parse(nsIURI* aURL,
 178                      nsIRequestObserver* aListener = nsnull,
 179                      void* aKey = 0,
 180                      nsDTDMode aMode = eDTDMode_autodetect);
 181
 182     /**
 183      * document.write and document.close
 184      *
 185      * @param   aSourceBuffer the argument of document.write (empty for .close())
 186      * @param   aKey a key unique to the script element that caused this call
 187      * @param   aContentType ignored (for interface compat only)
 188      * @param   aLastCall true if .close() false if .write()
 189      * @param   aMode ignored (for interface compat only)
 190      */
 191     NS_IMETHOD Parse(const nsAString& aSourceBuffer,
 192                      void* aKey,
 193                      const nsACString& aContentType,
 194                      PRBool aLastCall,
 195                      nsDTDMode aMode = eDTDMode_autodetect);
 196
 197     /**
 198      * Gets the key passed to initial Parse()
 199      */
 200     NS_IMETHOD_(void *) GetRootContextKey();
 201
 202     /**
 203      * Stops the parser prematurely
 204      */
 205     NS_IMETHOD Terminate();
 206
 207     /**
 208      * Don't call. For interface backwards compat only.
 209      */
 210     NS_IMETHOD ParseFragment(const nsAString& aSourceBuffer,
 211                              void* aKey,
 212                              nsTArray<nsString>& aTagStack,
 213                              PRBool aXMLMode,
 214                              const nsACString& aContentType,
 215                              nsDTDMode aMode = eDTDMode_autodetect);
 216
 217     /**
 218      * Don't call. For interface backwards compat only.
 219      */
 220     NS_IMETHOD ParseFragment(const nsAString& aSourceBuffer,
 221                              nsIContent* aTargetNode,
 222                              nsIAtom* aContextLocalName,
 223                              PRInt32 aContextNamespace,
 224                              PRBool aQuirks);
 225
 226     /**
 227      * Don't call. For interface compat only.
 228      */
 229     NS_IMETHOD BuildModel();
 230
 231     /**
 232      * Don't call. For interface compat only.
 233      */
 234     NS_IMETHODIMP CancelParsingEvents();
 235
 236     /**
 237      * Sets the state to initial values
 238      */
 239     virtual void Reset();
 240
 241     /**
 242      * True in fragment mode and during synchronous document.write
 243      */
 244     virtual PRBool CanInterrupt();
 245
 246     /**
 247      * True if the insertion point (per HTML5) is defined.
 248      */
 249     virtual PRBool IsInsertionPointDefined();
 250
 251     /**
 252      * Call immediately before starting to evaluate a parser-inserted script.
 253      */
 254     virtual void BeginEvaluatingParserInsertedScript();
 255
 256     /**
 257      * Call immediately after having evaluated a parser-inserted script.
 258      */
 259     virtual void EndEvaluatingParserInsertedScript();
 260
 261     /**
 262      * Marks the HTML5 parser as not a script-created parser: Prepares the
 263      * parser to be able to read a stream.
 264      */
 265     virtual void MarkAsNotScriptCreated();
 266
 267     /**
 268      * True if this is a script-created HTML5 parser.
 269      */
 270     virtual PRBool IsScriptCreated();
 271
 272     /* End nsIParser  */
 273
 274     /* Start nsAHtml5FragmentParser */
 275
 276     /**
 277      * Invoke the fragment parsing algorithm (innerHTML).
 278      *
 279      * @param aSourceBuffer the string being set as innerHTML
 280      * @param aTargetNode the target container
 281      * @param aContextLocalName local name of context node
 282      * @param aContextNamespace namespace of context node
 283      * @param aQuirks true to make <table> not close <p>
 284      * @param aPreventScriptExecution true to prevent scripts from executing;
 285      * don't set to false when parsing into a target node that has been bound
 286      * to tree.
 287      */
 288     NS_IMETHOD ParseHtml5Fragment(const nsAString& aSourceBuffer,
 289                                   nsIContent* aTargetNode,
 290                                   nsIAtom* aContextLocalName,
 291                                   PRInt32 aContextNamespace,
 292                                   PRBool aQuirks,
 293                                   PRBool aPreventScriptExecution);
 294
 295
 296     /* End nsAHtml5FragmentParser */
 297
 298     // Not from an external interface
 299     // Non-inherited methods
 300
 301   public:
 302
 303     /**
 304      * Initializes the parser to load from a channel.
 305      */
 306     virtual nsresult Initialize(nsIDocument* aDoc,
 307                         nsIURI* aURI,
 308                         nsISupports* aContainer,
 309                         nsIChannel* aChannel);
 310
 311     inline nsHtml5Tokenizer* GetTokenizer() {
 312       return mTokenizer;
 313     }
 314
 315     void InitializeDocWriteParserState(nsAHtml5TreeBuilderState* aState, PRInt32 aLine);
 316
 317     void DropStreamParser() {
 318       if (mStreamParser) {
 319         mStreamParser->DropTimer();
 320         mStreamParser = nsnull;
 321       }
 322     }
 323
 324     void StartTokenizer(PRBool aScriptingEnabled);
 325
 326     void ContinueAfterFailedCharsetSwitch();
 327
 328     nsHtml5StreamParser* GetStreamParser() {
 329       return mStreamParser;
 330     }
 331
 332     /**
 333      * Parse until pending data is exhausted or a script blocks the parser
 334      */
 335     void ParseUntilBlocked();
 336
 337   private:
 338
 339     // State variables
 340
 341     /**
 342      * Whether the last character tokenized was a carriage return (for CRLF)
 343      */
 344     PRBool                        mLastWasCR;
 345
 346     /**
 347      * Whether the last character tokenized was a carriage return (for CRLF)
 348      * when preparsing document.write.
 349      */
 350     PRBool                        mDocWriteSpeculativeLastWasCR;
 351
 352     /**
 353      * The parser is in the fragment mode
 354      */
 355     PRBool                        mFragmentMode;
 356
 357     /**
 358      * The parser is blocking on a script
 359      */
 360     PRBool                        mBlocked;
 361
 362     /**
 363      * Whether the document.write() speculator is already active.
 364      */
 365     PRBool                        mDocWriteSpeculatorActive;
 366
 367     /**
 368      * The number of parser-inserted script currently being evaluated.
 369      */
 370     PRInt32                       mParserInsertedScriptsBeingEvaluated;
 371
 372     /**
 373      * True if document.close() has been called.
 374      */
 375     PRBool                        mDocumentClosed;
 376
 377     // Gecko integration
 378     void*                         mRootContextKey;
 379
 380     // Portable parser objects
 381     /**
 382      * The first buffer in the pending UTF-16 buffer queue
 383      */
 384     nsRefPtr<nsHtml5UTF16Buffer>  mFirstBuffer;
 385
 386     /**
 387      * The last buffer in the pending UTF-16 buffer queue
 388      */
 389     nsHtml5UTF16Buffer*           mLastBuffer; // weak ref; always points to
 390                       // a buffer of the size NS_HTML5_PARSER_READ_BUFFER_SIZE
 391
 392     /**
 393      * The tree operation executor
 394      */
 395     nsRefPtr<nsHtml5TreeOpExecutor>     mExecutor;
 396
 397     /**
 398      * The HTML5 tree builder
 399      */
 400     const nsAutoPtr<nsHtml5TreeBuilder> mTreeBuilder;
 401
 402     /**
 403      * The HTML5 tokenizer
 404      */
 405     const nsAutoPtr<nsHtml5Tokenizer>   mTokenizer;
 406
 407     /**
 408      * Another HTML5 tree builder for preloading document.written content.
 409      */
 410     nsAutoPtr<nsHtml5TreeBuilder> mDocWriteSpeculativeTreeBuilder;
 411
 412     /**
 413      * Another HTML5 tokenizer for preloading document.written content.
 414      */
 415     nsAutoPtr<nsHtml5Tokenizer>   mDocWriteSpeculativeTokenizer;
 416
 417     /**
 418      * The stream parser.
 419      */
 420     nsRefPtr<nsHtml5StreamParser>       mStreamParser;
 421
 422     /**
 423      *
 424      */
 425     PRInt32                             mRootContextLineNumber;
 426
 427     /**
 428      * Whether it's OK to transfer parsing back to the stream parser
 429      */
 430     PRBool                              mReturnToStreamParserPermitted;
 431
 432     /**
 433      * The scoped atom table
 434      */
 435     nsHtml5AtomTable                    mAtomTable;
 436
 437 };
 438 #endif