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 "nsHTMLTags.h"
  48 #include "nsIContentSink.h"
  49 #include "nsCOMArray.h"
  50 #include "nsCycleCollectionParticipant.h"
  51 #include "nsWeakReference.h"
  52 #include "mozilla/Maybe.h"
  53 #include "mozilla/UniquePtr.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 aForceAutoDetection) 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    */
 142   NS_IMETHOD Parse(nsIURI* aURL) override;
 143
 144   /**
 145    * This method gets called when you want to parse a fragment of XML surrounded
 146    * by the context |aTagStack|. It requires that the parser have been given a
 147    * fragment content sink.
 148    *
 149    * @param aSourceBuffer The XML that hasn't been parsed yet.
 150    * @param aTagStack The context of the source buffer.
 151    */
 152   nsresult ParseFragment(const nsAString& aSourceBuffer,
 153                          nsTArray<nsString>& aTagStack);
 154
 155   NS_IMETHOD ContinueInterruptedParsing() override;
 156   NS_IMETHOD_(void) BlockParser() override;
 157   NS_IMETHOD_(void) UnblockParser() override;
 158   NS_IMETHOD_(void) ContinueInterruptedParsingAsync() override;
 159   NS_IMETHOD Terminate(void) override;
 160
 161   /**
 162    * Call this to query whether the parser is enabled or not.
 163    *
 164    *  @update  vidur 4/12/99
 165    *  @return  current state
 166    */
 167   NS_IMETHOD_(bool) IsParserEnabled() override;
 168
 169   /**
 170    * Call this to query whether the parser thinks it's done with parsing.
 171    *
 172    *  @update  rickg 5/12/01
 173    *  @return  complete state
 174    */
 175   NS_IMETHOD_(bool) IsComplete() override;
 176
 177   /**
 178    * This method gets called (automatically) during incremental parsing
 179    * @update    gess5/11/98
 180    * @return  TRUE if all went well, otherwise FALSE
 181    */
 182   virtual nsresult ResumeParse(bool allowIteration = true,
 183                                bool aIsFinalChunk = false,
 184                                bool aCanInterrupt = true);
 185
 186   //*********************************************
 187   // These methods are callback methods used by
 188   // net lib to let us know about our inputstream.
 189   //*********************************************
 190   // nsIRequestObserver methods:
 191   NS_DECL_NSIREQUESTOBSERVER
 192
 193   // nsIStreamListener methods:
 194   NS_DECL_NSISTREAMLISTENER
 195
 196   /**
 197    * Get the nsIStreamListener for this parser
 198    */
 199   virtual nsIStreamListener* GetStreamListener() override;
 200
 201   void SetSinkCharset(NotNull<const Encoding*> aCharset);
 202
 203   /**
 204    * Return true.
 205    */
 206   virtual bool IsInsertionPointDefined() override;
 207
 208   /**
 209    * No-op.
 210    */
 211   void IncrementScriptNestingLevel() final;
 212
 213   /**
 214    * No-op.
 215    */
 216   void DecrementScriptNestingLevel() final;
 217
 218   bool HasNonzeroScriptNestingLevel() const final;
 219
 220   /**
 221    * Always false.
 222    */
 223   virtual bool IsScriptCreated() override;
 224
 225   /**
 226    * This is called when the final chunk has been
 227    * passed to the parser and the content sink has
 228    * interrupted token processing. It schedules
 229    * a ParserContinue PL_Event which will ask the parser
 230    * to HandleParserContinueEvent when it is handled.
 231    * @update    kmcclusk6/1/2001
 232    */
 233   nsresult PostContinueEvent();
 234
 235   /**
 236    *  Fired when the continue parse event is triggered.
 237    *  @update  kmcclusk 5/18/98
 238    */
 239   void HandleParserContinueEvent(class nsParserContinueEvent*);
 240
 241   void Reset() {
 242     Cleanup();
 243     mUnusedInput.Truncate();
 244     Initialize();
 245   }
 246
 247   bool IsScriptExecuting() { return mSink && mSink->IsScriptExecuting(); }
 248
 249   bool IsOkToProcessNetworkData() {
 250     return !IsScriptExecuting() && !mProcessingNetworkData;
 251   }
 252
 253   // Returns Nothing() if we haven't determined yet what the parser is being
 254   // used for. Else returns whether this parser is used for parsing XML.
 255   mozilla::Maybe<bool> IsForParsingXML() {
 256     if (!mParserContext || mParserContext->mDTDMode == eDTDMode_autodetect) {
 257       return mozilla::Nothing();
 258     }
 259
 260     return mozilla::Some(mParserContext->mDocType == eXML);
 261   }
 262
 263  protected:
 264   void Initialize();
 265   void Cleanup();
 266
 267   /**
 268    *
 269    * @update    gess5/18/98
 270    * @param
 271    * @return
 272    */
 273   nsresult WillBuildModel();
 274
 275   /**
 276    * Called when parsing is done.
 277    */
 278   void DidBuildModel();
 279
 280  private:
 281   /**
 282    * Pushes XML fragment parsing data to expat without an input stream.
 283    */
 284   nsresult Parse(const nsAString& aSourceBuffer, bool aLastCall);
 285
 286  protected:
 287   //*********************************************
 288   // And now, some data members...
 289   //*********************************************
 290
 291   mozilla::UniquePtr<CParserContext> mParserContext;
 292   nsCOMPtr<nsIDTD> mDTD;
 293   nsCOMPtr<nsIContentSink> mSink;
 294   nsIRunnable* mContinueEvent;  // weak ref
 295
 296   eParserCommands mCommand;
 297   nsresult mInternalState;
 298   nsresult mStreamStatus;
 299   int32_t mCharsetSource;
 300
 301   uint16_t mFlags;
 302   uint32_t mBlocked;
 303
 304   nsString mUnusedInput;
 305   NotNull<const Encoding*> mCharset;
 306   nsCString mCommandStr;
 307
 308   bool mProcessingNetworkData;
 309   bool mIsAboutBlank;
 310 };
 311
 312 #endif