parser/htmlparser/nsParser.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /**
   7  * MODULE NOTES:
   8  *
   9  *  This class does two primary jobs:
  10  *    1) It iterates the tokens provided during the
  11  *       tokenization process, identifing where elements
  12  *       begin and end (doing validation and normalization).
  13  *    2) It controls and coordinates with an instance of
  14  *       the IContentSink interface, to coordinate the
  15  *       the production of the content model.
  16  *
  17  *  The basic operation of this class assumes that an HTML
  18  *  document is non-normalized. Therefore, we don't process
  19  *  the document in a normalized way. Don't bother to look
  20  *  for methods like: doHead() or doBody().
  21  *
  22  *  Instead, in order to be backward compatible, we must
  23  *  scan the set of tokens and perform this basic set of
  24  *  operations:
  25  *    1)  Determine the token type (easy, since the tokens know)
  26  *    2)  Determine the appropriate section of the HTML document
  27  *        each token belongs in (HTML,HEAD,BODY,FRAMESET).
  28  *    3)  Insert content into our document (via the sink) into
  29  *        the correct section.
  30  *    4)  In the case of tags that belong in the BODY, we must
  31  *        ensure that our underlying document state reflects
  32  *        the appropriate context for our tag.
  33  *
  34  *        For example,if we see a <TR>, we must ensure our
  35  *        document contains a table into which the row can
  36  *        be placed. This may result in "implicit containers"
  37  *        created to ensure a well-formed document.
  38  *
  39  */
  40
  41 #ifndef NS_PARSER__
  42 #define NS_PARSER__
  43
  44 #include "nsIParser.h"
  45 #include "nsDeque.h"
  46 #include "CParserContext.h"
  47 #include "nsParserCIID.h"
  48 #include "nsITokenizer.h"
  49 #include "nsHTMLTags.h"
  50 #include "nsIContentSink.h"
  51 #include "nsCOMArray.h"
  52 #include "nsCycleCollectionParticipant.h"
  53 #include "nsWeakReference.h"
  54
  55 class nsIDTD;
  56 class nsIRunnable;
  57
  58 #ifdef _MSC_VER
  59 #  pragma warning(disable : 4275)
  60 #endif
  61
  62 class nsParser final : public nsIParser,
  63                        public nsIStreamListener,
  64                        public nsSupportsWeakReference {
  65   /**
  66    * Destructor
  67    * @update  gess5/11/98
  68    */
  69   virtual ~nsParser();
  70
  71  public:
  72   /**
  73    * Called on module init
  74    */
  75   static nsresult Init();
  76
  77   /**
  78    * Called on module shutdown
  79    */
  80   static void Shutdown();
  81
  82   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  83   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsParser, nsIParser)
  84
  85   /**
  86    * default constructor
  87    * @update    gess5/11/98
  88    */
  89   nsParser();
  90
  91   /**
  92    * Select given content sink into parser for parser output
  93    * @update    gess5/11/98
  94    * @param   aSink is the new sink to be used by parser
  95    * @return  old sink, or nullptr
  96    */
  97   NS_IMETHOD_(void) SetContentSink(nsIContentSink* aSink) override;
  98
  99   /**
 100    * retrive the sink set into the parser
 101    * @update    gess5/11/98
 102    * @param   aSink is the new sink to be used by parser
 103    * @return  old sink, or nullptr
 104    */
 105   NS_IMETHOD_(nsIContentSink*) GetContentSink(void) override;
 106
 107   /**
 108    *  Call this method once you've created a parser, and want to instruct it
 109    *  about the command which caused the parser to be constructed. For example,
 110    *  this allows us to select a DTD which can do, say, view-source.
 111    *
 112    *  @update  gess 3/25/98
 113    *  @param   aCommand -- ptrs to string that contains command
 114    *  @return    nada
 115    */
 116   NS_IMETHOD_(void) GetCommand(nsCString& aCommand) override;
 117   NS_IMETHOD_(void) SetCommand(const char* aCommand) override;
 118   NS_IMETHOD_(void) SetCommand(eParserCommands aParserCommand) override;
 119
 120   /**
 121    *  Call this method once you've created a parser, and want to instruct it
 122    *  about what charset to load
 123    *
 124    *  @update  ftang 4/23/99
 125    *  @param   aCharset- the charset of a document
 126    *  @param   aCharsetSource- the source of the charset
 127    *  @param   aChannelHadCharset- ignored
 128    *  @return    nada
 129    */
 130   virtual void SetDocumentCharset(NotNull<const Encoding*> aCharset,
 131                                   int32_t aSource,
 132                                   bool aChannelHadCharset) override;
 133
 134   NotNull<const Encoding*> GetDocumentCharset(int32_t& aSource) {
 135     aSource = mCharsetSource;
 136     return mCharset;
 137   }
 138
 139   /**
 140    * Cause parser to parse input from given URL
 141    * @update    gess5/11/98
 142    * @param   aURL is a descriptor for source document
 143    * @param   aListener is a listener to forward notifications to
 144    * @return  TRUE if all went well -- FALSE otherwise
 145    */
 146   NS_IMETHOD Parse(nsIURI* aURL, nsIRequestObserver* aListener = nullptr,
 147                    void* aKey = 0,
 148                    nsDTDMode aMode = eDTDMode_autodetect) override;
 149
 150   /**
 151    * This method needs documentation
 152    */
 153   NS_IMETHOD ParseFragment(const nsAString& aSourceBuffer,
 154                            nsTArray<nsString>& aTagStack) override;
 155
 156   /**
 157    * This method gets called when the tokens have been consumed, and it's time
 158    * to build the model via the content sink.
 159    * @update    gess5/11/98
 160    * @return  YES if model building went well -- NO otherwise.
 161    */
 162   NS_IMETHOD BuildModel(void) override;
 163
 164   NS_IMETHOD ContinueInterruptedParsing() override;
 165   NS_IMETHOD_(void) BlockParser() override;
 166   NS_IMETHOD_(void) UnblockParser() override;
 167   NS_IMETHOD_(void) ContinueInterruptedParsingAsync() override;
 168   NS_IMETHOD Terminate(void) override;
 169
 170   /**
 171    * Call this to query whether the parser is enabled or not.
 172    *
 173    *  @update  vidur 4/12/99
 174    *  @return  current state
 175    */
 176   NS_IMETHOD_(bool) IsParserEnabled() override;
 177
 178   /**
 179    * Call this to query whether the parser thinks it's done with parsing.
 180    *
 181    *  @update  rickg 5/12/01
 182    *  @return  complete state
 183    */
 184   NS_IMETHOD_(bool) IsComplete() override;
 185
 186   /**
 187    *  This rather arcane method (hack) is used as a signal between the
 188    *  DTD and the parser. It allows the DTD to tell the parser that content
 189    *  that comes through (parser::parser(string)) but not consumed should
 190    *  propagate into the next string based parse call.
 191    *
 192    *  @update  gess 9/1/98
 193    *  @param   aState determines whether we propagate unused string content.
 194    *  @return  current state
 195    */
 196   void SetUnusedInput(nsString& aBuffer);
 197
 198   /**
 199    * This method gets called (automatically) during incremental parsing
 200    * @update    gess5/11/98
 201    * @return  TRUE if all went well, otherwise FALSE
 202    */
 203   virtual nsresult ResumeParse(bool allowIteration = true,
 204                                bool aIsFinalChunk = false,
 205                                bool aCanInterrupt = true);
 206
 207   //*********************************************
 208   // These methods are callback methods used by
 209   // net lib to let us know about our inputstream.
 210   //*********************************************
 211   // nsIRequestObserver methods:
 212   NS_DECL_NSIREQUESTOBSERVER
 213
 214   // nsIStreamListener methods:
 215   NS_DECL_NSISTREAMLISTENER
 216
 217   void PushContext(CParserContext& aContext);
 218   CParserContext* PopContext();
 219   CParserContext* PeekContext() { return mParserContext; }
 220
 221   /**
 222    * Get the channel associated with this parser
 223    * @update harishd,gagan 07/17/01
 224    * @param aChannel out param that will contain the result
 225    * @return NS_OK if successful
 226    */
 227   NS_IMETHOD GetChannel(nsIChannel** aChannel) override;
 228
 229   /**
 230    * Get the DTD associated with this parser
 231    * @update vidur 9/29/99
 232    * @param aDTD out param that will contain the result
 233    * @return NS_OK if successful, NS_ERROR_FAILURE for runtime error
 234    */
 235   NS_IMETHOD GetDTD(nsIDTD** aDTD) override;
 236
 237   /**
 238    * Get the nsIStreamListener for this parser
 239    */
 240   virtual nsIStreamListener* GetStreamListener() override;
 241
 242   void SetSinkCharset(NotNull<const Encoding*> aCharset);
 243
 244   /**
 245    *  Removes continue parsing events
 246    *  @update  kmcclusk 5/18/98
 247    */
 248
 249   NS_IMETHOD CancelParsingEvents() override;
 250
 251   /**
 252    * Return true.
 253    */
 254   virtual bool IsInsertionPointDefined() override;
 255
 256   /**
 257    * No-op.
 258    */
 259   void IncrementScriptNestingLevel() final;
 260
 261   /**
 262    * No-op.
 263    */
 264   void DecrementScriptNestingLevel() final;
 265
 266   bool HasNonzeroScriptNestingLevel() const final;
 267
 268   /**
 269    * No-op.
 270    */
 271   virtual void MarkAsNotScriptCreated(const char* aCommand) override;
 272
 273   /**
 274    * Always false.
 275    */
 276   virtual bool IsScriptCreated() override;
 277
 278   /**
 279    *  Set to parser state to indicate whether parsing tokens can be interrupted
 280    *  @param aCanInterrupt true if parser can be interrupted, false if it can
 281    *                       not be interrupted.
 282    *  @update  kmcclusk 5/18/98
 283    */
 284   void SetCanInterrupt(bool aCanInterrupt);
 285
 286   /**
 287    * This is called when the final chunk has been
 288    * passed to the parser and the content sink has
 289    * interrupted token processing. It schedules
 290    * a ParserContinue PL_Event which will ask the parser
 291    * to HandleParserContinueEvent when it is handled.
 292    * @update    kmcclusk6/1/2001
 293    */
 294   nsresult PostContinueEvent();
 295
 296   /**
 297    *  Fired when the continue parse event is triggered.
 298    *  @update  kmcclusk 5/18/98
 299    */
 300   void HandleParserContinueEvent(class nsParserContinueEvent*);
 301
 302   virtual void Reset() override {
 303     Cleanup();
 304     Initialize();
 305   }
 306
 307   bool IsScriptExecuting() { return mSink && mSink->IsScriptExecuting(); }
 308
 309   bool IsOkToProcessNetworkData() {
 310     return !IsScriptExecuting() && !mProcessingNetworkData;
 311   }
 312
 313  protected:
 314   void Initialize(bool aConstructor = false);
 315   void Cleanup();
 316
 317   /**
 318    *
 319    * @update    gess5/18/98
 320    * @param
 321    * @return
 322    */
 323   nsresult WillBuildModel(nsString& aFilename);
 324
 325   /**
 326    *
 327    * @update    gess5/18/98
 328    * @param
 329    * @return
 330    */
 331   nsresult DidBuildModel(nsresult anErrorCode);
 332
 333  private:
 334   /*******************************************
 335     These are the tokenization methods...
 336    *******************************************/
 337
 338   /**
 339    *  Part of the code sandwich, this gets called right before
 340    *  the tokenization process begins. The main reason for
 341    *  this call is to allow the delegate to do initialization.
 342    *
 343    *  @update  gess 3/25/98
 344    *  @param
 345    *  @return  TRUE if it's ok to proceed
 346    */
 347   bool WillTokenize(bool aIsFinalChunk = false);
 348
 349   /**
 350    *  This is the primary control routine. It iteratively
 351    *  consumes tokens until an error occurs or you run out
 352    *  of data.
 353    *
 354    *  @update  gess 3/25/98
 355    *  @return  error code
 356    */
 357   nsresult Tokenize(bool aIsFinalChunk = false);
 358
 359   /**
 360    * Pushes XML fragment parsing data to expat without an input stream.
 361    */
 362   nsresult Parse(const nsAString& aSourceBuffer, void* aKey, bool aLastCall);
 363
 364  protected:
 365   //*********************************************
 366   // And now, some data members...
 367   //*********************************************
 368
 369   CParserContext* mParserContext;
 370   nsCOMPtr<nsIDTD> mDTD;
 371   nsCOMPtr<nsIRequestObserver> mObserver;
 372   nsCOMPtr<nsIContentSink> mSink;
 373   nsIRunnable* mContinueEvent;  // weak ref
 374
 375   eParserCommands mCommand;
 376   nsresult mInternalState;
 377   nsresult mStreamStatus;
 378   int32_t mCharsetSource;
 379
 380   uint16_t mFlags;
 381   uint32_t mBlocked;
 382
 383   nsString mUnusedInput;
 384   NotNull<const Encoding*> mCharset;
 385   nsCString mCommandStr;
 386
 387   bool mProcessingNetworkData;
 388   bool mIsAboutBlank;
 389 };
 390
 391 nsresult nsParserInitialize();
 392
 393 #endif