diff --git a/htmlparser/src/CNavDTD.cpp b/htmlparser/src/CNavDTD.cpp
index 5689727bb709..f4fddf881d0a 100644
--- a/htmlparser/src/CNavDTD.cpp
+++ b/htmlparser/src/CNavDTD.cpp
@@ -1,30 +1,30 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
+/*                        
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
  * compliance with the NPL.  You may obtain a copy of the NPL at
  * http://www.mozilla.org/NPL/
- *
+ *                  
  * Software distributed under the NPL is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  * for the specific language governing rights and limitations under the
  * NPL.
- * 
+ *  
  * The Initial Developer of this code under the NPL is Netscape
  * Communications Corporation.  Portions created by Netscape are
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  * Reserved.
- */ 
-
-#include "nsDebug.h"
-#include "nsIDTDDebug.h" 
+ */    
+    
+#include "nsDebug.h" 
+#include "nsIDTDDebug.h"  
 #include "CNavDTD.h" 
 #include "nsHTMLTokens.h"
 #include "nsCRT.h"
 #include "nsParser.h"
+#include "nsIParser.h"
 #include "nsIHTMLContentSink.h" 
 #include "nsScanner.h"
-#include "nsParserTypes.h"
 #include "nsVoidArray.h"
 #include "nsTokenHandler.h"
 #include "nsIDTDDebug.h"
@@ -35,6 +35,7 @@
 #include "nsDTDUtils.h"
 #include "nsTagHandler.h"
 #include "nsViewSourceHTML.h"
+#include "nsHTMLTokenizer.h"
 
 #ifdef XP_PC
 #include <direct.h> //this is here for debug reasons...
@@ -45,7 +46,7 @@
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
 static NS_DEFINE_IID(kIDTDIID,      NS_IDTD_IID);
 static NS_DEFINE_IID(kClassIID,     NS_INAVHTML_DTD_IID); 
-
+ 
 //static const char* kNullURL = "Error: Null URL given";
 //static const char* kNullFilename= "Error: Null filename given";
 static const char* kNullToken = "Error: Null token given";
@@ -53,7 +54,7 @@ static const char* kInvalidTagStackPos = "Error: invalid tag stack position";
 static const char* kHTMLTextContentType = "text/html";
 static char* kVerificationDir = "c:/temp";
 static const char* kViewSourceCommand= "view-source";
-
+ 
 static nsAutoString gEmpty;
 
 static eHTMLTags gFormElementTags[]= {  
@@ -66,6 +67,7 @@ static eHTMLTags gHeadingTags[]={
   eHTMLTag_h1,  eHTMLTag_h2,  eHTMLTag_h3,  
   eHTMLTag_h4,  eHTMLTag_h5,  eHTMLTag_h6};
 
+  
 static eHTMLTags gStyleTags[]={
   eHTMLTag_a,       eHTMLTag_acronym,   eHTMLTag_b,
   eHTMLTag_bdo,     eHTMLTag_big,       eHTMLTag_blink,
@@ -78,210 +80,23 @@ static eHTMLTags gStyleTags[]={
   eHTMLTag_sub,     eHTMLTag_sup,       eHTMLTag_tt,
   eHTMLTag_u,       eHTMLTag_var};
 
-static eHTMLTags gNonContainers[]={
-  eHTMLTag_area,    eHTMLTag_base,    eHTMLTag_basefont,
-  eHTMLTag_bgsound, eHTMLTag_br,      eHTMLTag_col,     
-  eHTMLTag_embed,   eHTMLTag_frame,   eHTMLTag_img, 
-  eHTMLTag_keygen,  eHTMLTag_hr,      eHTMLTag_input,   
-  eHTMLTag_link,    eHTMLTag_isindex,
-  eHTMLTag_meta,    eHTMLTag_param,   eHTMLTag_plaintext,
-  eHTMLTag_sound,   eHTMLTag_style,   eHTMLTag_spacer,  
-  eHTMLTag_wbr,   
-  eHTMLTag_newline, eHTMLTag_text,    eHTMLTag_whitespace,
-  eHTMLTag_unknown, eHTMLTag_xmp};
 
-static eHTMLTags gTableTags[]={ 
+static eHTMLTags gTableChildTags[]={ 
   eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  eHTMLTag_tbody,   
   eHTMLTag_tfoot,   eHTMLTag_tr,  eHTMLTag_thead,     eHTMLTag_td};
   
 static eHTMLTags gWhitespaceTags[]={
   eHTMLTag_newline, eHTMLTag_whitespace};
 
+static eHTMLTags gHeadChildTags[]={ 
+  eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  eHTMLTag_tbody,   
+  eHTMLTag_tfoot,   eHTMLTag_tr,  eHTMLTag_thead,     eHTMLTag_td};
 
-static eHTMLTags gBlockParentTags []={ 
-  eHTMLTag_applet,    eHTMLTag_basefont,    eHTMLTag_blockquote,
-  eHTMLTag_body,      eHTMLTag_center,      eHTMLTag_dd,    
-  eHTMLTag_div,       eHTMLTag_embed,       eHTMLTag_fieldset,
-  eHTMLTag_form,      eHTMLTag_iframe,      eHTMLTag_layer,
-  eHTMLTag_li,        eHTMLTag_listing,     eHTMLTag_multicol,
-  eHTMLTag_noembed,   eHTMLTag_noframes,    eHTMLTag_nolayer,
-  eHTMLTag_noscript,  eHTMLTag_object,      eHTMLTag_plaintext,
-  eHTMLTag_pre,       eHTMLTag_td,          eHTMLTag_th,
-  eHTMLTag_ul,
-  eHTMLTag_xmp,
-};
-
-static eHTMLTags gBlockChildTags []={ 
-  eHTMLTag_a,         eHTMLTag_abbr,        eHTMLTag_acronym,   eHTMLTag_address,     eHTMLTag_applet,
-  eHTMLTag_b,         eHTMLTag_basefont,    eHTMLTag_bdo,       eHTMLTag_bgsound,     eHTMLTag_big,
-  eHTMLTag_blink,     eHTMLTag_blockquote,  eHTMLTag_br,        eHTMLTag_button,
-  eHTMLTag_center,    eHTMLTag_cite,        eHTMLTag_code,      
-  eHTMLTag_del,       eHTMLTag_dfn,         eHTMLTag_dir,       eHTMLTag_div,       eHTMLTag_dl,
-  eHTMLTag_em,        eHTMLTag_embed,
-  eHTMLTag_fieldset,  eHTMLTag_font,        eHTMLTag_form,
-  eHTMLTag_h1,        eHTMLTag_h2,          eHTMLTag_h3,
-  eHTMLTag_h4,        eHTMLTag_h5,          eHTMLTag_h6,
-  eHTMLTag_hr,      
-
-  eHTMLTag_i,         eHTMLTag_iframe,      eHTMLTag_ilayer,    eHTMLTag_img,         
-  eHTMLTag_ins,       eHTMLTag_isindex,     eHTMLTag_input,
-
-  eHTMLTag_kbd,     
-
-  eHTMLTag_label,     eHTMLTag_layer,       eHTMLTag_listing,
-
-  eHTMLTag_map,       /*eHTMLTag_marque,*/  eHTMLTag_menu,      eHTMLTag_multicol,
-  eHTMLTag_nobr,      eHTMLTag_noembed,     eHTMLTag_noframes,  eHTMLTag_nolayer,   eHTMLTag_noscript,
-
-  eHTMLTag_object,    eHTMLTag_ol,
-  eHTMLTag_p,         eHTMLTag_plaintext,   eHTMLTag_pre,         
-  eHTMLTag_q,
-  eHTMLTag_s,         eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    eHTMLTag_small,
-  eHTMLTag_sound,     eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,
-  eHTMLTag_sub,       eHTMLTag_sup,
-
-  eHTMLTag_table,     eHTMLTag_textarea,    eHTMLTag_tt,
-  eHTMLTag_u,         eHTMLTag_ul,          eHTMLTag_userdefined,
-  eHTMLTag_var,       eHTMLTag_wbr,         eHTMLTag_xmp,
-  
-    //a few special cases...
-  eHTMLTag_newline,
-  eHTMLTag_whitespace,
+static eHTMLTags gNonPropagatedTags[]={
+  eHTMLTag_head,  eHTMLTag_html,  eHTMLTag_body};
 
 
-};  
-
-static eHTMLTags gInlineParentTags []={ 
-  eHTMLTag_a,         eHTMLTag_abbr,        eHTMLTag_address,
-  eHTMLTag_b,         eHTMLTag_bdo,         eHTMLTag_big,
-  eHTMLTag_blink,     eHTMLTag_button,      eHTMLTag_caption,
-  eHTMLTag_cite,      eHTMLTag_code,        eHTMLTag_dfn,
-  eHTMLTag_dt,        eHTMLTag_em,          eHTMLTag_font,
-  eHTMLTag_h1,        eHTMLTag_h2,          eHTMLTag_h3,      
-  eHTMLTag_h4,        eHTMLTag_h5,          eHTMLTag_h6,      
-  eHTMLTag_i,         eHTMLTag_ilayer,      eHTMLTag_kbd,
-  eHTMLTag_label,     eHTMLTag_legend,      /*eHTMLTag_marquee,*/
-  eHTMLTag_nobr,      eHTMLTag_ol,          eHTMLTag_p,           
-  eHTMLTag_q,
-  eHTMLTag_s,         eHTMLTag_samp,        eHTMLTag_small,
-  eHTMLTag_span,      eHTMLTag_strike,      eHTMLTag_strong,
-  eHTMLTag_sub,       eHTMLTag_sup,         
-  eHTMLTag_td,        eHTMLTag_th,          eHTMLTag_tt,
-  eHTMLTag_u,         eHTMLTag_ul,          eHTMLTag_var
-};
-
-static eHTMLTags gInlineChildTags []={ 
-  eHTMLTag_a,       eHTMLTag_abbr,        eHTMLTag_acronym,   eHTMLTag_applet,
-  eHTMLTag_b,       eHTMLTag_bdo,         eHTMLTag_bgsound,   eHTMLTag_big,       eHTMLTag_blink,
-  eHTMLTag_br,      eHTMLTag_button,
-
-  eHTMLTag_cite,    eHTMLTag_code,
-  eHTMLTag_dfn,
-  eHTMLTag_em,      eHTMLTag_embed,
-  eHTMLTag_font,
-
-  eHTMLTag_form, //Added this for backward compatibility...
-
-  eHTMLTag_i,       eHTMLTag_iframe,      eHTMLTag_ilayer,    eHTMLTag_img,       eHTMLTag_input,
-  eHTMLTag_kbd,     
-  eHTMLTag_label,   
-  
-  eHTMLTag_layer, //Added this for backward compatibility...
-
-  
-  eHTMLTag_li,
-  eHTMLTag_map,
-  eHTMLTag_nobr,
-  eHTMLTag_object,
-  eHTMLTag_p,
-  eHTMLTag_pre,
-  eHTMLTag_q,
-  eHTMLTag_s,       eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    eHTMLTag_small,
-  eHTMLTag_sound,   eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,
-  eHTMLTag_sub,     eHTMLTag_sup,
-
-  eHTMLTag_table, //Added this for backward compatibility...
-
-  eHTMLTag_textarea,eHTMLTag_tt,
-  eHTMLTag_u,       eHTMLTag_userdefined,
-  eHTMLTag_var,
-  eHTMLTag_wbr,
-  eHTMLTag_text,
-  eHTMLTag_newline,
-  eHTMLTag_whitespace,
-};
-
-//This is a convenience set, which combines block AND inline child lists...
-static eHTMLTags gBlockAndInlineChildTags []={ 
-  eHTMLTag_a,         eHTMLTag_abbr,        eHTMLTag_acronym,   eHTMLTag_address,     eHTMLTag_applet,
-  eHTMLTag_b,         eHTMLTag_basefont,    eHTMLTag_bdo,       eHTMLTag_bgsound,     eHTMLTag_big,
-  eHTMLTag_blink,     eHTMLTag_blockquote,  eHTMLTag_br,        eHTMLTag_button,
-  eHTMLTag_center,    eHTMLTag_cite,        eHTMLTag_code,      
-  eHTMLTag_dfn,       eHTMLTag_del,         eHTMLTag_dir,         eHTMLTag_div,       eHTMLTag_dl,
-  eHTMLTag_em,        eHTMLTag_embed,
-  eHTMLTag_fieldset,  eHTMLTag_font,        eHTMLTag_form,
-  eHTMLTag_h1,        eHTMLTag_h2,          eHTMLTag_h3,
-  eHTMLTag_h4,        eHTMLTag_h5,          eHTMLTag_h6,
-  eHTMLTag_hr,      
-
-  eHTMLTag_i,         eHTMLTag_iframe,      eHTMLTag_ilayer,    eHTMLTag_img,         
-  eHTMLTag_ins,       eHTMLTag_isindex,   eHTMLTag_input,
-
-  eHTMLTag_kbd,     
-
-  eHTMLTag_label,     eHTMLTag_layer,       eHTMLTag_li,        eHTMLTag_listing,
-
-  eHTMLTag_map,       /*eHTMLTag_marque,*/  eHTMLTag_menu,      eHTMLTag_multicol,
-  eHTMLTag_nobr,      eHTMLTag_noembed,     eHTMLTag_noframes,  eHTMLTag_nolayer,   eHTMLTag_noscript,
-
-  eHTMLTag_object,    eHTMLTag_ol,
-  eHTMLTag_p,         eHTMLTag_plaintext,   eHTMLTag_pre,         
-  eHTMLTag_q,
-  eHTMLTag_s,         eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    eHTMLTag_small,
-  eHTMLTag_sound,     eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,
-  eHTMLTag_sub,       eHTMLTag_sup,
-
-  eHTMLTag_table,     eHTMLTag_textarea,    
-  eHTMLTag_tt,        eHTMLTag_u,           eHTMLTag_ul,        eHTMLTag_userdefined,
-  eHTMLTag_var,       eHTMLTag_wbr,         eHTMLTag_xmp,
-  
-    //a few special cases...
-  eHTMLTag_text,
-  eHTMLTag_newline,
-  eHTMLTag_whitespace,
-};  
-
-
-static eHTMLTags gPREChildTags []={ 
-  eHTMLTag_a,       eHTMLTag_abbr,        eHTMLTag_acronym,   
-  eHTMLTag_b,       eHTMLTag_bdo,         eHTMLTag_bgsound,   
-  eHTMLTag_br,      eHTMLTag_button,
-  eHTMLTag_cite,    eHTMLTag_code,        eHTMLTag_dfn,
-  eHTMLTag_em,      eHTMLTag_embed,
-  eHTMLTag_i,       eHTMLTag_ilayer,      eHTMLTag_input,
-  eHTMLTag_kbd,     eHTMLTag_label,       eHTMLTag_li,
-  eHTMLTag_map,     eHTMLTag_q,
-  eHTMLTag_s,       eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    
-  eHTMLTag_sound,   eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,  
-  eHTMLTag_textarea,eHTMLTag_tt,
-  eHTMLTag_u,       eHTMLTag_var,         eHTMLTag_wbr,
-  eHTMLTag_text,    eHTMLTag_newline,     eHTMLTag_whitespace,
-};
-
-
-static eHTMLTags gHeadChildTags []={ 
-  eHTMLTag_base,    eHTMLTag_bgsound,     eHTMLTag_isindex,
-  eHTMLTag_link,    eHTMLTag_meta,        /*eHTMLTag_nextid,*/
-  eHTMLTag_script,  eHTMLTag_sound,       eHTMLTag_style,
-  eHTMLTag_title
-};
-
-static eHTMLTags gFormChildTags []={ 
-  eHTMLTag_button,  eHTMLTag_input,   eHTMLTag_keygen,
-  eHTMLTag_label,   eHTMLTag_select,  eHTMLTag_textarea     
-};
-
-static CTokenRecycler gTokenRecycler;
+#include "nsElementTable.h"
 
 
 /***************************************************************
@@ -440,7 +255,7 @@ PRInt32 NavDispatchTokenHandler(CToken* aToken,nsIDTD* aDTD) {
   if(aDTD) {
     switch(theType) {
       case eToken_start:
-      case eToken_whitespace:
+      case eToken_whitespace: 
       case eToken_newline:
       case eToken_text:
         result=theDTD->HandleStartToken(aToken); break;
@@ -491,21 +306,19 @@ void CNavDTD::InitializeDefaultTokenHandlers() {
 }
 
 
-static CTokenDeallocator gTokenKiller;
-
 /**
  *  Default constructor
- *  
+ *   
  *  @update  gess 4/9/98
  *  @param   
  *  @return  
  */
-CNavDTD::CNavDTD() : nsIDTD(), mTokenDeque(gTokenKiller)  {
+CNavDTD::CNavDTD() : nsIDTD(){
   NS_INIT_REFCNT();
-  mSink = 0;
-  mParser=0;
-  mDTDDebug=0;
-  mLineNumber=1;
+  mSink = 0; 
+  mParser=0;       
+  mDTDDebug=0;   
+  mLineNumber=1;  
   mHasOpenBody=PR_FALSE;
   nsCRT::zero(mTokenHandlers,sizeof(mTokenHandlers));
   mHasOpenForm=PR_FALSE;
@@ -516,7 +329,20 @@ CNavDTD::CNavDTD() : nsIDTD(), mTokenDeque(gTokenKiller)  {
   mBodyContext=new nsDTDContext();
   mFormContext=0;
   mMapContext=0;
-//  DebugDumpContainmentRules(*this,"c:/temp/DTDRules1.out","New CNavDTD Containment Rules");
+  mTokenizer=0;
+
+//  DebugDumpContainmentRules2(*this,"c:/temp/DTDRules.new","New CNavDTD Containment Rules");
+}
+
+
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CNavDTD::GetMostDerivedIID(void)const {
+  return kClassIID;
 }
 
 /**
@@ -544,18 +370,6 @@ nsresult CNavDTD::CreateNewInstance(nsIDTD** aInstancePtrResult){
   return NS_NewNavHTMLDTD(aInstancePtrResult);
 }
 
-
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* CNavDTD::GetTokenRecycler(void){
-//  return 0;
-  return &gTokenRecycler;
-}
-
 /**
  * Called by the parser to initiate dtd verification of the
  * internal context stack.
@@ -575,7 +389,7 @@ PRBool CNavDTD::Verify(nsString& aURLRef,nsIParser* aParser){
     else mDTDDebug->SetVerificationDirectory(kVerificationDir);
   }
   if(mDTDDebug) {
-    mDTDDebug->Verify(this,aParser,mBodyContext->mElements.mCount,mBodyContext->mElements.mTags,aURLRef);
+    // mDTDDebug->Verify(this,aParser,mBodyContext->GetCount(),mBodyContext->mTags,aURLRef);
   }
   return result;
 }
@@ -632,6 +446,7 @@ nsresult CNavDTD::WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParse
     mSink=(nsIHTMLContentSink*)aParser->GetContentSink();
     if((aNotifySink) && (mSink)) {
       mHasOpenBody=PR_FALSE;
+      mHadBodyOrFrameset=PR_FALSE;
       mLineNumber=1;
       result = mSink->WillBuildModel();
     }
@@ -639,16 +454,49 @@ nsresult CNavDTD::WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParse
   return result;
 }
 
+/**
+  * This is called when it's time to read as many tokens from the tokenizer
+  * as you can. Not all tokens may make sense, so you may not be able to
+  * read them all (until more come in later).
+  *
+  * @update	gess5/18/98
+  * @param	aParser is the parser object that's driving this process
+  * @return	error code (almost always 0)
+  */
+nsresult CNavDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+
+  nsHTMLTokenizer*  theTokenizer=(nsHTMLTokenizer*)GetTokenizer();
+  nsITokenRecycler* theRecycler=GetTokenRecycler();
+  if(theTokenizer) {
+    while(NS_OK==result){
+      CToken* theToken=theTokenizer->PopToken();
+      if(theToken) {
+        result=HandleToken(theToken,aParser);
+        if(NS_SUCCEEDED(result)) {
+          theRecycler->RecycleToken(theToken);
+        }
+        else if(NS_ERROR_HTMLPARSER_BLOCK!=result){
+          theTokenizer->PushTokenFront(theToken);
+        }
+        // theRootDTD->Verify(kEmptyString,aParser);
+      }
+      else break;
+    }
+  }
+  return result;
+}
+
 /**
  * 
  * @update  gess5/18/98
  * @param 
  * @return
  */
-nsresult CNavDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+nsresult CNavDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result= NS_OK;
 
-  if((kNoError==anErrorCode) && (!mHasOpenBody)) {
+  if((NS_OK==anErrorCode) && (!mHadBodyOrFrameset)) {
     CStartToken theToken(eHTMLTag_body);  //open the body container...
     result=HandleStartToken(&theToken);
   }
@@ -657,7 +505,7 @@ nsresult CNavDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser
     mSink=(nsIHTMLContentSink*)aParser->GetContentSink();
 
     if(aNotifySink && mSink){
-      if((kNoError==anErrorCode) && (mBodyContext->mElements.mCount>0)) {
+      if((NS_OK==anErrorCode) && (mBodyContext->GetCount()>0)) {
         result = CloseContainersTo(0,eHTMLTag_unknown,PR_FALSE);
       }
 
@@ -695,8 +543,9 @@ nsresult CNavDTD::HandleToken(CToken* aToken,nsIParser* aParser){
       mParser=(nsParser*)aParser;
       mSink=(nsIHTMLContentSink*)mParser->GetContentSink();
       result=(*theHandler)(theToken,this);
-      if (mDTDDebug)
-         mDTDDebug->Verify(this, mParser, mBodyContext->mElements.mCount, mBodyContext->mElements.mTags, mFilename);
+      if (mDTDDebug) {
+         //mDTDDebug->Verify(this, mParser, mBodyContext->GetCount(), mBodyContext->mTags, mFilename);
+      }
     }
 
   }//if
@@ -734,12 +583,18 @@ nsresult CNavDTD::ReleaseTokenPump(nsITagHandler* aHandler){
  * @param   aChildTag is the tag itself.
  * @return  status
  */
-PRInt32 CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
-  PRInt32 result=kNoError;
-  CToken* theNextToken=mParser->PeekToken();
+nsresult CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
+  nsresult result=NS_OK;
 
+  CToken* theNextToken=mTokenizer->PeekToken();
   if(theNextToken){
     switch(aChildTag){
+      case eHTMLTag_body:
+      case eHTMLTag_frameset:
+        mHadBodyOrFrameset=PR_TRUE;
+        break;
+
+
       case eHTMLTag_pre:
       case eHTMLTag_listing:
         {
@@ -751,7 +606,7 @@ PRInt32 CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
                 case eHTMLTag_pre:
                 case eHTMLTag_listing:
                     //we skip the first newline token inside PRE and LISTING
-                  mParser->PopToken();
+                  mTokenizer->PopToken();
                   break;
                 default:
                   break;
@@ -775,23 +630,75 @@ PRInt32 CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
         break;
       default:
         break;
-    }//switch
+    }//switch 
   }
   return result;
-}
-
-
-void CompareResults(PRBool canContain,eHTMLTags aParentTag,eHTMLTags aChildTag){
-/*
-  PRBool theNewResult=CanContainEx(aParentTag,aChildTag);
-  if(canContain!=theNewResult){
-    printf("%s(child:%i,parent:%i)\n","can contain!=can containex",aChildTag,aParentTag);
-  }
-*/
-}
-
-
+} 
+ 
 /**
+ *  Determine whether the given tag is open anywhere
+ *  in our context stack.
+ *  
+ *  @update  gess 4/2/98
+ *  @param   eHTMLTags tag to be searched for in stack
+ *  @return  topmost index of tag on stack
+ */
+PRInt32 GetTopmostIndexOf(eHTMLTags aTag,nsTagStack& aTagStack) {
+  int i=0;
+  for(i=aTagStack.mCount-1;i>=0;i--){
+    if(aTagStack.mTags[i]==aTag)
+      return i;
+  }
+  return kNotFound;
+}
+
+/** 
+ *  This method is called to determine whether or not a START tag
+ *  can be autoclosed. This means that based on the current
+ *  context, the stack should be closed to the nearest matching
+ *  tag.  
+ *   
+ *  @param   aTag -- tag enum of child to be tested
+ *  @return  PR_TRUE if autoclosure should occur
+ */  
+eHTMLTags FindAutoCloseTargetForStartTag(eHTMLTags aCurrentTag,nsTagStack& aTagStack) {
+  int theTopIndex=aTagStack.mCount;
+  eHTMLTags aPrevTag=aTagStack.mTags[theTopIndex-1];
+ 
+  if(nsHTMLElement::IsContainer(aCurrentTag)){
+    if((aPrevTag==aCurrentTag) && (!gHTMLElements[aCurrentTag].CanSelfContain())){
+      return aCurrentTag;
+    }
+    if(nsHTMLElement::IsBlockCloser(aCurrentTag)) {
+
+      CTagList* theRootTags=gHTMLElements[aCurrentTag].GetRootTags();
+      if(theRootTags) {
+        PRInt32 theRootIndex=theRootTags->GetTopmostIndexOf(aTagStack);
+        if(theRootIndex<GetTopmostIndexOf(aCurrentTag,aTagStack)) {
+          return aCurrentTag;
+        }
+      }
+ 
+      CTagList* theCloseTags=gHTMLElements[aCurrentTag].GetAutoCloseStartTags();
+      if(theCloseTags){
+        PRInt32 thePeerIndex=theCloseTags->GetTopmostIndexOf(aTagStack);
+        if(kNotFound!=thePeerIndex){
+          if(thePeerIndex==theTopIndex-1) {
+            //the guy you can autoclose is on the top of the stack...
+            return aPrevTag;
+          } //if
+        } //if
+      }//if
+
+    } //if
+    else if(nsHTMLElement::IsInlineElement(aCurrentTag)) {
+    }//if 
+  } //if
+  return eHTMLTag_unknown;
+}
+
+    
+/** 
  *  This method gets called when a start token has been 
  *  encountered in the parse process. If the current container
  *  can contain this tag, then add it. Otherwise, you have
@@ -799,7 +706,7 @@ void CompareResults(PRBool canContain,eHTMLTags aParentTag,eHTMLTags aChildTag){
  *                  to be stored in
  *               2) close the top container, and add this to
  *                  whatever container ends up on top.
- *  
+ *   
  *  @update  gess 3/25/98
  *  @param   aToken -- next (start) token to be handled
  *  @param   aNode -- CParserNode representing this start token
@@ -809,27 +716,40 @@ nsresult CNavDTD::HandleDefaultStartToken(CToken* aToken,eHTMLTags aChildTag,nsI
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   nsresult  result=NS_OK;
-  eHTMLTags theParentTag=mBodyContext->mElements.Last();
 
-  if(RequiresAutomaticClosure(theParentTag,aChildTag)){
-    result=CloseContainersTo(aChildTag,PR_TRUE);
+    //Sick as it sounds, I have to make sure the body has been
+    //opened before other tags can be added to the content sink...
+
+  static eHTMLTags gBodyBlockers[]={eHTMLTag_body,eHTMLTag_frameset,eHTMLTag_head};
+  PRInt32 theBodyBlocker=GetTopmostIndexOf(gBodyBlockers,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown));
+  if(!theBodyBlocker) {
+    if(CanPropagate(eHTMLTag_body,aChildTag)) {
+      mHasOpenBody=PR_TRUE;
+      CStartToken theToken(eHTMLTag_body);  //open the body container...
+      result=HandleStartToken(&theToken);
+    }
+  }//if                     
+
+  eHTMLTags theParentTag=mBodyContext->Last();
+  PRBool theCanContainResult=CanContain(theParentTag,aChildTag);
+
+  eHTMLTags theTarget=FindAutoCloseTargetForStartTag(aChildTag,mBodyContext->mTags);
+  if(eHTMLTag_unknown!=theTarget){
+    result=CloseContainersTo(theTarget,PR_TRUE);
   }
 
-  PRBool theCanContainResult=CanContain(theParentTag,aChildTag);
-  CompareResults(theCanContainResult,theParentTag,aChildTag);
 
   if(PR_FALSE==theCanContainResult){
     if(CanPropagate(theParentTag,aChildTag))
       result=CreateContextStackFor(aChildTag);
     else result=kCantPropagate;
-    if(NS_OK!=result) {
+    if(NS_OK!=result) { 
       //if you're here, then the new topmost container can't contain aToken.
       //You must determine what container hierarchy you need to hold aToken,
       //and create that on the parsestack.
       result=ReduceContextStackFor(aChildTag);
 
-      PRBool theCanContainResult=CanContain(mBodyContext->mElements.Last(),aChildTag);
-      CompareResults(theCanContainResult,mBodyContext->mElements.Last(),aChildTag);
+      PRBool theCanContainResult=CanContain(mBodyContext->Last(),aChildTag);
 
       if(PR_FALSE==theCanContainResult) {
         //we unwound too far; now we have to recreate a valid context stack.
@@ -839,15 +759,17 @@ nsresult CNavDTD::HandleDefaultStartToken(CToken* aToken,eHTMLTags aChildTag,nsI
   }
 
   if(IsContainer(aChildTag)){
-    if(PR_TRUE==mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]) {
-      CloseTransientStyles(aChildTag);
+      //first, let's see if it's a style element...
+    if(!FindTagInSet(aChildTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
+        //it wasn't a style container, so open the element container...
+      if(mBodyContext->mOpenStyles) {
+        CloseTransientStyles(aChildTag);
+      }
     }
     result=OpenContainer(aNode,PR_TRUE);
   }
-  else {
-    if(PR_FALSE==mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]) {
-      OpenTransientStyles(aChildTag);
-    }
+  else {  //we're writing a leaf...
+    OpenTransientStyles(aChildTag);
     result=AddLeaf(aNode);
   }
 
@@ -870,80 +792,81 @@ nsresult CNavDTD::HandleDefaultStartToken(CToken* aToken,eHTMLTags aChildTag,nsI
  *  @param   aToken -- next (start) token to be handled
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
- */
+ */      
 nsresult CNavDTD::HandleStartToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   //Begin by gathering up attributes...
-  nsCParserNode attrNode((CHTMLToken*)aToken,mLineNumber); 
+  eHTMLTags     theChildTag=(eHTMLTags)aToken->GetTypeID();
+  nsCParserNode attrNode((CHTMLToken*)aToken,mLineNumber,GetTokenRecycler()); 
   PRInt16       attrCount=aToken->GetAttributeCount();
   nsresult      result=(0==attrCount) ? NS_OK : CollectAttributes(attrNode,attrCount);
-  eHTMLTags     theParent=mBodyContext->mElements.Last();
-  eHTMLTags     theChildTag=(eHTMLTags)aToken->GetTypeID();
+  eHTMLTags     theParent=mBodyContext->Last();
   PRInt32       theAttrCount;
-
+ 
   if(NS_OK==result) {
-      //now check to see if this token should be omitted...
+    switch(theChildTag) { 
 
-    if(PR_FALSE==CanOmit(theParent,theChildTag)) {
-  
-      switch(theChildTag) {
-
-        case eHTMLTag_title:
-          {
-            result=OpenHead(attrNode); //open the head...
-            if(NS_OK==result) {
-
-              result=CollectSkippedContent(attrNode,theAttrCount);
-              mSink->SetTitle(attrNode.GetSkippedContent());
-              result=CloseHead(attrNode); //close the head...
-            }
-          }
-          break;
-
-        case eHTMLTag_link:
-        case eHTMLTag_base:
-        case eHTMLTag_meta:
-          result=AddHeadLeaf(attrNode);
-          break;
-
-        case eHTMLTag_style:
-          {
+      case eHTMLTag_title:
+        {
+          PRBool headOpen=mHasOpenHead;
+          if(!headOpen)
             result=OpenHead(attrNode);
+          if(NS_OK==result) {
+            result=CollectSkippedContent(attrNode,theAttrCount);
+            mSink->SetTitle(attrNode.GetSkippedContent());
+            if((NS_OK==result) && (!headOpen))
+              result=CloseHead(attrNode);
+          }
+        }
+        break;
+
+      case eHTMLTag_base:
+      case eHTMLTag_link:
+      case eHTMLTag_meta:
+        result=AddHeadLeaf(attrNode);
+        break;
+
+      case eHTMLTag_style:
+        {
+          PRBool headOpen=mHasOpenHead;
+          if(!headOpen)
+            result=OpenHead(attrNode);
+          if(NS_OK==result) {
+            PRInt32 theCount;
+            CollectSkippedContent(attrNode,theCount);
             if(NS_OK==result) {
-              PRInt32 theCount;
-              CollectSkippedContent(attrNode,theCount);
-              if(NS_OK==result) {
-                result=AddLeaf(attrNode);
-                // XXX If the return value tells us to block, go
-                // ahead and close the tag out anyway, since its
-                // contents will be consumed.
-                if (NS_SUCCEEDED(result)) {
-                  nsresult rv = CloseHead(attrNode);
-                  // XXX Only send along a failure. If the close 
-                  // succeeded we still may need to indicate that the
-                  // parser has blocked (i.e. return the result of
-                  // the AddLeaf.
-                  if (rv != NS_OK) {
-                    result = rv;
-                  }
+              result=AddLeaf(attrNode);
+              // XXX If the return value tells us to block, go
+              // ahead and close the tag out anyway, since its
+              // contents will be consumed.
+              if (NS_SUCCEEDED(result)) {
+                nsresult rv = CloseHead(attrNode);
+                // XXX Only send along a failure. If the close 
+                // succeeded we still may need to indicate that the
+                // parser has blocked (i.e. return the result of
+                // the AddLeaf.
+                if (rv != NS_OK) {
+                  result = rv;
                 }
               }
             }
-          }
-          break;
+          } 
+        }
+        break;
 
-        case eHTMLTag_area:
-          if (mHasOpenMap) {
-            result = mSink->AddLeaf(attrNode);
-          }
-          break;
+      case eHTMLTag_area:
+        if (mHasOpenMap) {
+          result = mSink->AddLeaf(attrNode);
+        }
+        break;
 
-        default:
+      default:
+        if(PR_FALSE==CanOmit(theParent,theChildTag)) {
           result=HandleDefaultStartToken(aToken,theChildTag,attrNode);
-          break;
-      } //switch
-    } //if
+        }
+        break;
+    } //switch
   } //if
 
   if(eHTMLTag_newline==theChildTag)
@@ -953,8 +876,6 @@ nsresult CNavDTD::HandleStartToken(CToken* aToken) {
 }
 
 
-
-
 /**
  *  This method gets called when an end token has been 
  *  encountered in the parse process. If the end tag matches
@@ -974,9 +895,9 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
   nsresult    result=NS_OK;
   CEndToken*  et = (CEndToken*)(aToken);
   eHTMLTags   tokenTagType=(eHTMLTags)et->GetTypeID();
+  
 
-
-  // Here's the hacky part:
+  // Here's the hacky part: 
   // Because we're trying to be backward compatible with Nav4/5, 
   // we have to handle explicit styles the way it does. That means
   // that we keep an internal style stack.When an EndToken occurs, 
@@ -986,7 +907,7 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
 
   //now check to see if this token should be omitted, or 
   //if it's gated from closing by the presence of another tag.
-  if(PR_TRUE==CanOmitEndTag(mBodyContext->mElements.Last(),tokenTagType)) {
+  if(PR_TRUE==CanOmitEndTag(mBodyContext->Last(),tokenTagType)) {
     UpdateStyleStackForCloseTag(tokenTagType,tokenTagType);
     return result;
   }
@@ -999,16 +920,12 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
     case eHTMLTag_meta:
     case eHTMLTag_textarea:
     case eHTMLTag_title:
-    case eHTMLTag_head:
     case eHTMLTag_script:
       break;
 
     case eHTMLTag_map:
     case eHTMLTag_form:
-      {
-        nsCParserNode aNode((CHTMLToken*)aToken,mLineNumber);
-        result=CloseContainer(aNode,tokenTagType,PR_FALSE);
-      }
+      result=CloseContainer(theNode,tokenTagType,PR_FALSE);
       break;
 
     case eHTMLTag_td:
@@ -1017,7 +934,7 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
       // Empty the transient style stack (we just closed any extra
       // ones off so it's safe to do it now) because they don't carry
       // forward across table cell boundaries.
-      mBodyContext->mStyles->mCount=0;
+      //mBodyContext->mStyles->mCount=0;
       break;
 
     default:
@@ -1044,7 +961,7 @@ nsresult CNavDTD::HandleEntityToken(CToken* aToken) {
   CEntityToken* et = (CEntityToken*)(aToken);
   nsresult      result=NS_OK;
 
-  if(PR_FALSE==CanOmit(mBodyContext->mElements.Last(),eHTMLTag_entity)) {
+  if(PR_FALSE==CanOmit(mBodyContext->Last(),eHTMLTag_entity)) {
     nsCParserNode aNode((CHTMLToken*)aToken,mLineNumber);
     result=AddLeaf(aNode);
   }
@@ -1106,7 +1023,7 @@ nsresult CNavDTD::HandleAttributeToken(CToken* aToken) {
 
   return NS_OK;
 }
-
+ 
 /**
  *  This method gets called when a script token has been 
  *  encountered in the parse process. 
@@ -1176,20 +1093,22 @@ nsresult CNavDTD::HandleProcessingInstructionToken(CToken* aToken){
  * @param   aCount is the # of attributes you're expecting
  * @return error code (should be 0)
  */
-PRInt32 CNavDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
+nsresult CNavDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
   int attr=0;
-  for(attr=0;attr<aCount;attr++){
-    CToken* theToken=mParser->PeekToken();
-    if(theToken)  {
-      eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
-      if(eToken_attribute==theType){
-        mParser->PopToken(); //pop it for real...
+
+  nsresult result=NS_OK;
+  if(aCount<=mTokenizer->GetCount()) {
+    for(attr=0;attr<aCount;attr++){
+      CToken* theToken=mTokenizer->PopToken();
+      if(theToken)  {
         aNode.AddAttribute(theToken);
-      } 
+      }
     }
-    else return kInterrupted;
   }
-  return kNoError;
+  else {
+    result=kEOF;
+  }
+  return result;
 }
 
 
@@ -1201,22 +1120,22 @@ PRInt32 CNavDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
  * @param   holds the number of skipped content elements encountered
  * @return  Error condition.
  */
-PRInt32 CNavDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
-  PRInt32         result=kNoError;
-  eHTMLTokenTypes theType;
-  CToken*         theToken;
+nsresult CNavDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
+  nsresult result=NS_OK;
+  eHTMLTokenTypes theType=eToken_unknown;
   aCount=0;
-  do{
-    theToken=mParser->PeekToken();
-    if(theToken) {
-      theType=eHTMLTokenTypes(theToken->GetTokenType());
-      if(eToken_skippedcontent==theType) {
-        mParser->PopToken();
-        aNode.SetSkippedContent(theToken);
-        aCount++;
-      } 
-    }
-  } while(theToken && (eToken_skippedcontent==theType));
+
+  CToken* theToken=mTokenizer->PopToken();
+  if(theToken) {
+    theType=eHTMLTokenTypes(theToken->GetTokenType());
+    if(eToken_skippedcontent==theType) {
+      aNode.SetSkippedContent(theToken);
+      aCount++;
+    } 
+  }
+  else {
+    result=kEOF;
+  }
   return result;
 }
 
@@ -1294,14 +1213,14 @@ PRBool CNavDTD::CanContainStyles(eHTMLTags aParent) const {
       result=PR_FALSE; break;
     default:
       break;
-  }
-  return result;
-}
-
+  }   
+  return result; 
+}      
+       
  /***********************************************************************************
    The preceeding tables determine the set of elements each tag can contain...
   ***********************************************************************************/
-
+  
 /**
  *  This method is called to determine whether or not a tag
  *  of one type can contain a tag of another type.
@@ -1312,426 +1231,13 @@ PRBool CNavDTD::CanContainStyles(eHTMLTags aParent) const {
  *  @return  PR_TRUE if parent can contain child
  */
 PRBool CNavDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const {
-
-  PRBool result=PR_FALSE;
-  if((!IsContainer(aParent)) && (eHTMLTag_unknown!=aParent))
-    return result;
-
- 
-    /***************************************************************************
-     * Handle form elements here. Why? Because as long as a form is open, 
-     * almost any form element is allowed. (Except <option> which must have a 
-     * <select> or <optgroup> as a parent. and <optgroup> which must have a
-     * <select> as a parent) Handling forms here means I don't have to do 
-     * special case form handling in every case statement below.
-     *
-     * Note: ANYONE can contain a form element so long as a form is open.
-     ***************************************************************************/
-  if(FindTagInSet(aChild,gFormElementTags,sizeof(gFormElementTags)/sizeof(eHTMLTag_unknown))) {
-    if(HasOpenContainer(eHTMLTag_form)) {
-      switch((eHTMLTags)aParent) {
-        case eHTMLTag_select:
-          result=PRBool(eHTMLTag_option==aChild || eHTMLTag_optgroup==aChild);
-          break;
-	case eHTMLTag_optgroup:
-	  result=PRBool(eHTMLTag_option==aChild);
-	  break;
-        case eHTMLTag_option:
-          result=PR_FALSE;
-          break;
-        default:
-          result=PR_TRUE;
-          break;
-      } //switch
+  if(mHasOpenForm) {
+    if(FindTagInSet(aChild,gFormElementTags,sizeof(gFormElementTags)/sizeof(eHTMLTag_unknown))) {
+      return PR_TRUE;
     }//if
-    return result;
-  }
-
-  if((aParent) && (FindTagInSet(aParent,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown)))) {
-    if(eHTMLTag_li == aChild) {
-      //This code was added to enforce the rule that listitems
-      //autoclose prior listitems.  Stylistic tags (including <A>)
-      //that get in the way are simply out of luck.
-      result=PR_FALSE;
-    }
-    else
-      result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-  }
-  else {
-    switch((eHTMLTags)aParent) {
-
-      case eHTMLTag_abbr:
-        if(aParent!=aChild)
-          result=FindTagInSet(aChild,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_blockquote:
-      case eHTMLTag_body:
-      case eHTMLTag_ilayer:
-      case eHTMLTag_layer:
-        if(eHTMLTag_userdefined==aChild)
-          result=PR_TRUE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-      break;
-
-      case eHTMLTag_button:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_caption,eHTMLTag_legend};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-          if(PR_FALSE==result)
-            result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_caption:    case eHTMLTag_center:
-      case eHTMLTag_dir:
-      case eHTMLTag_div:        case eHTMLTag_form:
-      case eHTMLTag_label:      case eHTMLTag_legend:
-      case eHTMLTag_menu:       case eHTMLTag_noscript:
-      case eHTMLTag_ol:         case eHTMLTag_ul:
-      case eHTMLTag_embed:      case eHTMLTag_noembed:
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_dd:
-        result=(eHTMLTag_dt==aChild) ? PR_FALSE: FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_colgroup:
-        result=PRBool(eHTMLTag_col==(eHTMLTags)aChild);
-        break;
-
-      case eHTMLTag_dt:
-        {
-          if(eHTMLTag_dt==aChild)
-            result=PR_TRUE;
-          else result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_dl:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_dd,eHTMLTag_dt,eHTMLTag_whitespace,
-                                     eHTMLTag_map,eHTMLTag_form,eHTMLTag_newline,eHTMLTag_p};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_fieldset:
-        if(eHTMLTag_legend==aChild)
-          result=PR_TRUE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_frameset:
-        {
-          static eHTMLTags okTags[]={ eHTMLTag_frame,     eHTMLTag_frameset,  eHTMLTag_noframes,  
-                                      eHTMLTag_newline,   eHTMLTag_whitespace};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_h1: case eHTMLTag_h2:
-      case eHTMLTag_h3: case eHTMLTag_h4:
-      case eHTMLTag_h5: case eHTMLTag_h6:
-        {
-          if(FindTagInSet(aChild,gHeadingTags,sizeof(gHeadingTags)/sizeof(eHTMLTag_unknown)))
-            result=PR_FALSE;
-          else result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_head:
-        {
-          static eHTMLTags okTags[]={
-            eHTMLTag_base,    eHTMLTag_isindex, eHTMLTag_link,  eHTMLTag_meta,
-            eHTMLTag_script,  eHTMLTag_style,   eHTMLTag_title};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_html:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_body,eHTMLTag_frameset,eHTMLTag_head,eHTMLTag_script,eHTMLTag_noscript};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_iframe:/* XXX wrong */
-        if(eHTMLTag_frame==aChild)
-          result=PR_FALSE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_li:
-        if (eHTMLTag_li == aChild) {
-          result = PR_FALSE;
-        }
-        else result=!FindTagInSet(aChild,gHeadingTags,sizeof(gHeadingTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_map:
-        {
-          static eHTMLTags okTags[] = { eHTMLTag_area,eHTMLTag_newline,eHTMLTag_whitespace};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_multicol:
-        if(aParent!=aChild) {
-          result=FindTagInSet(aChild,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_unknown));
-          if(PR_FALSE==result)
-            result=FindTagInSet(aChild,gBlockChildTags,sizeof(gBlockChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_nolayer:
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_noframes:
-        if(eHTMLTag_body==aChild)
-          result=PR_TRUE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_option:
-        //for now, allow an option to contain anything but another option/group
-        result=PRBool((eHTMLTag_option!=aChild) && (eHTMLTag_optgroup!=aChild));
-        break;
-
-      case eHTMLTag_optgroup:
-        //for now, allow an optgroup to hold any child tag
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_applet:
-      case eHTMLTag_object:
-        if(eHTMLTag_param==aChild) {
-          result=PR_TRUE;
-          break;
-        }
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_address:
-        if(eHTMLTag_p==aChild) {
-          result=PR_TRUE;
-          break;
-        }
-        //else fall through...
-
-      case eHTMLTag_p:
-      case eHTMLTag_pre:
-        result=FindTagInSet(aChild,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_script:
-        //for now, allow an optgroup to hold itself and options...
-        result=PRBool((eHTMLTag_text==aChild) || (eHTMLTag_comment==aChild));
-        break;
-
-      case eHTMLTag_table:
-        {
-          static eHTMLTags okTags[]={ 
-            eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  
-            eHTMLTag_form,    eHTMLTag_script,
-            eHTMLTag_tbody,   eHTMLTag_tfoot,  /* eHTMLTag_tr,*/  
-            eHTMLTag_thead,   eHTMLTag_map};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_tbody:
-      case eHTMLTag_tfoot:
-      case eHTMLTag_thead:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_script,eHTMLTag_tr,eHTMLTag_map,eHTMLTag_form};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_title:
-      case eHTMLTag_textarea:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_text,eHTMLTag_whitespace,eHTMLTag_newline};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_th:
-      case eHTMLTag_td:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_newline,eHTMLTag_map};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-          if(PR_FALSE==result)
-            result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_tr:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_script,eHTMLTag_td,eHTMLTag_th,eHTMLTag_form,eHTMLTag_map};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_unknown:
-        //the only thing that should ever have an unknown
-        //parent is an HTML Tag. Everything else should propagate.
-        if((eHTMLTag_userdefined==aChild) && mAllowUnknownTags)
-          result=PR_TRUE;
-        else result=PRBool(eHTMLTag_html==aChild);
-        break;
-
-      case eHTMLTag_listing:
-      case eHTMLTag_select:
-      case eHTMLTag_userdefined:
-        result=PR_TRUE; //XXX for now...
-        break;
-
-      default:
-  #ifdef NS_DEBUG
-        printf("XXX: unhandled tag %s in CanContain switch statement\n",
-               NS_EnumToTag((nsHTMLTag)aParent));
-  #endif
-        break;
-    } //switch
-  } //if
-
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 10/28/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool SpecialContainerRuleApplies(PRInt32 aParentTag,PRInt32 aChildTag) {
-  PRBool result=PR_FALSE;
-  
-  switch(aChildTag){
-    case eHTMLTag_area:
-      result=PRBool(eHTMLTag_map==aParentTag);  break;
-    case eHTMLTag_body:
-      result=PRBool(eHTMLTag_html==aParentTag); break;
-    case eHTMLTag_col:
-      result=PRBool(eHTMLTag_colgroup==aParentTag); break;
-    case eHTMLTag_del:
-    case eHTMLTag_ins:
-      result=PRBool(eHTMLTag_body==aParentTag); break;
-    case eHTMLTag_dt:
-    case eHTMLTag_dd:
-      result=PRBool(eHTMLTag_dl==aParentTag); break;
-    case eHTMLTag_frameset:
-      result=PRBool((eHTMLTag_html==aParentTag) || (eHTMLTag_frameset==aParentTag));  break;
-    case eHTMLTag_frame:
-    case eHTMLTag_noframes:
-      result=PRBool(eHTMLTag_frameset==aParentTag); break;
-    case eHTMLTag_head:
-      result=PRBool(eHTMLTag_html==aParentTag); break;
-    case eHTMLTag_legend:
-      result=PRBool(eHTMLTag_fieldset==aParentTag); break;
-    case eHTMLTag_option:
-    case eHTMLTag_optgroup:
-      result=PRBool((eHTMLTag_optgroup==aParentTag) || (eHTMLTag_select==aParentTag)); break;
-    case eHTMLTag_param:
-      result=PRBool((eHTMLTag_applet==aParentTag) || (eHTMLTag_object==aParentTag)); break;
-    case eHTMLTag_td:
-      result=PRBool(eHTMLTag_tr==aParentTag); break;
-    case eHTMLTag_text:
-      result=PRBool((eHTMLTag_option==aParentTag) || (eHTMLTag_body==aParentTag)); break;
-    case eHTMLTag_th:
-      result=PRBool(eHTMLTag_tr==aParentTag); break;
-    case eHTMLTag_tr:
-      result=PRBool((eHTMLTag_tbody==aParentTag) || 
-                    (eHTMLTag_thead==aParentTag) ||
-                    (eHTMLTag_tfoot==aParentTag)); break;
-
-    case eHTMLTag_caption:
-    case eHTMLTag_colgroup:
-    case eHTMLTag_tbody:
-    case eHTMLTag_tfoot:
-    case eHTMLTag_thead:
-      result=PRBool(eHTMLTag_table==aParentTag); break;
-    
-    default:
-      break;
-  }
-
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 10/28/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool CNavDTD::CanContainEx(PRInt32 aParentTag,PRInt32 aChildTag) const {
-
-  //first, handle the case where we have an unknown parent...
-  if(eHTMLTag_unknown==aParentTag){
-    if(eHTMLTag_html==aChildTag)
-      return PR_TRUE;
-  }
-  //next, let's see if the child can be contained by a block-level tag...
-  if(FindTagInSet(aChildTag,gBlockChildTags,sizeof(gBlockChildTags)/sizeof(eHTMLTag_body)))  {
-    if(FindTagInSet(aParentTag,gBlockParentTags,sizeof(gBlockParentTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;
-  }
-  if(FindTagInSet(aChildTag,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_body)))  {
-    if(FindTagInSet(aParentTag,gInlineParentTags,sizeof(gInlineParentTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;
-  }
-  if(FindTagInSet(aChildTag,gHeadChildTags,sizeof(gHeadChildTags)/sizeof(eHTMLTag_unknown))){
-    if(eHTMLTag_head==aParentTag)
-      return PR_TRUE;
-  }
-  if(FindTagInSet(aChildTag,gFormChildTags,sizeof(gFormChildTags)/gFormChildTags[0]))  {
-    if(HasOpenContainer(eHTMLTag_form)) 
-      return PR_TRUE;
-  }
-    //this tag is so bizarre it requires its own special handling...
-  if(aParentTag==eHTMLTag_li){
-
-    if(FindTagInSet(aChildTag,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;
-        
-    PRInt32 count=mBodyContext->mElements.mCount;
-    if(count>1){
-      eHTMLTags penultimate=mBodyContext->mElements.mTags[count-2];
-      if((eHTMLTag_ol==penultimate) || (eHTMLTag_ul==penultimate)){
-        //treat the li container as a block container...
-        if(FindTagInSet(aChildTag,gBlockChildTags,sizeof(gBlockChildTags)/sizeof(eHTMLTag_body)))
-          return PR_TRUE;
-      }
-    }
-  }
-
-  if(aParentTag==eHTMLTag_pre) {
-    //PRE is also very bizarre and deserves it own special handling...
-    if(FindTagInSet(aChildTag,gPREChildTags,sizeof(gPREChildTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;    
-  }
-
-  if(SpecialContainerRuleApplies(aParentTag,aChildTag)){
-    return PR_TRUE;
-  }
-  return PR_FALSE;
-}
-
+  }//if
+  return gHTMLElements[aParent].CanContain((eHTMLTags)aChild);
+} 
 
 /**
  *  This method is called to determine whether or not 
@@ -1743,127 +1249,28 @@ PRBool CNavDTD::CanContainEx(PRInt32 aParentTag,PRInt32 aChildTag) const {
  *  @param   aChild -- tag enum of child container
  *  @return  PR_TRUE if propagation should occur
  */
-PRBool CNavDTD::CanPropagate(eHTMLTags aParent,eHTMLTags aChild) const {
-  PRBool result=PR_TRUE;
-
-  switch(aParent) {
-    case eHTMLTag_td:
-    case eHTMLTag_th:
-      
-      {
-        result=CanContain(aParent,aChild);
-        PRBool theCanContainExResult=CanContainEx(aParent,aChild);
-        CompareResults(result,aParent,aChild);
-      }
-      break;
-
-    case eHTMLTag_table:
-      if(aParent==aChild) {
-        break;
-      }
-      //else fall through...
-
-    default:
-      if(IsContainer(aChild) && HasOpenContainer(aChild))
-        result=IsGatedFromClosing(aChild);
-      break;
-  }//switch
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 4/8/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool CNavDTD::CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const {
+PRBool CNavDTD::CanPropagate(eHTMLTags aParentTag,eHTMLTags aChildTag) const {
   PRBool result=PR_FALSE;
 
-  switch(aParent) {
-
-    case eHTMLTag_html:
-      {
-        static eHTMLTags okTags[]={eHTMLTag_head,eHTMLTag_body };
-        result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-      }
-
-    case eHTMLTag_body:
-      result=PR_TRUE; break;
-
-    case eHTMLTag_table:
-      {
-        static eHTMLTags okTags[]={
-          eHTMLTag_caption, eHTMLTag_colgroup,
-          eHTMLTag_tbody,   eHTMLTag_tfoot,
-          eHTMLTag_thead,   eHTMLTag_tr,
-          eHTMLTag_td,      eHTMLTag_th,
-          eHTMLTag_col};
-        result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-      }
-      break;
-
-    default:
-      break;
-  }
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  can be autoclosed. This means that based on the current
- *  context, the stack should be closed to the nearest matching
- *  tag.
- *  
- *  @param   aTag -- tag enum of child to be tested
- *  @return  PR_TRUE if autoclosure should occur
- */
-PRBool CNavDTD::RequiresAutomaticClosure(eHTMLTags aParentTag,eHTMLTags aChildTag) const {
-  static eHTMLTags gAutoCloseTags[]={eHTMLTag_li,eHTMLTag_td,eHTMLTag_tr,eHTMLTag_dt};
-
-  PRBool    result=PR_FALSE;
-  PRInt32   theParentIndex=kNotFound;
-
-/*
-    //force autoclosure if you have p/pre stacks....
-  if((eHTMLTag_p==aChildTag) || (eHTMLTag_pre==aChildTag)){
-    if((eHTMLTag_p==aParentTag) || (eHTMLTag_pre==aParentTag)){
-      return PR_TRUE;
-    }
-  }
-*/
-    //this little bit of code forces DT and DD to autoclose each other.
-  if(eHTMLTag_dd==aChildTag) {
-    if(eHTMLTag_dt==aParentTag)
-      return PR_TRUE;
-  }
-  else if(eHTMLTag_dt==aChildTag) {
-    if(eHTMLTag_dd==aParentTag)
-      return PR_TRUE;
-  }
-
-  /***************************************************************************************
-    How this works:
-      1. Find the nearest parent on the appropriate stack that can gate the given child.
-      2. See if another child tag that matches this one is already open.
-      3. If there is and IT'S NOT GATED then autoclose it.
-   ***************************************************************************************/
-  if(eHTMLTag_unknown!=aParentTag){
-    if(PR_TRUE==FindTagInSet(aChildTag,gAutoCloseTags,sizeof(gAutoCloseTags)/sizeof(eHTMLTag_unknown))) {
-     
-      if(PR_TRUE==HasOpenContainer(aChildTag)) {
-        if(PR_FALSE==IsGatedFromClosing(aChildTag))
+  if(IsContainer(aChildTag)){
+    if(nsHTMLElement::IsBlockParent(aParentTag) || (gHTMLElements[aParentTag].GetSpecialChildren())) {
+      while(eHTMLTag_unknown!=aChildTag) {
+        if(CanContain(aParentTag,aChildTag)){
           result=PR_TRUE;
-      }
-    }
+          break;
+        }//if
+        CTagList* theTagList=gHTMLElements[aChildTag].GetRootTags();
+        aChildTag=theTagList->mTags[0];
+      }//while
+    }//if
+  }//if
+  else if(nsHTMLElement::IsTextTag(aChildTag)){
+
   }
   return result;
 }
 
-
+ 
 /**
  *  This method gets called to determine whether a given 
  *  tag can contain newlines. Most do not.
@@ -1878,14 +1285,26 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
   if((eHTMLTag_userdefined==aParent) && mAllowUnknownTags)
     return result;
 
+  if(eHTMLTag_head==aChild) {
+    if(HasOpenContainer(eHTMLTag_body))
+      return PR_TRUE;
+  }
+
+  static eHTMLTags canSkip[]={eHTMLTag_body,eHTMLTag_html,eHTMLTag_head};
+  if(FindTagInSet(aChild,canSkip,sizeof(canSkip)/sizeof(eHTMLTag_unknown))) {
+    if(HasOpenContainer(aChild))
+      return PR_TRUE;
+  }
+
   //begin with some simple (and obvious) cases...
   switch(aParent) {
     case eHTMLTag_table:
+    case eHTMLTag_tbody:
       if((eHTMLTag_form==aChild) || (eHTMLTag_table==aChild))
         result=PR_FALSE;
       else if(FindTagInSet(aChild,gFormElementTags,sizeof(gFormElementTags)/sizeof(eHTMLTag_unknown)))
         result=!HasOpenContainer(eHTMLTag_form);
-      else result=!FindTagInSet(aChild,gTableTags,sizeof(gTableTags)/sizeof(eHTMLTag_unknown));
+      else result=!FindTagInSet(aChild,gTableChildTags,sizeof(gTableChildTags)/sizeof(eHTMLTag_unknown));
       break;
 
     case eHTMLTag_tr:
@@ -1905,13 +1324,17 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
 
     case eHTMLTag_unknown:
       {
-        static eHTMLTags skippable[]={eHTMLTag_newline,eHTMLTag_whitespace};
-        if(FindTagInSet(aChild,skippable,sizeof(skippable)/sizeof(eHTMLTag_unknown))) {
+        static eHTMLTags canSkip2[]={eHTMLTag_newline,eHTMLTag_whitespace};
+        if(FindTagInSet(aChild,canSkip2,sizeof(canSkip2)/sizeof(eHTMLTag_unknown))) {
           result=PR_TRUE;
         }
       }
       break;
 
+    case eHTMLTag_head:
+      result=!gHeadKids.Contains(aChild);
+      break;
+
     default:
 
         //ok, since no parent claimed it, test based on the child...
@@ -1922,17 +1345,10 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
           result=PR_TRUE; 
           break;
 
-        case eHTMLTag_html:
         case eHTMLTag_body:
-          result=HasOpenContainer(aChild); //don't bother if they're already open...
+          result=HasOpenContainer(eHTMLTag_frameset);
           break;
 
-          //The following line was commented out to fix bug 1166. 
-          //Effectively, this allows a button to exist anywhere in the document,
-          //and not just inside a form.
-
-        //case eHTMLTag_button:       
-
         case eHTMLTag_fieldset:
         case eHTMLTag_input:        case eHTMLTag_isindex:
         case eHTMLTag_label:        case eHTMLTag_legend:
@@ -1952,7 +1368,7 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
             case eHTMLTag_tbody:    case eHTMLTag_col:    
             case eHTMLTag_colgroup: case eHTMLTag_unknown:
             case eHTMLTag_select:   case eHTMLTag_fieldset:
-            case eHTMLTag_frameset:
+            case eHTMLTag_frameset: case eHTMLTag_dl:
               result=PR_TRUE;
             default:
               break;
@@ -1987,7 +1403,7 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
 
         default:
 
-          static eHTMLTags kNonStylizedTabletags[]={eHTMLTag_table,eHTMLTag_tr};
+          static eHTMLTags kNonStylizedTabletags[]={eHTMLTag_table,eHTMLTag_tbody,eHTMLTag_tr};
           if(FindTagInSet(aChild,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
             if(FindTagInSet(aParent,kNonStylizedTabletags,sizeof(kNonStylizedTabletags)/sizeof(eHTMLTag_unknown)))
               return PR_TRUE;
@@ -2019,6 +1435,46 @@ PRBool IsCompatibleTag(eHTMLTags aTag1,eHTMLTags aTag2) {
     result=FindTagInSet(aTag2,gHeadingTags,sizeof(gHeadingTags)/sizeof(eHTMLTag_unknown));
   }
   return result;
+} 
+  
+/**
+ *  This method is called to determine whether or not an END tag
+ *  can be autoclosed. This means that based on the current
+ *  context, the stack should be closed to the nearest matching
+ *  tag.
+ *   
+ *  @param   aTag -- tag enum of child to be tested
+ *  @return  PR_TRUE if autoclosure should occur
+ */ 
+eHTMLTags FindAutoCloseTargetForEndTag(eHTMLTags aCurrentTag,nsTagStack& aTagStack,PRInt32 aChildIndex) {
+  int theTopIndex=aTagStack.mCount;
+  eHTMLTags aPrevTag=aTagStack.mTags[theTopIndex-1];
+ 
+  if(nsHTMLElement::IsContainer(aCurrentTag)){
+    if(aPrevTag==aCurrentTag){
+      return aCurrentTag;
+    }
+    
+    if(nsHTMLElement::IsBlockCloser(aCurrentTag)) {
+      CTagList* theCloseTags=gHTMLElements[aCurrentTag].GetAutoCloseEndTags();
+      CTagList* theRootTags=gHTMLElements[aCurrentTag].GetRootTags();
+      if(theCloseTags){  
+        PRInt32 thePeerIndex=theCloseTags->GetTopmostIndexOf(aTagStack);
+        if(kNotFound!=thePeerIndex){
+          PRInt32   theRootIndex=theRootTags->GetTopmostIndexOf(aTagStack);
+          if(theRootIndex<thePeerIndex)
+            return aTagStack.mTags[thePeerIndex];
+        } //if
+      }//if
+      else if(theRootTags) {
+        //since we didn't find any close tags, see if there is an instance of aCurrentTag
+        //above the stack from the roottag.
+        PRInt32 theRootIndex=theRootTags->GetTopmostIndexOf(aTagStack);          
+        return (theRootIndex<aChildIndex) ? aCurrentTag : eHTMLTag_unknown;
+      }
+    } //if
+  } //if
+  return eHTMLTag_unknown;
 }
 
 /**
@@ -2077,14 +1533,14 @@ PRBool CNavDTD::CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild) const {
       //Otherwise, IT's OK TO FALL THROUGH HERE...
 
 
-    default:
-      if(IsGatedFromClosing(aChild))
-        result=PR_TRUE;
-      else if(IsCompatibleTag(aChild,mBodyContext->mElements.Last()))
-        result=PR_FALSE;
-      else result=(!HasOpenContainer(aChild));
+    default: 
+      {
+        PRInt32 theTagPos=GetTopmostIndexOf(aChild);
+        eHTMLTags theTarget=FindAutoCloseTargetForEndTag(aChild,mBodyContext->mTags,theTagPos);
+        result=PRBool(eHTMLTag_unknown==theTarget);
+      }
       break;
-  } //switch
+  } //switch 
   return result;
 }
 
@@ -2097,90 +1553,7 @@ PRBool CNavDTD::CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild) const {
  *  @return  PR_TRUE if given tag can contain other tags
  */
 PRBool CNavDTD::IsContainer(PRInt32 aTag) const {
-  PRBool result;
-  if((eHTMLTag_userdefined==aTag) && mAllowUnknownTags)
-    result=PR_TRUE;
-  else result=!FindTagInSet(aTag,gNonContainers,sizeof(gNonContainers)/sizeof(eHTMLTag_unknown));
-  return result;
-}
-
-
-/**
- * This method does two things: 1st, help construct
- * our own internal model of the content-stack; and
- * 2nd, pass this message on to the sink.
- * @update  gess4/6/98
- * @param   aNode -- next node to be added to model
- * @return  TRUE if ok, FALSE if error
- */
-eHTMLTags CNavDTD::GetDefaultParentTagFor(eHTMLTags aChildTag) const{
-  eHTMLTags result=eHTMLTag_unknown;
-  switch(aChildTag) {
-
-    case eHTMLTag_text:
-      result=eHTMLTag_p; break;
-
-    case eHTMLTag_html:
-      result=eHTMLTag_unknown; break;
-
-    case eHTMLTag_body:
-    case eHTMLTag_head:
-    case eHTMLTag_frameset:
-      result=eHTMLTag_html; break;
-
-      //These tags are head specific...
-    case eHTMLTag_style:
-    case eHTMLTag_meta:
-    case eHTMLTag_title:
-    case eHTMLTag_base:
-    case eHTMLTag_link:
-      result=eHTMLTag_head; break;
-
-      //These tags are table specific...
-    case eHTMLTag_caption:
-    case eHTMLTag_colgroup:
-    case eHTMLTag_tbody:
-    case eHTMLTag_tfoot:
-    case eHTMLTag_thead:
-      result=eHTMLTag_table; break;
-
-    case eHTMLTag_tr:
-      result=eHTMLTag_tbody; break;
-
-    case eHTMLTag_td:
-    case eHTMLTag_th:
-      result=eHTMLTag_tr; break;
-
-    case eHTMLTag_col:
-      result=eHTMLTag_colgroup; break;    
-
-    case eHTMLTag_dd:
-    case eHTMLTag_dt:
-      result=eHTMLTag_dl; break;    
-
-    case eHTMLTag_textarea:
-    case eHTMLTag_select:
-      result=eHTMLTag_form; break;
-
-    case eHTMLTag_option:
-      result=eHTMLTag_select; break;    
-
-      //These have to do with image maps...
-    case eHTMLTag_area:
-      result=eHTMLTag_map; break;    
-
-      //These have to do with applets...
-    case eHTMLTag_param:
-      result=eHTMLTag_applet; break;    
-
-      //These have to do with frames...
-    case eHTMLTag_frame:
-      result=eHTMLTag_frameset; break;    
-
-    default:
-      result=eHTMLTag_body; //XXX Hack! Just for now.
-      break;
-  }
+  PRBool result=nsHTMLElement::IsContainer((eHTMLTags)aTag);
   return result;
 }
 
@@ -2213,7 +1586,6 @@ PRBool CNavDTD::ForwardPropagate(nsTagStack& aStack,eHTMLTags aParentTag,eHTMLTa
     case eHTMLTag_tr:
       {  
         PRBool theCanContainResult=CanContain(eHTMLTag_td,aChildTag);
-        CompareResults(theCanContainResult,eHTMLTag_td,aChildTag);
         if(PR_TRUE==theCanContainResult) {
           aStack.Push(eHTMLTag_td);
           result=BackwardPropagate(aStack,aParentTag,eHTMLTag_td);
@@ -2248,13 +1620,13 @@ PRBool CNavDTD::BackwardPropagate(nsTagStack& aStack,eHTMLTags aParentTag,eHTMLT
   eHTMLTags theParentTag=aChildTag;
 
   do {
-    theParentTag=(eHTMLTags)GetDefaultParentTagFor(theParentTag);
+    CTagList* theRootTags=gHTMLElements[theParentTag].GetRootTags();
+    theParentTag=theRootTags->mTags[0];
     if(theParentTag!=eHTMLTag_unknown) {
       aStack.Push(theParentTag);
     }
 
     PRBool theCanContainResult=CanContain(aParentTag,theParentTag);
-    CompareResults(theCanContainResult,aParentTag,theParentTag);
 
     if(theCanContainResult) {
       //we've found a complete sequence, so push the parent...
@@ -2300,95 +1672,15 @@ PRBool CNavDTD::HasOpenContainer(eHTMLTags aContainer) const {
 PRBool CNavDTD::HasOpenContainer(const eHTMLTags aTagSet[],PRInt32 aCount) const {
 
   int theIndex; 
-  int theTopIndex=mBodyContext->mElements.mCount-1;
+  int theTopIndex=mBodyContext->GetCount()-1;
 
   for(theIndex=theTopIndex;theIndex>0;theIndex--){
-    if(FindTagInSet(mBodyContext->mElements.mTags[theIndex],aTagSet,aCount))
+    if(FindTagInSet((*mBodyContext)[theIndex],aTagSet,aCount))
       return PR_TRUE;
   }
   return PR_FALSE;
 }
 
-
-/**
- *  Call this method when you want to determine whether a
- *  given tag should be prevented (gated) from closing.
- *
- *  @update  gess 7/15/96
- *  @param   aTag the tag to be tested for autoclosure
- *  @return  TRUE if tag is gated.
- */
-PRBool CNavDTD::IsGatedFromClosing(eHTMLTags aChildTag) const {
-  PRBool  result=PR_FALSE;
-  PRInt32 tagPos=GetTopmostIndexOf(aChildTag);
-  PRInt32 theGatePos=kNotFound;
-
-  if(FindTagInSet(aChildTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
-    static eHTMLTags theGateTags[]={ 
-      eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  eHTMLTag_tbody,   
-      eHTMLTag_tfoot,   eHTMLTag_tr,  eHTMLTag_thead,     eHTMLTag_td, 
-      eHTMLTag_body};
-    theGatePos=GetTopmostIndexOf(theGateTags,sizeof(theGateTags)/sizeof(eHTMLTag_unknown));
-  }
-  else {
-    switch(aChildTag) {
-    case eHTMLTag_li:
-      {
-        static eHTMLTags theGateTags[]={eHTMLTag_ol,eHTMLTag_ul};
-        theGatePos=GetTopmostIndexOf(theGateTags,sizeof(theGateTags)/sizeof(eHTMLTag_unknown));
-      }
-      break;
-
-    case eHTMLTag_td:
-    case eHTMLTag_tr:
-      {      
-          /***************************************************************************
-           * This code may seem confusing, so let me explain it.
-           * We're trying to handle the case where a child tag may be prevented from
-           * closing a tag already on the stack. Here's a case:
-           *
-           *  <table>
-           *    <tr>
-           *      <td>
-           *        <table>
-           *          </tr>
-           *    
-           * In this case, the bottom </tr> is "gated" from closing the bottommost
-           * table.
-           *
-           * HOW THIS CODE WORKS:
-           *
-           *  This block of code compares all the members of the default parent 
-           *  hierarchy for the childtag against the open containers on our stack.
-           *  If they ever match, then the given child should be gated.
-           ***************************************************************************/
-
-        int theIndex; 
-        int theTopIndex=mBodyContext->mElements.mCount-1;
-
-        eHTMLTags theParent=GetDefaultParentTagFor(aChildTag);
-        while(eHTMLTag_unknown!=theParent) {
-          for(theIndex=theTopIndex;theIndex>tagPos;theIndex--){
-            if(mBodyContext->mElements.mTags[theIndex]==theParent){
-              theGatePos=theIndex;
-              break;
-            }
-          }
-          theParent=GetDefaultParentTagFor(theParent);
-        }
-      }
-      break;
-
-    default:
-      break;
-    }
-  }
-  if(kNotFound!=theGatePos)
-    if(kNotFound!=tagPos)
-      result=PRBool(theGatePos>tagPos);
-  return result;
-}
-
 /**
  *  This method retrieves the HTMLTag type of the topmost
  *  container on the stack.
@@ -2397,7 +1689,7 @@ PRBool CNavDTD::IsGatedFromClosing(eHTMLTags aChildTag) const {
  *  @return  tag id of topmost node in contextstack
  */
 eHTMLTags CNavDTD::GetTopNode() const {
-  return mBodyContext->mElements.Last();
+  return mBodyContext->Last();
 }
 
 /**
@@ -2409,10 +1701,10 @@ eHTMLTags CNavDTD::GetTopNode() const {
  *  @return  topmost index of tag on stack
  */
 PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTagSet[],PRInt32 aCount) const {
-  int i=0;
-  for(i=mBodyContext->mElements.mCount-1;i>=0;i--){
-    if(FindTagInSet(mBodyContext->mElements.mTags[i],aTagSet,aCount)) {
-      return i;
+  int theIndex=0;
+  for(theIndex=mBodyContext->GetCount()-1;theIndex>=0;theIndex--){
+    if(FindTagInSet((*mBodyContext)[theIndex],aTagSet,aCount)) {
+      return theIndex;
     }
   }
   return kNotFound;
@@ -2427,12 +1719,7 @@ PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTagSet[],PRInt32 aCount) const {
  *  @return  topmost index of tag on stack
  */
 PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTag) const {
-  int i=0;
-  for(i=mBodyContext->mElements.mCount-1;i>=0;i--){
-    if(mBodyContext->mElements.mTags[i]==aTag)
-      return i;
-  }
-  return kNotFound;
+  return ::GetTopmostIndexOf(aTag,mBodyContext->mTags);
 }
 
 /*********************************************
@@ -2455,34 +1742,34 @@ PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTag) const {
 nsresult CNavDTD::OpenTransientStyles(eHTMLTags aTag){
   nsresult result=NS_OK;
 
-  if(!FindTagInSet(aTag,gWhitespaceTags,sizeof(gWhitespaceTags)/sizeof(eHTMLTag_unknown))) {
-    PRInt32 pos=0;
+  if(!FindTagInSet(aTag,gWhitespaceTags,sizeof(gWhitespaceTags)/sizeof(aTag))){ 
+      //the following code builds the set of style tags to be opened...
+    eHTMLTags theStyles[50];
+    int theCount=0;
 
-    eHTMLTags parentTag=mBodyContext->mElements.Last();
-    if(CanContainStyles(parentTag)) {
-      for(pos=0;pos<mBodyContext->mStyles->mCount;pos++) {
-        eHTMLTags theTag=mBodyContext->mStyles->mTags[pos]; 
-        if(PR_FALSE==HasOpenContainer(theTag)) {
-
-          CStartToken   token(theTag);
-          nsCParserNode theNode(&token,mLineNumber);
-
-          switch(theTag) {
-            case eHTMLTag_secret_h1style: case eHTMLTag_secret_h2style: 
-            case eHTMLTag_secret_h3style: case eHTMLTag_secret_h4style:
-            case eHTMLTag_secret_h5style: case eHTMLTag_secret_h6style:
-              break;
-            default:
-              token.SetTypeID(theTag);  //open the html container...
-              result=OpenContainer(theNode,PR_FALSE);
-              mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]=PR_TRUE;
-          } //switch
+    int theStackPos=0;
+    for(theStackPos=0;theStackPos<mBodyContext->GetCount();theStackPos++){
+      nsTagStack* theStyleStack=mBodyContext->mStyles[theStackPos];
+      if(theStyleStack) {
+        int theTagPos=0;
+        for(theTagPos=0;theTagPos<theStyleStack->mCount;theTagPos++){
+          if((0==theCount) || (!FindTagInSet(theStyleStack->mTags[theTagPos],theStyles,theCount))) {
+            theStyles[theCount++]=theStyleStack->mTags[theTagPos];
+          }
         }
-        if(NS_OK!=result)
-          break;
-      }//for
+      }
     }
-  }//if
+    theStyles[theCount]=eHTMLTag_unknown;
+
+      //now iterate style set, and open the containers...
+    for(theStackPos=0;theStackPos<theCount;theStackPos++){
+      CStartToken   token(theStyles[theStackPos]);
+      nsCParserNode theNode(&token,mLineNumber);
+      token.SetTypeID(theStyles[theStackPos]); 
+      result=OpenContainer(theNode,PR_FALSE);
+    }
+    mBodyContext->mOpenStyles=theCount;
+  }
   return result;
 }
 
@@ -2501,13 +1788,17 @@ nsresult CNavDTD::OpenTransientStyles(eHTMLTags aTag){
 nsresult CNavDTD::CloseTransientStyles(eHTMLTags aTag){
   nsresult result=NS_OK;
 
-  if((mBodyContext->mStyles->mCount>0) && (mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1])) {
-    if(!FindTagInSet(aTag,gWhitespaceTags,sizeof(gWhitespaceTags)/sizeof(eHTMLTag_unknown))) {
-      result=CloseContainersTo(mBodyContext->mStyles->mTags[0],PR_FALSE);
-      mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]=PR_FALSE;
+  int theTagPos=0;
 
-    }//if
-  }//if
+    //now iterate style set, and close the containers...
+  for(theTagPos=mBodyContext->mOpenStyles;theTagPos>0;theTagPos--){
+    eHTMLTags theTag=GetTopNode();
+    CStartToken   token(theTag);
+    nsCParserNode theNode(&token,mLineNumber);
+    token.SetTypeID(theTag); 
+    result=CloseContainer(theNode,theTag,PR_FALSE);
+  }
+  mBodyContext->mOpenStyles=0;
   return result;
 }
 
@@ -2520,10 +1811,10 @@ nsresult CNavDTD::CloseTransientStyles(eHTMLTags aTag){
  * @param   aNode -- next node to be added to model
  */
 nsresult CNavDTD::OpenHTML(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
 
   nsresult result=mSink->OpenHTML(aNode); 
-  mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+  mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
   return result;
 }
 
@@ -2537,9 +1828,9 @@ nsresult CNavDTD::OpenHTML(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseHTML(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult result=mSink->CloseHTML(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
   return result;
 }
 
@@ -2553,8 +1844,9 @@ nsresult CNavDTD::CloseHTML(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::OpenHead(const nsIParserNode& aNode){
-  mBodyContext->mElements.Push(eHTMLTag_head);
+  mBodyContext->Push(eHTMLTag_head);
   nsresult result=mSink->OpenHead(aNode); 
+  mHasOpenHead=PR_TRUE;
   return result;
 }
 
@@ -2568,7 +1860,8 @@ nsresult CNavDTD::OpenHead(const nsIParserNode& aNode){
  */
 nsresult CNavDTD::CloseHead(const nsIParserNode& aNode){
   nsresult result=mSink->CloseHead(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
+  mHasOpenHead=PR_FALSE;
   return result;
 }
 
@@ -2581,10 +1874,10 @@ nsresult CNavDTD::CloseHead(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::OpenBody(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
 
   nsresult result=NS_OK;
-  eHTMLTags topTag=mBodyContext->mElements.Last();
+  eHTMLTags topTag=mBodyContext->Last();
 
   if(eHTMLTag_html!=topTag) {
     
@@ -2611,7 +1904,7 @@ nsresult CNavDTD::OpenBody(const nsIParserNode& aNode){
 
   if(NS_OK==result) {
     result=mSink->OpenBody(aNode); 
-    mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+    mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
   }
   return result;
 }
@@ -2625,9 +1918,9 @@ nsresult CNavDTD::OpenBody(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseBody(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
   nsresult result=mSink->CloseBody(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
   return result;
 }
 
@@ -2708,9 +2001,9 @@ nsresult CNavDTD::CloseMap(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::OpenFrameset(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
   nsresult result=mSink->OpenFrameset(aNode); 
-  mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+  mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
   return result;
 }
 
@@ -2723,9 +2016,9 @@ nsresult CNavDTD::OpenFrameset(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseFrameset(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult result=mSink->CloseFrameset(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
   return result;
 }
 
@@ -2740,7 +2033,7 @@ nsresult CNavDTD::CloseFrameset(const nsIParserNode& aNode){
  */
 nsresult
 CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
   
   nsresult   result=NS_OK; 
   eHTMLTags nodeType=(eHTMLTags)aNode.GetNodeType();
@@ -2755,7 +2048,6 @@ CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
       result=OpenBody(aNode); break;
 
     case eHTMLTag_style:
-    case eHTMLTag_head:
     case eHTMLTag_title:
       break;
 
@@ -2785,9 +2077,13 @@ CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
       }
       break;
 
+    case eHTMLTag_head:
+      result=OpenHead(aNode); //open the head...
+      break;
+
     default:
       result=mSink->OpenContainer(aNode); 
-      mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+      mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
       break;
   }
 
@@ -2809,7 +2105,7 @@ CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
 nsresult
 CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
                         PRBool aUpdateStyles){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult   result=NS_OK;
   eHTMLTags nodeType=(eHTMLTags)aNode.GetNodeType();
   
@@ -2825,7 +2121,7 @@ CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
       break;
 
     case eHTMLTag_head:
-      //result=CloseHead(aNode); 
+      result=CloseHead(aNode); 
       break;
 
     case eHTMLTag_body:
@@ -2844,11 +2140,10 @@ CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
     case eHTMLTag_title:
     default:
       result=mSink->CloseContainer(aNode); 
-      mBodyContext->mElements.Pop();
+      mBodyContext->Pop();
       break;
   }
 
-  mBodyContext->mElements.mBits[mBodyContext->mElements.mCount]=PR_FALSE;
   if((NS_OK==result) && (PR_TRUE==aUpdateStyles)){
     UpdateStyleStackForCloseTag(nodeType,aTag);
   }
@@ -2867,15 +2162,15 @@ CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
 nsresult
 CNavDTD::CloseContainersTo(PRInt32 anIndex,eHTMLTags aTag,
                            PRBool aUpdateStyles){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult result=NS_OK;
 
   static CEndToken aToken(gEmpty);
   nsCParserNode theNode(&aToken,mLineNumber);
 
-  if((anIndex<mBodyContext->mElements.mCount) && (anIndex>=0)) {
-    while(mBodyContext->mElements.mCount>anIndex) {
-      eHTMLTags theTag=mBodyContext->mElements.Last();
+  if((anIndex<mBodyContext->GetCount()) && (anIndex>=0)) {
+    while(mBodyContext->GetCount()>anIndex) {
+      eHTMLTags theTag=mBodyContext->Last();
       aToken.SetTypeID(theTag);
       result=CloseContainer(theNode,aTag,aUpdateStyles);
     }
@@ -2892,7 +2187,7 @@ CNavDTD::CloseContainersTo(PRInt32 anIndex,eHTMLTags aTag,
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
 
   PRInt32 pos=GetTopmostIndexOf(aTag);
 
@@ -2901,7 +2196,7 @@ nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
     return CloseContainersTo(pos,aTag,aUpdateStyles);
   }
 
-  eHTMLTags theTopTag=mBodyContext->mElements.Last();
+  eHTMLTags theTopTag=mBodyContext->Last();
   if(IsCompatibleTag(aTag,theTopTag)) {
     //if you're here, it's because we're trying to close one style tag,
     //but a different one is actually open. Because this is NAV4x
@@ -2915,7 +2210,8 @@ nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
   }
   
   nsresult result=NS_OK;
-  eHTMLTags theParentTag=GetDefaultParentTagFor(aTag);
+  CTagList* theTagList=gHTMLElements[aTag].GetRootTags();
+  eHTMLTags theParentTag=theTagList->mTags[0];
   pos=GetTopmostIndexOf(theParentTag);
   if(kNotFound!=pos) {
     //the parent container is open, so close it instead
@@ -2933,10 +2229,10 @@ nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseTopmostContainer(){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
 
   CEndToken aToken(gEmpty);
-  eHTMLTags theTag=mBodyContext->mElements.Last();
+  eHTMLTags theTag=mBodyContext->Last();
   aToken.SetTypeID(theTag);
   nsCParserNode theNode(&aToken,mLineNumber);
   return CloseContainer(theNode,theTag,PR_TRUE);
@@ -2964,17 +2260,20 @@ nsresult CNavDTD::AddLeaf(const nsIParserNode& aNode){
  * @return  error code; 0 means OK
  */
 nsresult CNavDTD::AddHeadLeaf(const nsIParserNode& aNode){
-  
+  nsresult result=NS_OK;
+
   static eHTMLTags gNoXTags[]={eHTMLTag_noframes,eHTMLTag_nolayer,eHTMLTag_noscript};
   
   //this code has been added to prevent <meta> tags from being processed inside
   //the document if the <meta> tag itself was found in a <noframe>, <nolayer>, or <noscript> tag.
   if(eHTMLTag_meta==aNode.GetNodeType())
     if(HasOpenContainer(gNoXTags,sizeof(gNoXTags)/sizeof(eHTMLTag_unknown))) {
-      return NS_OK;
+      return result;
     }
 
-  nsresult result=OpenHead(aNode);
+  PRBool headOpen=mHasOpenHead;
+  if(!headOpen)
+    result=OpenHead(aNode);
   if(NS_OK==result) {
     result=AddLeaf(aNode);
     // XXX If the return value tells us to block, go
@@ -3014,7 +2313,7 @@ nsresult CNavDTD::CreateContextStackFor(eHTMLTags aChildTag){
   
   nsresult  result=(nsresult)kContextMismatch;
   PRInt32   cnt=0;
-  eHTMLTags theTop=mBodyContext->mElements.Last();
+  eHTMLTags theTop=mBodyContext->Last();
   PRBool    bResult=ForwardPropagate(kPropagationStack,theTop,aChildTag);
   
   if(PR_FALSE==bResult){
@@ -3050,7 +2349,7 @@ nsresult CNavDTD::CreateContextStackFor(eHTMLTags aChildTag){
     else bResult=BackwardPropagate(kPropagationStack,eHTMLTag_html,aChildTag);
   } //elseif
 
-  if((0==mBodyContext->mElements.mCount) || (mBodyContext->mElements.Last()==kPropagationStack.Pop()))
+  if((0==mBodyContext->GetCount()) || (mBodyContext->Last()==kPropagationStack.Pop()))
     result=NS_OK;
 
   //now, build up the stack according to the tags 
@@ -3080,14 +2379,14 @@ nsresult CNavDTD::CreateContextStackFor(eHTMLTags aChildTag){
  *  @return  
  */
 nsresult CNavDTD::ReduceContextStackFor(eHTMLTags aChildTag){
-  nsresult   result=NS_OK;
-  eHTMLTags topTag=mBodyContext->mElements.Last();
+  nsresult  result=NS_OK;
+  eHTMLTags theTopTag=mBodyContext->Last();
 
-  while( (topTag!=kNotFound) && 
-         (PR_FALSE==CanContain(topTag,aChildTag)) &&
-         (PR_FALSE==CanContainIndirect(topTag,aChildTag))) {
+  while( (theTopTag!=kNotFound) && 
+         (PR_FALSE==CanContain(theTopTag,aChildTag)) &&
+         (PR_FALSE==CanPropagate(theTopTag,aChildTag))){
     CloseTopmostContainer();
-    topTag=mBodyContext->mElements.Last();
+    theTopTag=mBodyContext->Last();
   }
   return result;
 }
@@ -3101,26 +2400,17 @@ nsresult CNavDTD::ReduceContextStackFor(eHTMLTags aChildTag){
  * @param   aTag is the id of the html container being opened
  * @return  0 if all is well.
  */
-nsresult
-CNavDTD::UpdateStyleStackForOpenTag(eHTMLTags aTag,eHTMLTags anActualTag){
+nsresult CNavDTD::UpdateStyleStackForOpenTag(eHTMLTags aTag,eHTMLTags anActualTag){
   nsresult   result=0;
-  
-  if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
-    mBodyContext->mStyles->Push(aTag);
-  }
-  else {
-    switch (aTag) {
-    case eHTMLTag_h1: case eHTMLTag_h2:
-    case eHTMLTag_h3: case eHTMLTag_h4:
-    case eHTMLTag_h5: case eHTMLTag_h6:
-      break;
 
-    default:
-      break;
+  if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
+    nsTagStack* theStyleStack=mBodyContext->mStyles[mBodyContext->GetCount()-1];
+    if(theStyleStack){
+      theStyleStack->Push(aTag);
     }
   }
   return result;
-} //update...
+} //update..
 
 
 /**
@@ -3135,440 +2425,43 @@ nsresult
 CNavDTD::UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags anActualTag){
   nsresult result=0;
   
-  if(mBodyContext->mStyles->mCount>0) {
-    if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
-      if(aTag==anActualTag)
-        mBodyContext->mStyles->Pop();
-    }
-    else {
-      switch (aTag) {
-      case eHTMLTag_h1: case eHTMLTag_h2:
-      case eHTMLTag_h3: case eHTMLTag_h4:
-      case eHTMLTag_h5: case eHTMLTag_h6:
-        break;
-
-      default:
-        break;
-      }//switch
-    }
+  if(mBodyContext->mStyles){
+    nsTagStack* theStyleStack=mBodyContext->mStyles[mBodyContext->GetCount()-1];
+    if(theStyleStack){
+      if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
+        if(aTag==anActualTag) {
+          theStyleStack->Pop();
+          mBodyContext->mOpenStyles--;
+        }
+      }
+    }//if
   }//if
   return result;
 }
 
-
-/*******************************************************************
-  These methods used to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
 /**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gess 5/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
+ * 
+ * @update	gess8/4/98
+ * @param 
+ * @return
  */
-nsresult
-CNavDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsresult result=aScanner.GetChar(aChar);
-
-  if(NS_OK==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(NS_OK==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=gTokenRecycler.CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
-          else aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_unknown,gEmpty);
-        }//if
-        break;
-
-      case kExclamation:
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-        break;
-
-      case kQuestionMark: //it must be an XML processing instruction...
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
-        break;
-
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (NS_OK==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
+nsITokenRecycler* CNavDTD::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
+ * Retrieve the preferred tokenizer for use by this DTD.
+ * @update	gess12/28/98
+ * @param   none
+ * @return  ptr to tokenizer
  */
-nsresult
-CNavDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  nsresult result=NS_OK;
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==NS_OK)) {
-    CAttributeToken* theToken= (CAttributeToken*)gTokenRecycler.CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
- 
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else if(NS_OK==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(NS_OK==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
+nsITokenizer* CNavDTD::GetTokenizer(void) {
+  if(!mTokenizer)
+    mTokenizer=new nsHTMLTokenizer();
+  return mTokenizer;
 }
 
-/**
- *  This is a special case method. It's job is to consume 
- *  all of the given tag up to an including the end tag.
- *
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null
- */
-nsresult
-CNavDTD::ConsumeContentToEndTag(PRUnichar aChar,
-                                eHTMLTags aChildTag,
-                                CScanner& aScanner,
-                                CToken*& aToken){
-  
-  //In the case that we just read the given tag, we should go and
-  //consume all the input until we find a matching end tag.
-
-  nsAutoString endTag("</");
-  endTag.Append(NS_EnumToTag(aChildTag));
-  endTag.Append(">");
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_skippedcontent,aChildTag,endTag);
-  return aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of a tag.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-
-static eHTMLTags gSkippedContentTags[]=
-  { eHTMLTag_noscript,
-    eHTMLTag_plaintext, eHTMLTag_script,   eHTMLTag_style, 
-    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
-
-static eHTMLTags gSkippedContentTargets[]=
-  { eHTMLTag_noscript,
-    eHTMLTag_html,      eHTMLTag_script,   eHTMLTag_style, 
-    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
-
-nsresult
-CNavDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
-  
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(NS_OK==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-      //now that that's over with, we have one more problem to solve.
-      //In the case that we just read a <SCRIPT> or <STYLE> tags, we should go and
-      //consume all the content itself.
-      if(NS_OK==result) {
-
-        eHTMLTags theTag=(eHTMLTags)aToken->GetTypeID();
-
-        PRInt32 theIndex=IndexOfTagInSet(theTag,gSkippedContentTags,sizeof(gSkippedContentTags)/sizeof(eHTMLTag_unknown));
-        if(-1<theIndex) {
-
-            //Do special case handling for <script>, <style>, <title> or <textarea>...
-          CToken*   skippedToken=0;
-          result=ConsumeContentToEndTag(aChar,gSkippedContentTargets[theIndex],aScanner,skippedToken);
-    
-          if((NS_OK==result) && skippedToken){
-            mTokenDeque.Push(skippedToken);
-  
-            //In the case that we just read a given tag, we should go and
-            //consume all the tag content itself (and throw it all away).
-
-            CToken* endtoken=gTokenRecycler.CreateTokenOfType(eToken_end,theTag,skippedToken->GetStringValueXXX());
-            mTokenDeque.Push(endtoken);
-          } //if
-        } //if
-      } //if
-
-      //EEEEECCCCKKKK!!! 
-      //This code is confusing, so pay attention.
-      //If you're here, it's because we were in the midst of consuming a start
-      //tag but ran out of data (not in the stream, but in this *part* of the stream.
-      //For simplicity, we have to unwind our input. Therefore, we pop and discard
-      //any new tokens we've cued this round. Later we can get smarter about this.
-      if(NS_OK!=result) {
-        while(mTokenDeque.GetSize()>theDequeSize) {
-          delete (CToken*)mTokenDeque.PopBack();
-        }
-      }
-
-
-    } //if
-  } //if
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult
-CNavDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  theChar;
-   nsresult result=aScanner.GetChar(theChar);
-
-   if(NS_OK==result) {
-     if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==theChar) {
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       aScanner.PutBack(theChar);
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult
-CNavDTD::ConsumeWhitespace(PRUnichar aChar,
-                           CScanner& aScanner,
-                           CToken*& aToken) {
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
-  nsresult result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CNavDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CNavDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
-  if(aToken) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-    if(result) {
-      nsString& temp=aToken->GetStringValueXXX();
-      if(0==temp.Length()){
-        delete aToken;
-        aToken = nsnull;
-      }
-      else result=kNoError;
-    }
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created newline token that is parsing
- *  @return error code
- */
-nsresult CNavDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CNavDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser){
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return NS_OK;
-  }
-
-  mParser=(nsParser*)aParser;
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    PRUnichar theChar;
-    result=theScanner->GetChar(theChar);
-    switch(result) {
-      case kEOF:
-          //We convert from eof to complete here, because we never really tried to get data.
-          //All we did was try to see if data was available, which it wasn't.
-          //It's important to return process complete, so that controlling logic can know that
-          //everything went well, but we're done with token processing.
-        result=kProcessComplete;
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(theChar) {
-          case kLessThan:
-            result=ConsumeTag(theChar,*theScanner,aToken);
-            break;
-
-          case kAmpersand:
-            result=ConsumeEntity(theChar,*theScanner,aToken);
-            break;
-          
-          case kCR: case kLF:
-            result=ConsumeNewline(theChar,*theScanner,aToken);
-            break;
-          
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(theChar)) {
-              nsAutoString temp(theChar);
-              result=ConsumeText(temp,*theScanner,aToken);
-              break;
-            }
-            result=ConsumeWhitespace(theChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-//    if(NS_OK==result)
-//      result=theScanner->Eof(); 
-  } //if
-  return result;
-}
-
-
 /**
  * 
  * @update  gess5/18/98
diff --git a/htmlparser/src/CNavDTD.h b/htmlparser/src/CNavDTD.h
index d23f87244db2..648c64b438b4 100644
--- a/htmlparser/src/CNavDTD.h
+++ b/htmlparser/src/CNavDTD.h
@@ -86,7 +86,6 @@
 #include "nsVoidArray.h"
 #include "nsDeque.h"
 
-
 #define NS_INAVHTML_DTD_IID      \
   {0x5c5cce40, 0xcfd6,  0x11d1,  \
   {0xaa, 0xda, 0x00,    0x80, 0x5f, 0x8a, 0x3e, 0x14}}
@@ -100,7 +99,7 @@ class CITokenHandler;
 class nsParser;
 class nsDTDContext;
 class nsTagStack;
-
+class nsITokenizer;
 
 /***************************************************************
   Now the main event: CNavDTD.
@@ -135,6 +134,8 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual ~CNavDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -191,6 +192,16 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -199,7 +210,7 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  This method is called by the parser, once for each token
@@ -229,21 +240,27 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
+    nsITokenizer* GetTokenizer(void);
 
+    
+    /**
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
+     */
+    virtual  nsITokenRecycler* GetTokenRecycler(void);
 
     /**
      * If the parse process gets interrupted, this method gets called
 	   * prior to the process resuming.
      * @update	gess5/18/98
-     * @return	error code -- usually kNoError (0)
+     * @return	error code -- usually NS_OK (0)
      */
     NS_IMETHOD WillResumeParse(void);
 
@@ -251,7 +268,7 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      * If the parse process is about to be interrupted, this method
 	   * will be called just prior.
      * @update	gess5/18/98
-     * @return	error code  -- usually kNoError (0)
+     * @return	error code  -- usually NS_OK (0)
      */
     NS_IMETHOD WillInterruptParse(void);
 
@@ -266,17 +283,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool CanContain(PRInt32 aParent,PRInt32 aChild) const;
 
-    /**
-     *  This method is called to determine whether or not a tag
-     *  of one type can contain a tag of another type.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   aParent -- int tag of parent container
-     *  @param   aChild -- int tag of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainEx(PRInt32 aParent,PRInt32 aChild) const;
-
     /**
      *  This method is called to determine whether or not a tag
      *  of one type can contain a tag of another type.
@@ -288,17 +294,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool CanPropagate(eHTMLTags aParent,eHTMLTags aChild) const;
 
-    /**
-     *  This method is called to determine whether a tag
-     *  of one of its children can contain a given child tag.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   aParent -- tag enum of parent container
-     *  @param   aChild -- tag enum of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const;
-
     /**
      *  This method gets called to determine whether a given 
      *  child tag can be omitted by the given parent.
@@ -331,17 +326,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool IsContainer(PRInt32 aTag) const;
 
-    /**
-     * Call this if you want the DTD to give you a default
-	   * Parent tag for given child tag. This is needed in cases
-	   * such as propagation.
-	   *
-     * @update  gess 7/6/98
-     * @param   aTag --  child to determine dflt parent tag for
-     * @return  enum of parent tag -- potentially eHTMLTag_unknown
-     */
-    virtual eHTMLTags GetDefaultParentTagFor(eHTMLTags aTag) const;
-
     /**
      * This method tries to design a context map (without actually
      * changing our parser state) from the parent down to the
@@ -381,17 +365,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool HasOpenContainer(const eHTMLTags aTagSet[],PRInt32 aCount) const;
 
-    /**
-     * This method is used to determine the index on the stack of the
-     * nearest container tag that can constrain autoclosure. It is possible
-	   * that no tag on the stack will gate autoclosure.
-	   *
-     * @update	gess 7/15/98
-     * @param   id of tag you want to test for
-     * @return  index of gating tag on context stack. kNotFound otherwise
-     */
-    virtual PRBool IsGatedFromClosing(eHTMLTags aChild) const;
-
     /**
      * Accessor that retrieves the tag type of the topmost item on context 
 	   * vector stack.
@@ -418,9 +391,7 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
     virtual PRInt32 GetTopmostIndexOf(eHTMLTags aTagSet[],PRInt32 aCount) const;
 
 
-    virtual  nsITokenRecycler* GetTokenRecycler(void);
-
-    /**
+    /** 
      * The following methods are use to create and manage
      * the dynamic set of token handlers.
      * @update	gess5/11/98
@@ -538,52 +509,13 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
     nsresult  UpdateStyleStackForOpenTag(eHTMLTags aTag,eHTMLTags aActualTag);
     nsresult  UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags aActualTag);
     PRBool    CanContainStyles(eHTMLTags aTag) const;
-    PRBool    RequiresAutomaticClosure(eHTMLTags aParentTag,eHTMLTags aChildTag) const;
-
-    /****************************************************
-        These methods interface with the parser to do
-        the tokenization phase.
-     ****************************************************/
-
-
-    /**
-     * The following methods consume a particular type
-     * of HTML token.
-     *
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-    nsresult     ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Causes content to be skipped up to sequence contained in aString.
-     * @update	gess 5/11/98
-     * @param   aString ????
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    virtual nsresult ConsumeContentToEndTag(PRUnichar aChar,
-																						eHTMLTags aChildTag,
-																						CScanner& aScanner,
-																						CToken*& aToken);
 
 
 protected:
 
-		PRInt32			CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
-		PRInt32			CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
-    PRInt32     DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag);    
+		nsresult    CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
+		nsresult    CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
+    nsresult    DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag);    
 
 
     nsIHTMLContentSink* mSink;
@@ -599,11 +531,12 @@ protected:
     PRBool              mHasOpenMap;
     PRBool              mHasOpenHead;
     PRBool              mHasOpenBody;
-    nsDeque             mTokenDeque;
+    PRBool              mHadBodyOrFrameset;
     nsString            mFilename;
     nsIDTDDebug*		    mDTDDebug;
     PRInt32             mLineNumber;
     nsParser*           mParser;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewNavHTMLDTD(nsIDTD** aInstancePtrResult);
diff --git a/htmlparser/src/COtherDTD.cpp b/htmlparser/src/COtherDTD.cpp
index f19a24f85ebf..9e7d08674a19 100644
--- a/htmlparser/src/COtherDTD.cpp
+++ b/htmlparser/src/COtherDTD.cpp
@@ -38,7 +38,7 @@
 #include "nsParser.h"
 #include "nsIHTMLContentSink.h" 
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"
@@ -50,7 +50,7 @@
 #ifdef XP_PC
 #include <direct.h> //this is here for debug reasons...
 #endif
-#include <time.h>
+#include <time.h> 
 #include "prmem.h"
 
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
@@ -148,6 +148,16 @@ COtherDTD::~COtherDTD(){
   //parent does all the real work of destruction.
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& COtherDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh instance
  * of itself
@@ -330,19 +340,6 @@ PRBool COtherDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const {
 }
 
 
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 4/8/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool COtherDTD::CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const {
-  return CNavDTD::CanContainIndirect(aParent,aChild);
-}
-
 /**
  *  This method gets called to determine whether a given 
  *  tag can contain newlines. Most do not.
@@ -368,18 +365,6 @@ PRBool COtherDTD::CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild) const {
   return CNavDTD::CanOmitEndTag(aParent,aChild);
 }
 
-/**
- * This method does two things: 1st, help construct
- * our own internal model of the content-stack; and
- * 2nd, pass this message on to the sink.
- * @update  gess4/6/98
- * @param   aNode -- next node to be added to model
- * @return  TRUE if ok, FALSE if error
- */
-eHTMLTags COtherDTD::GetDefaultParentTagFor(eHTMLTags aTag) const{
-  return CNavDTD::GetDefaultParentTagFor(aTag);
-}
-
 
 /*********************************************
   Here comes code that handles the interface
@@ -693,140 +678,6 @@ nsresult COtherDTD::UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags anActua
   return CNavDTD::UpdateStyleStackForCloseTag(aTag,anActualTag);
 } //update...
 
-/*******************************************************************
-  These methods used to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gess 5/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
- */
-nsresult COtherDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeTag(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
- */
-nsresult COtherDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  return CNavDTD::ConsumeAttributes(aChar,aScanner,aToken);
-}
-
-/**
- *  This is a special case method. It's job is to consume 
- *  all of the given tag up to an including the end tag.
- *
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null
- */
-nsresult COtherDTD::ConsumeContentToEndTag(PRUnichar aChar,
-																					 eHTMLTags aChildTag,
-																					 CScanner& aScanner,
-																					 CToken*& aToken){
-  return CNavDTD::ConsumeContentToEndTag(aChar,aChildTag,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of a tag.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeStartTag(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeEntity(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeWhitespace(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  return CNavDTD::ConsumeComment(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  return CNavDTD::ConsumeText(aString,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  return CNavDTD::ConsumeNewline(aChar,aScanner,aToken);
-}
-
-
 /**
  * 
  * @update	gess5/18/98
diff --git a/htmlparser/src/COtherDTD.h b/htmlparser/src/COtherDTD.h
index e3ccac7099ea..6b8686cf050c 100644
--- a/htmlparser/src/COtherDTD.h
+++ b/htmlparser/src/COtherDTD.h
@@ -62,6 +62,8 @@ class COtherDTD : public CNavDTD {
      */
     virtual ~COtherDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -117,17 +119,6 @@ class COtherDTD : public CNavDTD {
      */
     virtual PRBool CanContain(PRInt32 aParent,PRInt32 aChild) const;
 
-    /**
-     *  This method is called to determine whether or not a tag
-     *  of one type can contain a tag of another type.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   aParent -- tag enum of parent container
-     *  @param   aChild -- tag enum of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const;
-
     /**
      *  This method gets called to determine whether a given 
      *  tag can contain newlines. Most do not.
@@ -148,17 +139,6 @@ class COtherDTD : public CNavDTD {
      *  @return  PR_TRUE if given tag can contain other tags
      */
     virtual PRBool CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild)const;
-
-    /**
-     * This method does two things: 1st, help construct
-     * our own internal model of the content-stack; and
-     * 2nd, pass this message on to the sink.
-     * @update  gess4/6/98
-     * @param   aNode -- next node to be added to model
-     * @return  TRUE if ok, FALSE if error
-     */
-    virtual eHTMLTags GetDefaultParentTagFor(eHTMLTags aTag) const;
-
    
     /**
      * This method gets called when a start token has been consumed and needs 
@@ -428,104 +408,6 @@ private:
     nsresult UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags aActualTag);
 
 
-    /****************************************************
-        These methods interface with the parser to do
-        the tokenization phase.
-     ****************************************************/
-
-
-    /**
-     * Retrieve the next TAG from the given scanner.
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve next START tag from given scanner.
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve collection of HTML/XML attributes from given scanner
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-    
-    /**
-     * Retrieve a sequence of text from given scanner.
-     * @update	gess 5/11/98
-     * @param   aString will contain retrieved text.
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve an entity from given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a whitespace sequence from the given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a comment from the given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Retrieve newlines from given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Causes content to be skipped up to sequence contained in aString.
-     * @update	gess 5/11/98
-     * @param   aString ????
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    virtual nsresult ConsumeContentToEndTag(PRUnichar aChar,
-																						eHTMLTags aChildTag,
-																						CScanner& aScanner,
-																						CToken*& aToken);
-
-
 protected:
 
     
diff --git a/htmlparser/src/CParserContext.cpp b/htmlparser/src/CParserContext.cpp
index 90b2cf9226a5..67850f48ed8d 100644
--- a/htmlparser/src/CParserContext.cpp
+++ b/htmlparser/src/CParserContext.cpp
@@ -9,7 +9,7 @@
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  * for the specific language governing rights and limitations under the
  * NPL.
- *
+ * 
  * The Initial Developer of this code under the NPL is Netscape
  * Communications Corporation.  Portions created by Netscape are
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
@@ -20,7 +20,7 @@
 #include "CParserContext.h"
 #include "nsToken.h"
 
-
+/*
 class CTokenDeallocator: public nsDequeFunctor{
 public:
   virtual void* operator()(void* anObject) {
@@ -32,7 +32,7 @@ public:
 
 CTokenDeallocator gTokenDeallocator;
 
-
+*/
 
 /**
  * Your friendly little constructor. Ok, it's not the friendly, but the only guy
@@ -42,9 +42,9 @@ CTokenDeallocator gTokenDeallocator;
  * @param   aKey
  * @param   aListener
  */
-CParserContext::CParserContext(CScanner* aScanner,void* aKey,nsIStreamObserver* aListener) :
-  mSourceType(),
-  mTokenDeque(gTokenDeallocator)
+CParserContext::CParserContext(nsScanner* aScanner,void* aKey,nsIStreamObserver* aListener) :
+  mSourceType()
+  //,mTokenDeque(gTokenDeallocator)
 {
   mScanner=aScanner;
   mKey=aKey;
@@ -54,9 +54,8 @@ CParserContext::CParserContext(CScanner* aScanner,void* aKey,nsIStreamObserver*
   mParseMode=eParseMode_unknown;
   mAutoDetectStatus=eUnknownDetect;
   mTransferBuffer=0;
-  mCurrentPos=0;
-  mMarkPos=0;
   mDTD=0;
+  mTransferBufferSize=eTransferBufferSize;
 }
 
 
@@ -67,11 +66,6 @@ CParserContext::CParserContext(CScanner* aScanner,void* aKey,nsIStreamObserver*
  */
 CParserContext::~CParserContext(){
 
-  if(mCurrentPos)
-    delete mCurrentPos;
-  if(mMarkPos)
-    delete mMarkPos;
-
   if(mScanner)
     delete mScanner;
 
diff --git a/htmlparser/src/CParserContext.h b/htmlparser/src/CParserContext.h
index 9a8d1d678a04..55b4fcbe72b7 100644
--- a/htmlparser/src/CParserContext.h
+++ b/htmlparser/src/CParserContext.h
@@ -26,13 +26,12 @@
 #define __CParserContext
 
 #include "nsIParser.h"
-#include "nsDeque.h"
-#include "nsParserTypes.h"
 #include "nsIURL.h"
 #include "nsIDTD.h"
 #include "nsScanner.h"
 #include "nsIStreamListener.h"
 #include "nsString.h"
+#include "nshtmlpars.h"
 
 /**
  * Note that the parser is given FULL access to all
@@ -45,7 +44,7 @@ public:
 
     enum {eTransferBufferSize=4096};
 
-    CParserContext( CScanner* aScanner,
+    CParserContext( nsScanner* aScanner,
                     void* aKey=0,
                     nsIStreamObserver* aListener=0);
 
@@ -56,10 +55,7 @@ public:
     nsString            mSourceType;
     eAutoDetectResult   mAutoDetectStatus;
 
-    nsDequeIterator*    mCurrentPos;
-    nsDequeIterator*    mMarkPos;
-    nsDeque             mTokenDeque;
-    CScanner*           mScanner;
+    nsScanner*          mScanner;
     nsIDTD*             mDTD;
 
     eParseMode          mParseMode;
@@ -68,7 +64,8 @@ public:
 
     CParserContext*     mPrevContext;
     void*               mKey;
-
+    PRUint32            mTransferBufferSize;
+    // nsDeque          mTokenDeque;
 };
 
 
diff --git a/htmlparser/src/CRtfDTD.cpp b/htmlparser/src/CRtfDTD.cpp
index 222cd9807407..285e4d3fefe2 100644
--- a/htmlparser/src/CRtfDTD.cpp
+++ b/htmlparser/src/CRtfDTD.cpp
@@ -36,8 +36,9 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
+#include "nsITokenizer.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"  //this is here for debug reasons...
@@ -198,6 +199,7 @@ CRtfDTD::CRtfDTD() : nsIDTD() {
   NS_INIT_REFCNT();
   mParser=0;
   mFilename=0;
+  mTokenizer=0;
 }
 
 /**
@@ -210,6 +212,16 @@ CRtfDTD::CRtfDTD() : nsIDTD() {
 CRtfDTD::~CRtfDTD(){
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CRtfDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct fresh instance
  * of itself.
@@ -261,141 +273,39 @@ NS_IMETHODIMP CRtfDTD::WillBuildModel(nsString& aFilename,PRInt32 aLevel,nsIPars
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CRtfDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CRtfDTD::DidBuildModel(PRInt32 anErrorCode,PRInt32 aLevel,nsIParser* aParser){
+NS_IMETHODIMP CRtfDTD::DidBuildModel(nsresult anErrorCode,PRInt32 aLevel,nsIParser* aParser){
   nsresult result=NS_OK;
 
   return result;
 }
 
-
-
-/*******************************************************************
-  These methods use to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
 /**
- *  This gets called when we've just read a '\' char. 
- *  It means we need to read an RTF control word.
- *  
- *  @update gess 3/25/98
- *  @param  aToken ptr-ref to new token we create
- *  @return error code -- preferably kNoError
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
  */
-PRInt32 CRtfDTD::ConsumeControlWord(CToken*& aToken){
-  PRInt32 result=kNoError;
-  CRTFControlWord* cw=new CRTFControlWord("");
-  if(cw){
-    CScanner* theScanner=mParser->GetScanner();
-    cw->Consume(*theScanner);
-    aToken=cw;
-  }
-  return result;
-}
-
-/**
- *  This gets called when we've just read a '{' or '}' group char. 
- *  It means we have just started or ended an RTF group.
- *  
- *  @update gess 3/25/98
- *  @param  aToken ptr-ref to new token we create
- *  @return error code -- preferably kNoError
- */
-static char* keys[] = {"}","{"};
-
-PRInt32 CRtfDTD::ConsumeGroupTag(CToken*& aToken,PRBool aStartGroup){
-  PRInt32 result=kNoError;
-  CRTFGroup* cw=new CRTFGroup(keys[PR_TRUE==aStartGroup],aStartGroup);
-  if(cw){
-    CScanner* theScanner=mParser->GetScanner();
-    cw->Consume(*theScanner);
-    aToken=cw;
-  }
-  return result;
-}
-
-/**
- *  This gets called when we've just read plain text char.
- *  It means we need to read RTF content.
- *  
- *  @update gess 3/25/98
- *  @param  aToken ptr-ref to new token we create
- *  @return error code -- preferably kNoError
- */
-PRInt32 CRtfDTD::ConsumeContent(PRUnichar aChar,CToken*& aToken){
-  PRInt32 result=kNoError;
-  PRUnichar buffer[2] = {0,0};
-  buffer[0]=aChar;
-  CRTFContent * cw=new CRTFContent(buffer);
-  if(cw){
-    CScanner* theScanner=mParser->GetScanner();
-    cw->Consume(*theScanner);
-    aToken=cw;
-  }
-  return result;
-}
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CRtfDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser){
-
-  mParser=(nsParser*)aParser;
-  CScanner* theScanner=mParser->GetScanner();
-
-  PRUnichar aChar;
-  nsresult   result=theScanner->GetChar(aChar);
-
-  switch(result) {
-    case kEOF:
-      break;
-
-    case kInterrupted:
-      theScanner->RewindToMark();
-      break; 
-
-    case NS_OK:
-    default:
-      switch(aChar) {
-        case kLeftBrace:
-          result=ConsumeGroupTag(aToken,PR_TRUE); break;
-
-        case kRightBrace:
-          result=ConsumeGroupTag(aToken,PR_FALSE); break;
-
-        case kBackSlash:
-          result=ConsumeControlWord(aToken); break;
-
-        case kCR:
-        case kSpace:
-        case kTab:
-        case kLF:
-          break;
-
-        default:
-          result=ConsumeContent(aChar,aToken); break;
-      } //switch
-      break; 
-  } //switch
-  if(NS_OK==result)
-    result=theScanner->Eof();
-  return result;
+nsITokenizer* CRtfDTD::GetTokenizer(void){
+  return 0;
 }
 
 /**
@@ -474,8 +384,8 @@ PRBool CRtfDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const{
  *  @param   aToken -- token object to be put into content model
  *  @return  0 if all is well; non-zero is an error
  */
-PRInt32 CRtfDTD::HandleGroup(CToken* aToken){
-  PRInt32 result=kNoError;
+nsresult CRtfDTD::HandleGroup(CToken* aToken){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -485,8 +395,8 @@ PRInt32 CRtfDTD::HandleGroup(CToken* aToken){
  *  @param   aToken -- token object to be put into content model
  *  @return  0 if all is well; non-zero is an error
  */
-PRInt32 CRtfDTD::HandleControlWord(CToken* aToken){
-  PRInt32 result=kNoError;
+nsresult CRtfDTD::HandleControlWord(CToken* aToken){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -496,8 +406,8 @@ PRInt32 CRtfDTD::HandleControlWord(CToken* aToken){
  *  @param   aToken -- token object to be put into content model
  *  @return  0 if all is well; non-zero is an error
  */
-PRInt32 CRtfDTD::HandleContent(CToken* aToken){
-  PRInt32 result=kNoError;
+nsresult CRtfDTD::HandleContent(CToken* aToken){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -582,9 +492,9 @@ PRInt32 CRTFControlWord::GetTokenType() {
 }
 
 
-PRInt32 CRTFControlWord::Consume(CScanner& aScanner){
+PRInt32 CRTFControlWord::Consume(nsScanner& aScanner){
   PRInt32 result=aScanner.ReadWhile(mTextValue,gAlphaChars,PR_TRUE,PR_FALSE);
-  if(kNoError==result) {
+  if(NS_OK==result) {
     //ok, now look for an option parameter...
     PRUnichar ch;
     result=aScanner.Peek(ch);
@@ -601,7 +511,7 @@ PRInt32 CRTFControlWord::Consume(CScanner& aScanner){
         break;
     }
   }
-  if(kNoError==result)
+  if(NS_OK==result)
     result=aScanner.SkipWhitespace();
   return result;
 }
@@ -614,7 +524,7 @@ PRInt32 CRTFControlWord::Consume(CScanner& aScanner){
 CRTFGroup::CRTFGroup(char* aKey,PRBool aStartGroup) : CToken(aKey) {
   mStart=aStartGroup;
 }
-
+ 
 
 PRInt32 CRTFGroup::GetTokenType() {
   return eRTFToken_group;
@@ -628,8 +538,8 @@ PRBool CRTFGroup::IsGroupStart(){
   return mStart;
 }
 
-PRInt32 CRTFGroup::Consume(CScanner& aScanner){
-  PRInt32 result=kNoError;
+PRInt32 CRTFGroup::Consume(nsScanner& aScanner){
+  PRInt32 result=NS_OK;
   if(PR_FALSE==mStart)
     result=aScanner.SkipWhitespace();
   return result;
@@ -658,7 +568,7 @@ PRInt32 CRTFContent::GetTokenType() {
  * @return
  */
 static nsString textTerminators("\\{}");
-PRInt32 CRTFContent::Consume(CScanner& aScanner){
+PRInt32 CRTFContent::Consume(nsScanner& aScanner){
   PRInt32 result=aScanner.ReadUntil(mTextValue,textTerminators,PR_FALSE,PR_FALSE);
   return result;
 }
diff --git a/htmlparser/src/CRtfDTD.h b/htmlparser/src/CRtfDTD.h
index 55ffb3b40509..cfc1f82bb83e 100644
--- a/htmlparser/src/CRtfDTD.h
+++ b/htmlparser/src/CRtfDTD.h
@@ -40,7 +40,7 @@
 
 class nsIParserNode;
 class nsParser;
-
+class nsITokenizer;
 
 enum eRTFTokenTypes {
   eRTFToken_unknown=0,
@@ -102,7 +102,7 @@ class CRTFControlWord : public CToken {
 public:
                   CRTFControlWord(char* aKey);
   virtual PRInt32 GetTokenType();
-  virtual PRInt32 Consume(CScanner& aScanner);
+  virtual PRInt32 Consume(nsScanner& aScanner);
 protected:
   nsString  mArgument;
 };
@@ -120,7 +120,7 @@ public:
   virtual PRInt32 GetTokenType();
   virtual void    SetGroupStart(PRBool aFlag);
   virtual PRBool  IsGroupStart();
-  virtual PRInt32 Consume(CScanner& aScanner);
+  virtual PRInt32 Consume(nsScanner& aScanner);
 protected:
           PRBool  mStart;
 };
@@ -136,7 +136,7 @@ class CRTFContent: public CToken {
 public:
                   CRTFContent(PRUnichar* aValue);
   virtual PRInt32 GetTokenType();
-  virtual PRInt32 Consume(CScanner& aScanner);
+  virtual PRInt32 Consume(nsScanner& aScanner);
 };
 
 
@@ -165,6 +165,8 @@ class CRtfDTD : public nsIDTD {
      */
     virtual ~CRtfDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -202,6 +204,16 @@ class CRtfDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRInt32 aLevel,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -210,7 +222,7 @@ class CRtfDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRInt32 aLevel,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRInt32 aLevel,nsIParser* aParser);
 
     /**
      *  
@@ -218,7 +230,7 @@ class CRtfDTD : public nsIDTD {
      *  @param   aToken -- token object to be put into content model
      *  @return  0 if all is well; non-zero is an error
      */
-    virtual PRInt32 HandleGroup(CToken* aToken);
+    NS_IMETHOD HandleGroup(CToken* aToken);
 
     /**
      *  
@@ -226,7 +238,7 @@ class CRtfDTD : public nsIDTD {
      *  @param   aToken -- token object to be put into content model
      *  @return  0 if all is well; non-zero is an error
      */
-    virtual PRInt32 HandleControlWord(CToken* aToken);
+    NS_IMETHOD HandleControlWord(CToken* aToken);
 
     /**
      *  
@@ -234,7 +246,7 @@ class CRtfDTD : public nsIDTD {
      *  @param   aToken -- token object to be put into content model
      *  @return  0 if all is well; non-zero is an error
      */
-    virtual PRInt32 HandleContent(CToken* aToken);
+    NS_IMETHOD HandleContent(CToken* aToken);
 
     /**
      *  
@@ -262,47 +274,14 @@ class CRtfDTD : public nsIDTD {
      */
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
-   
+  
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    virtual PRInt32 ConsumeControlWord(CToken*& aToken);
-
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    virtual PRInt32 ConsumeGroupTag(CToken*& aToken,PRBool aStartTag);
-
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    virtual PRInt32 ConsumeContent(PRUnichar aChar,CToken*& aToken);
-
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
+    nsITokenizer* GetTokenizer(void);
 
     /**
      * 
@@ -371,6 +350,7 @@ protected:
     
     nsParser*           mParser;
     char*               mFilename;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewRTF_DTD(nsIDTD** aInstancePtrResult);
diff --git a/htmlparser/src/MANIFEST b/htmlparser/src/MANIFEST
index 2948935a25f2..49874d39525d 100644
--- a/htmlparser/src/MANIFEST
+++ b/htmlparser/src/MANIFEST
@@ -6,6 +6,7 @@ nshtmlpars.h
 nsIContentSink.h
 nsIHTMLContentSink.h
 nsHTMLContentSinkStream.h
+nsITokenizer.h
 nsHTMLTokens.h
 nsIParserNode.h
 nsIParser.h
diff --git a/htmlparser/src/Makefile.in b/htmlparser/src/Makefile.in
index 67f88033590e..26b831a1eedf 100644
--- a/htmlparser/src/Makefile.in
+++ b/htmlparser/src/Makefile.in
@@ -30,6 +30,8 @@ DEFINES += -D_IMPL_NS_HTMLPARS
 
 CPPSRCS=					\
 	nsDTDUtils.cpp				\
+	nsHTMLTokenizer.cpp \
+	nsXMLTokenizer.cpp \
 	CNavDTD.cpp				\
 	COtherDTD.cpp				\
 	CRtfDTD.cpp				\
@@ -57,6 +59,7 @@ CPPSRCS=					\
 EXPORTS =     \
   nshtmlpars.h    \
   nsIContentSink.h  \
+	nsITokenizer.h \
   nsIHTMLContentSink.h  \
   nsHTMLContentSinkStream.h \
   nsHTMLEntities.h    \
diff --git a/htmlparser/src/makefile.win b/htmlparser/src/makefile.win
index e7c3361c46e7..326e407708cb 100644
--- a/htmlparser/src/makefile.win
+++ b/htmlparser/src/makefile.win
@@ -25,6 +25,8 @@ REQUIRES=xpcom raptor netlib
 
 CPPSRCS=					\
 	nsDTDUtils.cpp				\
+	nsHTMLTokenizer.cpp \
+	nsXMLTokenizer.cpp \
 	CNavDTD.cpp				\
 	COtherDTD.cpp				\
 	CRtfDTD.cpp				\
@@ -51,6 +53,8 @@ CPPSRCS=					\
 
 CPP_OBJS=					\
 	.\$(OBJDIR)\nsDTDUtils.obj			\
+	.\$(OBJDIR)\nsHTMLTokenizer.obj \
+	.\$(OBJDIR)\nsXMLTokenizer.obj \
 	.\$(OBJDIR)\CNavDTD.obj			\
 	.\$(OBJDIR)\COtherDTD.obj		\
 	.\$(OBJDIR)\CRtfDTD.obj			\
@@ -77,6 +81,7 @@ CPP_OBJS=					\
 
 EXPORTS=					\
 	nshtmlpars.h				\
+	nsITokenizer.h \
 	nsIContentSink.h			\
 	nsIHTMLContentSink.h			\
 	nsILoggingSink.h			\
diff --git a/htmlparser/src/nsDTDDebug.cpp b/htmlparser/src/nsDTDDebug.cpp
index 3e9a37f69dae..9c02e2774ad4 100644
--- a/htmlparser/src/nsDTDDebug.cpp
+++ b/htmlparser/src/nsDTDDebug.cpp
@@ -17,7 +17,7 @@
  */
   
 /**
- * MODULE NOTES:
+ * MODULE NOTES: 
  * @update  jevering 06/18/98
  * 
  * This file contains the parser debugger object which aids in
diff --git a/htmlparser/src/nsDTDUtils.cpp b/htmlparser/src/nsDTDUtils.cpp
index 18c2a47a72ee..3550a4549df4 100644
--- a/htmlparser/src/nsDTDUtils.cpp
+++ b/htmlparser/src/nsDTDUtils.cpp
@@ -15,10 +15,10 @@
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  * Reserved.
  */
-
+ 
 
 #include "nsDTDUtils.h"
-
+#include "CNavDTD.h"
 
 static CTokenDeallocator gTokenKiller;
  
@@ -27,23 +27,17 @@ static CTokenDeallocator gTokenKiller;
  ***************************************************************/
 
 
-
 /**
  * Default constructor
  * @update	gess9/10/98
  */
 nsTagStack::nsTagStack(int aDefaultSize) {
-#ifndef rickgdebug
-  mSize=aDefaultSize;
-  mTags =new eHTMLTags[mSize];
-  mBits =new PRBool[mSize];
-#else
-  mSize=eStackSize;
+#ifndef NS_DEBUG
+  mTags =new eHTMLTags[mCapacity];
 #endif
+  mCapacity=aDefaultSize;
   mCount=0;
-  mPrevious=0;
-  nsCRT::zero(mTags,mSize*sizeof(eHTMLTags));
-  nsCRT::zero(mBits,mSize*sizeof(PRBool));
+  nsCRT::zero(mTags,mCapacity*sizeof(eHTMLTags));
 }
 
 /**
@@ -51,14 +45,12 @@ nsTagStack::nsTagStack(int aDefaultSize) {
  * @update  gess7/9/98
  */
 nsTagStack::~nsTagStack() {
-#ifndef rickgdebug
-    delete mTags;
-    delete mBits;
-    mTags=0;
-    mBits=0;
+#ifndef NS_DEBUG
+  delete mTags;
+  mTags=0;
 #endif
-    mSize=mCount=0; 
-  }
+  mCapacity=mCount=0; 
+}
 
 /**
  * Resets state of stack to be empty.
@@ -73,27 +65,17 @@ void nsTagStack::Empty(void) {
  * @update  gess7/9/98 
  */
 void nsTagStack::Push(eHTMLTags aTag) {
-
-  if(mCount>=mSize) {
-#ifndef rickgdebug
-      //regrow the dynamic stack... 
-    eHTMLTags* tmp=new eHTMLTags[2*mSize];
-    nsCRT::zero(tmp,2*mSize*sizeof(eHTMLTag_html));
-    nsCRT::memcpy(tmp,mTags,mSize*sizeof(eHTMLTag_html));
+  if(mCount>=mCapacity) {
+#ifndef NS_DEBUG
+    eHTMLTags* tmp=new eHTMLTags[2*mCapacity];
+    nsCRT::zero(tmp,2*mCapacity*sizeof(eHTMLTag_html));
+    nsCRT::memcpy(tmp,mTags,mCapacity*sizeof(eHTMLTag_html));
     delete mTags;
     mTags=tmp;
-
-    PRBool* tmp2=new PRBool[2*mSize];
-    nsCRT::zero(tmp2,2*mSize*sizeof(PRBool));
-    nsCRT::memcpy(tmp2,mBits,mSize*sizeof(PRBool));
-    delete mBits;
-    mBits=tmp2;
-    mSize*=2;
 #else
     NS_PRECONDITION(mCount<eStackSize,"TagStack Overflow: DEBUG VERSION!");
 #endif
   }
-
   mTags[mCount++]=aTag;
 }
 
@@ -106,7 +88,6 @@ eHTMLTags nsTagStack::Pop() {
   if(mCount>0) {
     result=mTags[--mCount];
     mTags[mCount]=eHTMLTag_unknown;
-    mBits[mCount]=PR_FALSE;
   }
   return result;
 }
@@ -121,6 +102,29 @@ eHTMLTags nsTagStack::First() const {
   return eHTMLTag_unknown;
 }
 
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsTagStack::TagAt(PRInt32 anIndex) const {
+  if((anIndex>=0) && (anIndex<mCount))
+    return mTags[anIndex];
+  return eHTMLTag_unknown;
+}
+
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsTagStack::operator[](PRInt32 anIndex) const {
+  if((anIndex>=0) && (anIndex<mCount))
+    return mTags[anIndex];
+  return eHTMLTag_unknown;
+}
+
+
+
 /**
  * 
  * @update  gess7/9/98
@@ -141,9 +145,13 @@ eHTMLTags nsTagStack::Last() const {
  * 
  * @update	gess9/10/98
  */
-nsDTDContext::nsDTDContext(int aDefaultSize) : mElements(aDefaultSize) {
-  mStyles=new nsTagStack(aDefaultSize);
-}
+nsDTDContext::nsDTDContext(int aDefaultSize) {
+#ifndef NS_DEBUG
+  mStyles =new nsTagStack*[mCapacity];
+#endif
+  mOpenStyles=0;
+  nsCRT::zero(mStyles,mTags.mCapacity*sizeof(void*));
+} 
  
 
 /**
@@ -151,43 +159,88 @@ nsDTDContext::nsDTDContext(int aDefaultSize) : mElements(aDefaultSize) {
  * @update	gess9/10/98
  */
 nsDTDContext::~nsDTDContext() {
-  while(mStyles){
-    nsTagStack* next=mStyles->mPrevious;
+#ifndef NS_DEBUG
+  delete mTags;
+  delete mStyles;
+  mTags=0;
+  mStyles=0;
+#endif
+}
+
+/**
+ * 
+ * @update  gess7/9/98 
+ */
+PRInt32 nsDTDContext::GetCount(void) {
+  return mTags.mCount;
+}
+
+/**
+ * 
+ * @update  gess7/9/98 
+ */
+void nsDTDContext::Push(eHTMLTags aTag) {
+  if(mTags.mCount>=mTags.mCapacity) {
+#ifndef NS_DEBUG
+    nsTagStack** tmp2=new nsTagStack*[2*mTags.mCapacity];
+    nsCRT::zero(tmp2,2*mTags.mCapacity*sizeof(void*));
+    nsCRT::memcpy(tmp2,mStyles,mTags.mCapacity*sizeof(void*));
     delete mStyles;
-    mStyles=next;
+    mStyles=tmp2;
+    //mCapacity*=2;
+#else
+    NS_PRECONDITION(mTags.mCount<nsTagStack::eStackSize,"TagStack Overflow: DEBUG VERSION!");
+#endif
   }
+  mTags.Push(aTag);
 }
 
-
 /**
- * Creates and pushes a new style stack onto our
- * internal list of style stacks.
- * @update	gess9/10/98
+ * 
+ * @update  gess7/9/98
  */
-void nsDTDContext::pushStyleStack(nsTagStack* aStyleStack){
-  if(!aStyleStack)
-    aStyleStack=new nsTagStack();
-  if(aStyleStack){
-    mStyles->mPrevious=mStyles;
-    mStyles=aStyleStack;
-  }
-}
-
-
-/**
- * Pops the topmost style stack off our internal
- * list of style stacks.
- * @update	gess9/10/98
- */
-nsTagStack* nsDTDContext::popStyleStack(){
-  nsTagStack* result=0;
-  if(mStyles) {
-    result=mStyles;
-    mStyles=mStyles->mPrevious;
+eHTMLTags nsDTDContext::Pop() {
+  eHTMLTags result=eHTMLTag_unknown;
+  if(mTags.mCount>0) {
+    result=mTags.Pop();
+    mStyles[mTags.mCount]=0;
   }
   return result;
 }
 
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::First() const {
+  return mTags.First();
+}
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::TagAt(PRInt32 anIndex) const {
+  return mTags.TagAt(anIndex);
+}
+
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::operator[](PRInt32 anIndex) const {
+  return mTags[anIndex];
+}
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::Last() const {
+  return mTags.Last();
+}
+
 
 /**************************************************************
   Now define the tokenrecycler class...
@@ -202,7 +255,7 @@ CTokenRecycler::CTokenRecycler() : nsITokenRecycler() {
   int i=0;
   for(i=0;i<eToken_last-1;i++) {
     mTokenCache[i]=new nsDeque(gTokenKiller);
-//    mTotals[i]=0;
+    //mTotals[i]=0;
   }
 }
 
@@ -219,6 +272,17 @@ CTokenRecycler::~CTokenRecycler() {
   }
 }
 
+class CTokenFinder: public nsDequeFunctor{
+public:
+  CTokenFinder(CToken* aToken) {mToken=aToken;}
+  virtual void* operator()(void* anObject) {
+    if(anObject==mToken) {
+      return anObject;
+    }
+    return 0;
+  }
+  CToken* mToken;
+};
 
 /**
  * This method gets called when someone wants to recycle a token
@@ -229,6 +293,10 @@ CTokenRecycler::~CTokenRecycler() {
 void CTokenRecycler::RecycleToken(CToken* aToken) {
   if(aToken) {
     PRInt32 theType=aToken->GetTokenType();
+    CToken* theMatch=(CToken*)mTokenCache[theType-1]->FirstThat(CTokenFinder(aToken));
+    if(theMatch) {
+      int x=5;
+    }
     mTokenCache[theType-1]->Push(aToken);
   }
 }
@@ -248,7 +316,7 @@ CToken* CTokenRecycler::CreateTokenOfType(eHTMLTokenTypes aType,eHTMLTags aTag,
     result->Reinitialize(aTag,aString);
   }
   else {
-//    mTotals[aType-1]++;
+    //mTotals[aType-1]++;
     switch(aType){
       case eToken_start:      result=new CStartToken(aTag); break;
       case eToken_end:        result=new CEndToken(aTag); break;
diff --git a/htmlparser/src/nsDTDUtils.h b/htmlparser/src/nsDTDUtils.h
index e7260ea8932c..c5f326c466f4 100644
--- a/htmlparser/src/nsDTDUtils.h
+++ b/htmlparser/src/nsDTDUtils.h
@@ -28,11 +28,12 @@
 
 #include "nsHTMLTags.h"
 #include "nsHTMLTokens.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsCRT.h"
 #include "nsDeque.h"
 #include "nsIDTD.h"
 #include <fstream.h>
+#include "nsITokenizer.h"
 
 /***************************************************************
   Before digging into the NavDTD, we'll define a helper 
@@ -48,36 +49,33 @@
  ***************************************************************/
 
 void DebugDumpContainmentRules(nsIDTD& theDTD,const char* aFilename,const char* aTitle);
-
-//#define rickgdebug 1
+void DebugDumpContainmentRules2(nsIDTD& theDTD,const char* aFilename,const char* aTitle);
 
 class nsTagStack {
 public:
 
-#ifdef rickgdebug
+#ifdef NS_DEBUG
   enum {eStackSize=200};
 #else
   enum {eStackSize=30};
 #endif
+              nsTagStack(int aDefaultSize=eStackSize);
+              ~nsTagStack();
+  void        Push(eHTMLTags aTag);
+  eHTMLTags   Pop();
+  eHTMLTags   First() const;
+  eHTMLTags   TagAt(PRInt32 anIndex) const;
+  eHTMLTags   operator[](PRInt32 anIndex) const;
+  eHTMLTags   Last() const;
+  void        Empty(void); 
 
-            nsTagStack(int aDefaultSize=eStackSize);
-            ~nsTagStack();
-  void      Push(eHTMLTags aTag);
-  eHTMLTags Pop();
-  eHTMLTags First() const;
-  eHTMLTags Last() const;
-  void      Empty(void); 
-
-  nsTagStack* mPrevious;
-  int         mSize;
+  int         mCapacity;
   int         mCount;
 
-#ifndef rickgdebug
+#ifndef NS_DEBUG
   eHTMLTags*  mTags;
-  PRBool*     mBits;
 #else
   eHTMLTags   mTags[eStackSize];
-  PRBool      mBits[eStackSize];
 #endif
 };
 
@@ -93,11 +91,23 @@ class nsDTDContext {
 public:
                 nsDTDContext(int aDefaultSize=nsTagStack::eStackSize);
                 ~nsDTDContext();
-  void          pushStyleStack(nsTagStack* aStack=0);
-  nsTagStack*   popStyleStack();
+  void          Push(eHTMLTags aTag);
+  eHTMLTags     Pop();
+  eHTMLTags     First() const;
+  eHTMLTags     TagAt(PRInt32 anIndex) const;
+  eHTMLTags     operator[](PRInt32 anIndex) const;
+  eHTMLTags     Last() const;
+  void          Empty(void); 
+  PRInt32       GetCount(void);
 
-  nsTagStack    mElements;  //no need to hide these members. 
-  nsTagStack*   mStyles;    //the dtd should have direct access to them.
+  nsTagStack    mTags;
+
+#ifndef NS_DEBUG
+  nsTagStack**  mStyles;
+#else
+  nsTagStack*   mStyles[nsTagStack::eStackSize];
+#endif
+  int           mOpenStyles;
 };
 
 
@@ -132,6 +142,7 @@ public:
 
 protected:
     nsDeque*  mTokenCache[eToken_last-1];
+    // int       mTotals[eToken_last-1];
 };
 
 /************************************************************************
diff --git a/htmlparser/src/nsElementTable.h b/htmlparser/src/nsElementTable.h
new file mode 100644
index 000000000000..e9487bf11ff9
--- /dev/null
+++ b/htmlparser/src/nsElementTable.h
@@ -0,0 +1,724 @@
+
+class CTagList {
+public:
+  CTagList( int aCount,
+            eHTMLTags aTag1=eHTMLTag_unknown,
+            eHTMLTags aTag2=eHTMLTag_unknown,
+            eHTMLTags aTag3=eHTMLTag_unknown,
+            eHTMLTags aTag4=eHTMLTag_unknown,
+            eHTMLTags aTag5=eHTMLTag_unknown,
+            eHTMLTags aTag6=eHTMLTag_unknown,
+            eHTMLTags aTag7=eHTMLTag_unknown,
+            eHTMLTags aTag8=eHTMLTag_unknown,
+            eHTMLTags aTag9=eHTMLTag_unknown,
+            eHTMLTags aTag10=eHTMLTag_unknown){
+    mCount=aCount;
+    mTags[0]=aTag1; mTags[1]=aTag2;
+    mTags[2]=aTag3; mTags[3]=aTag4;
+    mTags[4]=aTag5; mTags[5]=aTag6;
+    mTags[6]=aTag7; mTags[7]=aTag8;
+    mTags[8]=aTag9; mTags[9]=aTag10;  
+  }
+
+  PRInt32 GetTopmostIndexOf(nsTagStack& aTagStack);
+  PRBool  Contains(eHTMLTags aTag);
+
+  eHTMLTags mTags[10];
+  int       mCount;
+};
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool CTagList::Contains(eHTMLTags aTag){
+  return FindTagInSet(aTag,mTags,mCount);
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRInt32 CTagList::GetTopmostIndexOf(nsTagStack& aTagStack){
+  int max=aTagStack.mCount;
+  int index;
+  for(index=max-1;index>0;index--){
+    if(FindTagInSet(aTagStack.mTags[index],mTags,mCount)) {
+      return index;
+    }
+  }
+  return kNotFound;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+struct nsHTMLElement {
+
+  static  PRBool  IsBlockElement(eHTMLTags aChild);
+  static  PRBool  IsInlineElement(eHTMLTags aChild);
+  static  PRBool  IsBlockCloser(eHTMLTags aChild);
+
+  CTagList*       GetRootTags(void) const {return mRootNodes;}
+  CTagList*       GetAutoCloseStartTags(void) const {return mAutocloseStart;}
+  CTagList*       GetAutoCloseEndTags(void) const {return mAutocloseEnd;}
+
+  static  PRBool  IsBlockParent(eHTMLTags aChild);
+  static  PRBool  IsInlineParent(eHTMLTags aChild); 
+
+  CTagList*       GetSpecialChildren(void) const {return mSpecialKids;}
+  CTagList*       GetSpecialParents(void) const {return mSpecialParents;}
+    
+  eHTMLTags       GetTag(void) const {return mTagID;}
+  PRBool          CanContain(eHTMLTags aChild) const;
+  PRBool          CanOmitStartTag(eHTMLTags aChild) const;
+  PRBool          CanOmitEndTag(eHTMLTags aChild) const;
+  PRBool          CanSelfContain() const {return mSelfContained;}
+  PRBool          HasBits(PRInt32 aBitset) const;
+
+  static  PRBool  CanContain(eHTMLTags aParent,eHTMLTags aChild);
+  static  PRBool  IsContainer(eHTMLTags aTag) ;
+  static  PRBool  IsStyleTag(eHTMLTags aTag) ;
+  static  PRBool  IsTextTag(eHTMLTags aTag);
+
+  eHTMLTags   mTagID;
+  CTagList*   mRootNodes;         //These are the tags above which you many not autoclose
+  CTagList*   mAutocloseStart;    //these are the start tags that you can automatically close with this START tag
+  CTagList*   mAutocloseEnd;      //these are the start tags that you can automatically close with this END tag
+  int         mBits;              //defines parental and containment rules
+  CTagList*   mSpecialParents;    //These are the extra tags that can contain you
+  CTagList*   mSpecialKids;       //These are th extra things you can contain
+  PRBool      mSelfContained;
+}; 
+
+    
+/***************************************************************************** 
+  Now it's time to list all the html elements all with their capabilities...
+******************************************************************************/
+
+// id, hasblockparent, hasinlineparent,isBlockContainer,isInlineContainer
+
+//First, define the set of taglists for tags with special parents...
+CTagList  gAParents(1,eHTMLTag_map);
+CTagList  gInHead(1,eHTMLTag_head);
+CTagList  gInTable(1,eHTMLTag_table);
+CTagList  gInHTML(1,eHTMLTag_html);
+CTagList  gInBody(1,eHTMLTag_body);
+CTagList  gInForm(1,eHTMLTag_form);
+CTagList  gInTR(1,eHTMLTag_tr);
+CTagList  gInDL(1,eHTMLTag_dl);
+CTagList  gInFrameset(1,eHTMLTag_frameset);
+CTagList  gOptgroupParents(2,eHTMLTag_optgroup,eHTMLTag_select);
+CTagList  gBodyParents(2,eHTMLTag_html,eHTMLTag_noframes);
+CTagList  gColParents(2,eHTMLTag_colgroup,eHTMLTag_table);
+CTagList  gFramesetParents(2,eHTMLTag_frameset,eHTMLTag_html);
+CTagList  gLegendParents(1,eHTMLTag_fieldset);
+CTagList  gAreaParent(1,eHTMLTag_map);
+CTagList  gParamParents(2,eHTMLTag_applet,eHTMLTag_object);
+CTagList  gTRParents(4,eHTMLTag_tbody,eHTMLTag_tfoot,eHTMLTag_thead,eHTMLTag_table);
+
+//*********************************************************************************************
+//  Next, define the set of taglists for tags with special kids...
+//*********************************************************************************************
+CTagList  gContainsText(4,eHTMLTag_text,eHTMLTag_newline,eHTMLTag_whitespace,eHTMLTag_entity);
+CTagList  gContainsHTML(1,eHTMLTag_html);
+CTagList  gContainsOpts(2,eHTMLTag_option,eHTMLTag_optgroup);
+CTagList  gContainsParam(1,eHTMLTag_param);
+CTagList  gColgroupKids(1,eHTMLTag_col); 
+CTagList  gBodyKids(2,eHTMLTag_noscript,eHTMLTag_script);
+CTagList  gButtonKids(2,eHTMLTag_caption,eHTMLTag_legend);
+CTagList  gDLKids(2,eHTMLTag_dd,eHTMLTag_dt);
+CTagList  gDTKids(1,eHTMLTag_dt);
+CTagList  gFieldsetKids(1,eHTMLTag_legend);
+CTagList  gFormKids(1,eHTMLTag_keygen);
+CTagList  gFramesetKids(3,eHTMLTag_frame,eHTMLTag_frameset,eHTMLTag_noframes);
+CTagList  gHtmlKids(5,eHTMLTag_body,eHTMLTag_frameset,eHTMLTag_head,eHTMLTag_noscript,eHTMLTag_script);
+CTagList  gHeadKids(7,eHTMLTag_base,eHTMLTag_bgsound,eHTMLTag_link,eHTMLTag_meta,eHTMLTag_script,eHTMLTag_style,eHTMLTag_title);
+CTagList  gMapKids(1,eHTMLTag_area);
+CTagList  gNoframesKids(1,eHTMLTag_body);
+CTagList  gPreKids(1,eHTMLTag_hr);
+CTagList  gTableKids(9,eHTMLTag_caption,eHTMLTag_col,eHTMLTag_colgroup,eHTMLTag_form,eHTMLTag_map,eHTMLTag_thead,eHTMLTag_tbody,eHTMLTag_tfoot,eHTMLTag_script);
+CTagList  gTableElemKids(7,eHTMLTag_form,eHTMLTag_map,eHTMLTag_noscript,eHTMLTag_script,eHTMLTag_td,eHTMLTag_th,eHTMLTag_tr);
+CTagList  gTBodyKids(1,eHTMLTag_tr);
+CTagList  gTRKids(6,eHTMLTag_form,eHTMLTag_map,eHTMLTag_noscript,eHTMLTag_script,eHTMLTag_td,eHTMLTag_th);
+CTagList  gULKids(2,eHTMLTag_li,eHTMLTag_p);
+
+//*********************************************************************************************
+// The following tag lists are used to define common set of root notes for the HTML elements...
+//*********************************************************************************************
+CTagList  gRootTags(2,eHTMLTag_body,eHTMLTag_td);
+CTagList  gHTMLRootTags(1,eHTMLTag_unknown);
+CTagList  gLIRootTags(7,eHTMLTag_ul,eHTMLTag_ol,eHTMLTag_dir,eHTMLTag_menu,eHTMLTag_p,eHTMLTag_body,eHTMLTag_td);
+CTagList  gTextRootTags(2,eHTMLTag_p,eHTMLTag_body);
+CTagList  gTDRootTags(3,eHTMLTag_tr,eHTMLTag_tbody,eHTMLTag_table);
+CTagList  gOptionRootTags(1,eHTMLTag_select);
+
+
+//*********************************************************************************************
+// The following tag lists are used to define the autoclose properties of the html elements...
+//*********************************************************************************************
+CTagList  gAutoClose(2,eHTMLTag_body,eHTMLTag_td);
+CTagList  gBodyAutoClose(1,eHTMLTag_head);
+CTagList  gCaptionAutoClose(1,eHTMLTag_tbody);
+CTagList  gLIAutoClose(2,eHTMLTag_p,eHTMLTag_li);
+CTagList  gPAutoClose(2,eHTMLTag_p,eHTMLTag_li);
+CTagList  gHxAutoClose(6,eHTMLTag_h1,eHTMLTag_h2,eHTMLTag_h3,eHTMLTag_h4,eHTMLTag_h5,eHTMLTag_h6);
+CTagList  gTRCloseTags(2,eHTMLTag_td,eHTMLTag_th);
+CTagList  gTDCloseTags(2,eHTMLTag_td,eHTMLTag_th);
+CTagList  gDTCloseTags(2,eHTMLTag_dt,eHTMLTag_dd);
+
+ 
+static const int kNone= 0x0;
+static const int kBP  = 0x1;  //has block parent
+static const int kIP  = 0x2;  //has inline parent
+static const int kCB  = 0x4;  //can close blocks (even if it's not a block elements)
+static const int kBC  = 0x8;  //contains block child
+static const int kIC  = 0x10;  //contains inline child
+
+static const int kBPIP   = (kBP | kIP);
+static const int kBPIPIC = (kBP | kIP | kIC);
+static const int kBPBCIC = (kBP | kBC | kIC);
+static const int kBCIC   = (kBC | kIC);
+static const int kAll    = (kBPIP | kBCIC);
+
+
+//*********************************************************************************************
+//Lastly, bind tags with their rules, their special parents and special kids.
+//*********************************************************************************************
+
+static nsHTMLElement gHTMLElements[] = {
+
+  //                                                               
+  //                      Root          Autoclose-    Autoclose-      Container     Special       Special
+  //    tag-id            Nodes         starttags     endtags         -rules        Parents       Kids
+
+  {eHTMLTag_unknown,    &gRootTags,    0,              0,              kNone,        0,            &gContainsHTML},
+  {eHTMLTag_a,          &gRootTags,    0,              0,              kBPIPIC,     &gAParents,   0},
+  {eHTMLTag_abbr,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_acronym,    &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_address,    &gRootTags,    0,              0,              kBP|kIC},
+  {eHTMLTag_applet,     &gRootTags,    0,              0,              kAll,         0,            &gContainsParam},
+  {eHTMLTag_area,       &gAreaParent,  &gAutoClose,    0,              kNone},
+  
+  {eHTMLTag_b,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_base,       &gInHead,      0,              0,              kNone,        &gInHead,     0},
+  {eHTMLTag_basefont,   &gRootTags,    0,              0,              kBP},
+  {eHTMLTag_bdo,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_bgsound,    &gRootTags,    0,              0,              kBPIP,        &gInHead,     0},
+  {eHTMLTag_big,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_blink,      &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_blockquote, &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_body,       &gInHTML,      &gBodyAutoClose,0,              kBCIC|kCB,    &gBodyParents,&gBodyKids},
+  {eHTMLTag_br,         &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_button,     &gRootTags,    0,              0,              kAll,         0,            &gButtonKids},
+
+  {eHTMLTag_caption,    &gRootTags,    &gCaptionAutoClose,  0,         kIC|kCB,      &gInTable,    0},
+  {eHTMLTag_center,     &gRootTags,    0,              0,              kAll},
+  {eHTMLTag_cite,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_code,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_col,        &gColParents,  0,              0,              kNone,        &gColParents, 0},
+  {eHTMLTag_colgroup,   &gRootTags,    0,              0,              kNone,        0,            &gColgroupKids},  
+
+  {eHTMLTag_dd,         &gInDL,        &gDTCloseTags,  0,              kBCIC|kCB,    &gInDL,       0},
+  {eHTMLTag_del,        &gRootTags,    0,              0,              kAll,         0,0},
+  {eHTMLTag_dfn,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_dir,        &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_div,        &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_dl,         &gRootTags,    0,              0,              kBP|kIC,      0,            &gDLKids},
+  {eHTMLTag_dt,         &gInDL,        &gDTCloseTags,  0,              kIC|kCB,      &gInDL,       &gDTKids},
+
+  {eHTMLTag_em,         &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_embed,      &gRootTags,    0,              0,              kAll,         0,            &gContainsParam},
+
+  {eHTMLTag_fieldset,   &gRootTags,    0,              0,              kBPBCIC,   0,            &gFieldsetKids},
+  {eHTMLTag_font,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_form,       &gRootTags,    0,              0,              kAll,         0,            &gFormKids},
+  {eHTMLTag_frame,      &gInFrameset,  0,              0,              kNone,        &gInFrameset, 0},
+  {eHTMLTag_frameset,   &gInHTML,      0,              0,              kNone,        &gFramesetParents,  &gFramesetKids},
+
+  {eHTMLTag_h1,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h2,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h3,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h4,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h5,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h6,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_head,       &gInHTML,      0,              0,              kNone,        &gInHTML,     &gHeadKids},
+  {eHTMLTag_hr,         &gRootTags,    0,              0,              kBP},
+  {eHTMLTag_html,       &gHTMLRootTags,&gAutoClose,    0,              kNone,        0,            &gHtmlKids},
+  
+  {eHTMLTag_i,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_iframe,     &gRootTags,    0,              0,              kAll},
+  {eHTMLTag_ilayer,     &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_img,        &gRootTags,    0,              0,              kBPIP},  
+  {eHTMLTag_input,      &gRootTags,    0,              0,              kBPIP},  //NOT DONE!!!
+  {eHTMLTag_ins,        &gRootTags,    0,              0,              kAll,         &gInBody,     0},
+  {eHTMLTag_isindex,    &gRootTags,    0,              0,              kBP,          &gInHead,     0},
+
+  {eHTMLTag_kbd,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_keygen,     &gRootTags,    0,              0,              kNone,        &gInForm,     0},
+
+  {eHTMLTag_label,      &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_layer,      &gRootTags,    0,              0,              kAll},
+  {eHTMLTag_legend,     &gRootTags,    0,              0,              kIC,          &gLegendParents,0},
+  {eHTMLTag_li,         &gLIRootTags,  &gLIAutoClose,   0,             kAll},
+  {eHTMLTag_link,       &gInHead,      0,              0,              kNone,        &gInHead,     0},
+  {eHTMLTag_listing,    &gRootTags,    0,              0,              kAll}, 
+
+  {eHTMLTag_map,        &gRootTags,    0,              0,              kBPIP,        0,            &gMapKids},
+  {eHTMLTag_menu,       &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_meta,       &gInHead,      0,              0,              kNone,        &gInHead,     0},
+  {eHTMLTag_multicol,   &gRootTags,    0,              0,              kBPBCIC},
+
+  {eHTMLTag_nobr,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_noembed,    &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_noframes,   &gRootTags,    0,              0,              kBPBCIC,  &gInFrameset, &gNoframesKids},
+  {eHTMLTag_nolayer,    &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_noscript,   &gRootTags,    0,              0,              kBPBCIC},
+  
+  {eHTMLTag_object,     &gRootTags,    0,              0,              kAll,         0,            &gContainsParam},
+  {eHTMLTag_ol,         &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_optgroup,   &gRootTags,    0,              0,              kNone, &gOptgroupParents,   &gContainsOpts},
+  {eHTMLTag_option,     &gOptionRootTags,0,              0,            kNone, &gOptgroupParents,   &gContainsText},
+
+  //                                                               
+  //                      Root          Autoclose-    Autoclose-      Container     Special       Special
+  //    tag-id            Nodes         starttags     endtags         -rules        Parent        Kids
+
+  {eHTMLTag_p,          &gRootTags,    &gPAutoClose,   0,              kBPBCIC},
+  {eHTMLTag_param,      &gParamParents,0,              0,              kNone,    &gParamParents,   0},
+  {eHTMLTag_plaintext,  &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_pre,        &gRootTags,    0,              0,              kBP|kIC,   0,  &gPreKids},
+  {eHTMLTag_q,          &gRootTags,    0,              0,              kBPIPIC}, 
+
+  {eHTMLTag_s,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_samp,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_script,     &gRootTags,    0,              0,              kBPIP,        &gInHead,     &gContainsText},
+  {eHTMLTag_select,     &gInForm,      0,              0,              kBPIP,        0,            &gContainsOpts},
+  {eHTMLTag_server,     &gRootTags,    0,              0,              kNone},
+  {eHTMLTag_small,      &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_sound,      &gRootTags,    0,              0,              kBPIP,        &gInHead,     0},
+  {eHTMLTag_spacer,     &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_span,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_strike,     &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_strong,     &gRootTags,    0,              0,              kBPIPIC,      &gInHead,     &gContainsText},
+  {eHTMLTag_style,      &gInHead,      0,              0,              kNone,        &gInHead},
+  {eHTMLTag_sub,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_sup,        &gRootTags,    0,              0,              kBPIPIC},
+
+  {eHTMLTag_table,      &gRootTags,    0,              0,              kBP,          0,            &gTableKids},
+  {eHTMLTag_tbody,      &gInTable,     0,              0,              kNone,        &gInTable,    &gTBodyKids},
+  {eHTMLTag_td,         &gTDRootTags,  &gTDCloseTags,  0,              kBCIC|kCB,    &gInTR,       0},
+  {eHTMLTag_textarea,   &gInForm,      0,              0,              kBPIP,        0,            &gContainsText},
+  {eHTMLTag_tfoot,      &gInTable,     0,              0,              kCB,          &gInTable,    &gTableElemKids},
+  {eHTMLTag_th,         &gTDRootTags,  0,              0,              kBCIC|kCB,    &gInTR,       0},
+  {eHTMLTag_thead,      &gInTable,     0,              0,              kCB,          &gInTable,    &gTableElemKids},
+  {eHTMLTag_title,      &gInHead,      0,              0,              kNone,        &gInHead,     &gContainsText},
+  {eHTMLTag_tr,         &gTRParents,   &gTRCloseTags,  0,              kCB,          &gTRParents,  &gTRKids},
+  {eHTMLTag_tt,         &gRootTags,    0,              0,              kBPIPIC},
+
+  {eHTMLTag_u,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_ul,         &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_var,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_wbr,        &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_xmp,        &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_text,       &gTextRootTags,0,             0,              kBPIP},
+  {eHTMLTag_whitespace, &gTextRootTags,0,              0,              kBPIP},
+  {eHTMLTag_newline,    &gTextRootTags,0,              0,              kBPIP},
+  {eHTMLTag_comment,    &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_entity,     &gTextRootTags,0,              0,              kBPIP},
+  {eHTMLTag_userdefined,&gRootTags,    0,              0,              kBPIP},
+};
+
+/**
+ * This class is here to finalize the initialization of the
+ * nsHTMLElement table.
+ */
+class CTableInitializer {
+public:
+  CTableInitializer(){
+    int index=0;
+    for(index=0;index<eHTMLTag_userdefined;index++){
+      gHTMLElements[index].mSelfContained=PR_FALSE;
+      //gHTMLElements[index].mBits&=kTC;
+    }
+
+    //now initalize tags that can contain themselves...
+    int max=sizeof(gStyleTags)/sizeof(eHTMLTag_unknown);
+    for(index=0;index<max;index++){
+      gHTMLElements[gStyleTags[index]].mSelfContained=PR_TRUE;
+    }
+    gHTMLElements[eHTMLTag_frameset].mSelfContained=PR_TRUE;
+  }
+};
+CTableInitializer gTableInitializer;
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsContainer(eHTMLTags aChild) {
+  PRBool result=PR_FALSE;
+
+  if((eHTMLTag_userdefined==aChild) || (eHTMLTag_unknown==aChild))
+    result=PR_TRUE;
+  else if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    if((gHTMLElements[aChild].HasBits(kBC))  ||
+       (gHTMLElements[aChild].HasBits(kIC)) || 
+       (gHTMLElements[aChild].mSpecialKids)) {
+      result=PR_TRUE;
+    }
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsBlockElement(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kBP);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsBlockCloser(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kCB|kBP);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsInlineElement(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kIP);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsBlockParent(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kBC);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsInlineParent(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kIC);
+  } 
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanContain(eHTMLTags aParent,eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aParent>=eHTMLTag_unknown) & (aParent<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].CanContain(aChild);
+  } 
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanOmitEndTag(eHTMLTags aChild) const{
+  PRBool result=PR_FALSE;
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanOmitStartTag(eHTMLTags aChild) const{
+  PRBool result=PR_FALSE;
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::HasBits(PRInt32 aBitset) const{
+  PRBool result=(mBits & aBitset);
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsStyleTag(eHTMLTags aChild) {
+  PRBool result=FindTagInSet(aChild,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_body));
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsTextTag(eHTMLTags aChild) {
+  static eHTMLTags gTextTags[]={eHTMLTag_text,eHTMLTag_entity,eHTMLTag_newline, eHTMLTag_whitespace};
+  PRBool result=FindTagInSet(aChild,gTextTags,sizeof(gTextTags)/sizeof(eHTMLTag_body));
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanContain(eHTMLTags aChild) const{
+
+  if(IsContainer(mTagID)){
+
+    if(mTagID==aChild) {
+      return mSelfContained;  //not many tags can contain themselves...
+    }
+
+    if(nsHTMLElement::IsInlineElement(aChild)){
+      if(nsHTMLElement::IsInlineParent(mTagID)){
+        return PR_TRUE;
+      }
+    }
+
+    if(nsHTMLElement::IsTextTag(aChild)) {
+      if(nsHTMLElement::IsInlineParent(mTagID)){
+        return PR_TRUE;
+      }
+    }
+
+    if(nsHTMLElement::IsBlockElement(aChild)){
+      if(nsHTMLElement::IsBlockParent(mTagID) || IsStyleTag(mTagID)){
+        return PR_TRUE;
+      }
+    }
+
+    if(mSpecialKids) {
+      if(FindTagInSet(aChild,mSpecialKids->mTags,mSpecialKids->mCount)){
+        return PR_TRUE;
+      }
+    }
+
+    if(mTagID!=eHTMLTag_server){
+      int x=5;
+    }
+  }
+  
+  return PR_FALSE;
+}
+
+/**
+ * This method figures out what kind of child tag 
+ * you're looking at. For now, it's kind of an 
+ * expensive lookup. Later, I'll OPT-O-MIZE it.
+ * @update  gess4/6/98
+ * @param   aChildTag is who you're trying to figure out
+ * @return  eHTMLChildType value
+ */
+eHTMLCategory GetParentModelFor(eHTMLTags aChildTag) {
+  eHTMLCategory result=eHTMLCategory_unknown;
+
+  PRBool blockChild=nsHTMLElement::IsBlockElement(aChildTag);
+  PRBool inlineChild=nsHTMLElement::IsInlineElement(aChildTag);
+
+  if(blockChild & inlineChild)
+    return eHTMLCategory_blockAndInline;
+  else if(blockChild)
+    return eHTMLCategory_block;
+  else if(inlineChild)
+    return eHTMLCategory_inline;
+  else if(gHTMLElements[aChildTag].mSpecialParents==&gInHead)
+    return eHTMLCategory_head;
+  else if(gHTMLElements[aChildTag].mSpecialParents==&gInForm)
+    return eHTMLCategory_form;
+  else if(gHTMLElements[aChildTag].mSpecialParents==&gInTable)
+    return eHTMLCategory_table;
+
+  else {
+    switch(aChildTag){
+      case eHTMLTag_li:
+        result=eHTMLCategory_list;
+        break;
+      case eHTMLTag_html:
+        result=eHTMLCategory_unknown;
+        break;
+      case eHTMLTag_head:
+      case eHTMLTag_body:
+      case eHTMLTag_unknown:
+        result=eHTMLCategory_html;
+        break;
+      case eHTMLTag_tbody:
+      case eHTMLTag_thead:
+      case eHTMLTag_tfoot:
+        result=eHTMLCategory_tablepart;
+        break;
+      case eHTMLTag_tr:
+        result=eHTMLCategory_tablerow;
+        break;
+      case eHTMLTag_td:
+      case eHTMLTag_th:
+        result=eHTMLCategory_tabledata;
+        break;
+      case eHTMLTag_option:
+      case eHTMLTag_optgroup:
+        result=eHTMLCategory_options;
+        break;
+      case eHTMLTag_legend:
+        result=eHTMLCategory_text;
+        break;
+      case eHTMLTag_frameset:
+        result=eHTMLCategory_frameset;
+        break;
+      default:
+        NS_ERROR("Oops");
+        break;
+    } //switch
+  } //else
+
+  return result;
+}
+
+/**
+ * This method figures out what kind of parent tag 
+ * you're looking at. For now, it's kind of an 
+ * expensive lookup. Later, I'll OPT-O-MIZE it.
+ * @update  gess4/6/98
+ * @param   aParentTag is who you're trying to figure out
+ * @return  eHTMLChildType value
+ */
+eHTMLCategory GetContentModelFor(eHTMLTags aTag) {
+  eHTMLCategory result=eHTMLCategory_unknown;
+
+  PRBool blockParent=nsHTMLElement::IsBlockParent(aTag);
+  PRBool inlineParent=nsHTMLElement::IsInlineParent(aTag);
+
+  if(blockParent & inlineParent) { 
+    return eHTMLCategory_blockAndInline;
+  }
+  else if(blockParent) {
+    return eHTMLCategory_block;
+  }
+  else if(inlineParent) {
+    return eHTMLCategory_inline;
+  }
+  else if(gHTMLElements[aTag].mSpecialParents==&gInTable) {
+    return eHTMLCategory_table;
+  }
+  else if((aTag==eHTMLTag_ol) || (aTag==eHTMLTag_ol)) {
+    result=eHTMLCategory_list;
+  }
+  else {
+    switch(aTag){
+      case eHTMLTag_li:
+        result=eHTMLCategory_list;
+        break;
+      case eHTMLTag_html:
+      case eHTMLTag_body:
+        result=eHTMLCategory_html;
+        break;
+      case eHTMLTag_head:
+        result=eHTMLCategory_head;
+        break;
+      case eHTMLTag_unknown:
+        result=eHTMLCategory_unknown;
+        break;
+      case eHTMLTag_tbody:
+      case eHTMLTag_thead:
+      case eHTMLTag_tfoot:
+        result=eHTMLCategory_tablepart;
+        break;
+      case eHTMLTag_tr:
+        result=eHTMLCategory_tablerow;
+        break;
+      case eHTMLTag_td:
+      case eHTMLTag_th:
+        result=eHTMLCategory_tabledata;
+        break;
+      case eHTMLTag_table:
+        result=eHTMLCategory_table;
+        break;
+      case eHTMLTag_select:
+        result=eHTMLCategory_options;
+        break;
+      case eHTMLTag_frameset:
+        result=eHTMLCategory_frameset;
+        break;
+      default:
+        if(!(blockParent || inlineParent)) {
+          if(gHTMLElements[aTag].mSpecialKids==&gContainsText)
+            return eHTMLCategory_text;
+        }
+        NS_ERROR("Oops");
+        break;
+    } //switch
+  } //else
+  return result;
+}
diff --git a/htmlparser/src/nsHTMLContentSinkStream.cpp b/htmlparser/src/nsHTMLContentSinkStream.cpp
index 8f9cc6805aa0..dcf4549bd6e6 100644
--- a/htmlparser/src/nsHTMLContentSinkStream.cpp
+++ b/htmlparser/src/nsHTMLContentSinkStream.cpp
@@ -32,7 +32,7 @@
 #include "nsHTMLTokens.h"
 #include <iostream.h>
 #include "nsString.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
 static NS_DEFINE_IID(kIContentSinkIID, NS_ICONTENT_SINK_IID);
diff --git a/htmlparser/src/nsHTMLNullSink.cpp b/htmlparser/src/nsHTMLNullSink.cpp
index 1d9806e62cc4..2a1d3894b188 100644
--- a/htmlparser/src/nsHTMLNullSink.cpp
+++ b/htmlparser/src/nsHTMLNullSink.cpp
@@ -18,7 +18,7 @@
  */
 #include "nsIHTMLContentSink.h"
 #include "nsHTMLTokens.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "prtypes.h" 
 #include <iostream.h>  
 
diff --git a/htmlparser/src/nsHTMLTokenizer.cpp b/htmlparser/src/nsHTMLTokenizer.cpp
new file mode 100644
index 000000000000..f653624323c8
--- /dev/null
+++ b/htmlparser/src/nsHTMLTokenizer.cpp
@@ -0,0 +1,665 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#include "nsHTMLTokenizer.h"
+#include "nsParser.h"
+#include "nsScanner.h"
+#include "nsDTDUtils.h"
+
+/************************************************************************
+  And now for the main class -- nsHTMLTokenizer...
+ ************************************************************************/
+
+static NS_DEFINE_IID(kISupportsIID,   NS_ISUPPORTS_IID);                 
+static NS_DEFINE_IID(kITokenizerIID,  NS_ITOKENIZER_IID);
+static NS_DEFINE_IID(kClassIID,       NS_HTMLTOKENIZER_IID); 
+static CTokenDeallocator gTokenKiller;
+static CTokenRecycler gTokenRecycler;
+static nsAutoString gEmpty;
+
+/**
+ *  This method gets called as part of our COM-like interfaces.
+ *  Its purpose is to create an interface to parser object
+ *  of some type.
+ *  
+ *  @update   gess 4/8/98
+ *  @param    nsIID  id of object to discover
+ *  @param    aInstancePtr ptr to newly discovered interface
+ *  @return   NS_xxx result code
+ */
+nsresult nsHTMLTokenizer::QueryInterface(const nsIID& aIID, void** aInstancePtr)  
+{                                                                        
+  if (NULL == aInstancePtr) {                                            
+    return NS_ERROR_NULL_POINTER;                                        
+  }                                                                      
+
+  if(aIID.Equals(kISupportsIID))    {  //do IUnknown...
+    *aInstancePtr = (nsIDTD*)(this);                                        
+  }
+  else if(aIID.Equals(kITokenizerIID)) {  //do IParser base class...
+    *aInstancePtr = (nsIDTD*)(this);                                        
+  }
+  else if(aIID.Equals(kClassIID)) {  //do this class...
+    *aInstancePtr = (nsHTMLTokenizer*)(this);                                        
+  }                 
+  else {
+    *aInstancePtr=0;
+    return NS_NOINTERFACE;
+  }
+  NS_ADDREF_THIS();
+  return NS_OK;                                                        
+}
+
+
+/**
+ *  This method is defined in nsIParser. It is used to 
+ *  cause the COM-like construction of an nsParser.
+ *  
+ *  @update  gess 4/8/98
+ *  @param   nsIParser** ptr to newly instantiated parser
+ *  @return  NS_xxx error result
+ */
+NS_HTMLPARS nsresult NS_NewHTMLTokenizer(nsIDTD** aInstancePtrResult) {
+  nsHTMLTokenizer* it = new nsHTMLTokenizer();
+
+  if (it == 0) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return it->QueryInterface(kClassIID, (void **) aInstancePtrResult);
+}
+
+
+NS_IMPL_ADDREF(nsHTMLTokenizer)
+NS_IMPL_RELEASE(nsHTMLTokenizer)
+
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsHTMLTokenizer::nsHTMLTokenizer() : nsITokenizer(), mTokenDeque(gTokenKiller) {
+  NS_INIT_REFCNT();
+  mDoXMLEmptyTags=PR_FALSE;
+}
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsHTMLTokenizer::~nsHTMLTokenizer(){
+}
+
+
+/*******************************************************************
+  Here begins the real working methods for the tokenizer.
+ *******************************************************************/
+
+void AddToken(CToken*& aToken,nsresult aResult,nsDeque& aDeque) {
+  if(aToken) {
+    if(NS_SUCCEEDED(aResult)) {
+      aDeque.Push(aToken);
+    }
+    else {
+      delete aToken; 
+      aToken=0;
+    }
+  }
+}
+
+/**
+ * Retrieve a ptr to the global token recycler...
+ * @update	gess8/4/98
+ * @return  ptr to recycler (or null)
+ */
+nsITokenRecycler* nsHTMLTokenizer::GetTokenRecycler(void) {
+  return &gTokenRecycler;
+}
+
+
+/**
+ * This method provides access to the topmost token in the tokenDeque.
+ * The token is not really removed from the list.
+ * @update	gess8/2/98
+ * @return  ptr to token
+ */
+CToken* nsHTMLTokenizer::PeekToken() {
+  return (CToken*)mTokenDeque.Peek();
+}
+
+
+/**
+ * This method provides access to the topmost token in the tokenDeque.
+ * The token is really removed from the list; if the list is empty we return 0.
+ * @update	gess8/2/98
+ * @return  ptr to token or NULL
+ */
+CToken* nsHTMLTokenizer::PopToken() {
+  return (CToken*)mTokenDeque.PopFront();
+}
+
+
+/**
+ * 
+ * @update	gess8/2/98
+ * @param 
+ * @return
+ */
+CToken* nsHTMLTokenizer::PushTokenFront(CToken* theToken) {
+  mTokenDeque.PushFront(theToken);
+	return theToken;
+}
+
+/**
+ * 
+ * @update	gess8/2/98
+ * @param 
+ * @return
+ */
+CToken* nsHTMLTokenizer::PushToken(CToken* theToken) {
+  mTokenDeque.Push(theToken);
+	return theToken;
+}
+
+/**
+ * 
+ * @update	gess12/29/98
+ * @param 
+ * @return
+ */
+PRInt32 nsHTMLTokenizer::GetCount(void) {
+  return mTokenDeque.GetSize();
+}
+
+/**
+ *  This method repeatedly called by the tokenizer. 
+ *  Each time, we determine the kind of token were about to 
+ *  read, and then we call the appropriate method to handle
+ *  that token type.
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeToken(nsScanner& aScanner) {
+
+  nsresult result=NS_OK;
+  if(NS_OK==result){
+    PRUnichar theChar;
+    result=aScanner.GetChar(theChar);
+    CToken* theToken=0;
+    switch(result) {
+      case kEOF:
+          //We convert from eof to complete here, because we never really tried to get data.
+          //All we did was try to see if data was available, which it wasn't.
+          //It's important to return process complete, so that controlling logic can know that
+          //everything went well, but we're done with token processing.
+        break;
+
+      case NS_OK:
+      default:
+        switch(theChar) {
+          case kLessThan:
+            result=ConsumeTag(theChar,theToken,aScanner);
+            break;
+
+          case kAmpersand:
+            result=ConsumeEntity(theChar,theToken,aScanner);
+            break;
+          
+          case kCR: case kLF:
+            result=ConsumeNewline(theChar,theToken,aScanner);
+            break;
+          
+          case kNotFound:
+            break;
+          
+          default:
+            if(!nsString::IsSpace(theChar)) {
+              nsAutoString temp(theChar);
+              result=ConsumeText(temp,theToken,aScanner);
+              break;
+            }
+            result=ConsumeWhitespace(theChar,theToken,aScanner);
+            break;
+        } //switch
+        break; 
+    } //switch
+  } //if
+  return result;
+}
+
+
+/**
+ *  This method is called just after a "<" has been consumed 
+ *  and we know we're at the start of some kind of tagged 
+ *  element. We don't know yet if it's a tag or a comment.
+ *  
+ *  @update  gess 5/12/98
+ *  @param   aChar is the last char read
+ *  @param   aScanner is represents our input source
+ *  @param   aToken is the out arg holding our new token
+ *  @return  error code.
+ */
+nsresult nsHTMLTokenizer::ConsumeTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+
+  nsresult result=aScanner.GetChar(aChar);
+
+  if(NS_OK==result) {
+
+    switch(aChar) {
+      case kForwardSlash:
+        PRUnichar ch; 
+        result=aScanner.Peek(ch);
+        if(NS_OK==result) {
+          if(nsString::IsAlpha(ch)) {
+            result=ConsumeEndTag(aChar,aToken,aScanner);
+          }
+          else result=ConsumeComment(aChar,aToken,aScanner);
+        }//if
+        break;
+
+      case kExclamation:
+        result=ConsumeComment(aChar,aToken,aScanner);
+        break;
+
+      case kQuestionMark: //it must be an XML processing instruction...
+        result=ConsumeProcessingInstruction(aChar,aToken,aScanner);
+        break;
+
+      default:
+        if(nsString::IsAlpha(aChar))
+          result=ConsumeStartTag(aChar,aToken,aScanner);
+        else if(kEOF!=aChar) {
+          nsAutoString temp("<");
+          result=ConsumeText(temp,aToken,aScanner);
+        }
+    } //switch
+
+  } //if
+  return result;
+}
+
+/**
+ *  This method is called just after we've consumed a start
+ *  tag, and we now have to consume its attributes.
+ *  
+ *  @update  gess 3/25/98
+ *  @param   aChar: last char read
+ *  @param   aScanner: see nsScanner.h
+ *  @return  
+ */
+nsresult nsHTMLTokenizer::ConsumeAttributes(PRUnichar aChar,CStartToken* aToken,nsScanner& aScanner) {
+  PRBool done=PR_FALSE;
+  nsresult result=NS_OK;
+  PRInt16 theAttrCount=0;
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+
+  while((!done) && (result==NS_OK)) {
+    CToken* theToken= (CAttributeToken*)theRecycler->CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
+    if(theToken){
+      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+ 
+      //Much as I hate to do this, here's some special case code.
+      //This handles the case of empty-tags in XML. Our last
+      //attribute token will come through with a text value of ""
+      //and a textkey of "/". We should destroy it, and tell the 
+      //start token it was empty.
+      if(NS_SUCCEEDED(result)) {
+        nsString& key=((CAttributeToken*)theToken)->GetKey();
+        nsString& text=theToken->GetStringValueXXX();
+        if((mDoXMLEmptyTags) && (key[0]==kForwardSlash) && (0==text.Length())){
+          //tada! our special case! Treat it like an empty start tag...
+          aToken->SetEmpty(PR_TRUE);
+          theRecycler->RecycleToken(theToken);
+        }
+        else {
+          theAttrCount++;
+          AddToken(theToken,result,mTokenDeque);
+        }
+      }
+    }//if
+    
+    if(NS_SUCCEEDED(result)){
+      result=aScanner.Peek(aChar);
+      if(aChar==kGreaterThan) { //you just ate the '>'
+        aScanner.GetChar(aChar); //skip the '>'
+        done=PR_TRUE;
+      }//if
+    }//if
+  }//while
+
+  aToken->SetAttributeCount(theAttrCount);
+  return result;
+}
+
+/**
+ *  This is a special case method. It's job is to consume 
+ *  all of the given tag up to an including the end tag.
+ *
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null
+ */
+nsresult nsHTMLTokenizer::ConsumeContentToEndTag(PRUnichar aChar,
+                                eHTMLTags aChildTag,
+                                nsScanner& aScanner,
+                                CToken*& aToken){
+  
+  //In the case that we just read the given tag, we should go and
+  //consume all the input until we find a matching end tag.
+
+  nsAutoString endTag("</");
+  endTag.Append(NS_EnumToTag(aChildTag));
+  endTag.Append(">");
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_skippedcontent,aChildTag,endTag);
+  return aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+}
+
+/**
+ *  This method is called just after a "<" has been consumed 
+ *  and we know we're at the start of a tag.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+
+static eHTMLTags gSkippedContentTags[]=
+  { eHTMLTag_noscript,
+    eHTMLTag_plaintext, eHTMLTag_script,   eHTMLTag_style, 
+    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
+
+static eHTMLTags gSkippedContentTargets[]=
+  { eHTMLTag_noscript,
+    eHTMLTag_html,      eHTMLTag_script,   eHTMLTag_style, 
+    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
+
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsHTMLTokenizer::HandleSkippedContent(nsScanner& aScanner,CToken*& aToken) {
+  nsresult result=NS_OK;
+
+  eHTMLTags theTag=(eHTMLTags)aToken->GetTypeID();
+  PRInt32 theIndex=IndexOfTagInSet(theTag,gSkippedContentTags,sizeof(gSkippedContentTags)/sizeof(eHTMLTag_unknown));
+  if(-1<theIndex) {
+
+      //Do special case handling for <script>, <style>, <title> or <textarea>...
+    CToken*   skippedToken=0;
+    PRUnichar theChar;
+    result=ConsumeContentToEndTag(theChar,gSkippedContentTargets[theIndex],aScanner,skippedToken);
+
+    if((NS_OK==result) && skippedToken){
+      AddToken(skippedToken,result,mTokenDeque);
+
+      //In the case that we just read a given tag, we should go and
+      //consume all the tag content itself (and throw it all away).
+
+      CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+      nsString& theTagStr=skippedToken->GetStringValueXXX();
+      CToken* endtoken=theRecycler->CreateTokenOfType(eToken_end,theTag,theTagStr);
+      if(endtoken){
+        endtoken->Reinitialize(theTag,theTagStr);
+        AddToken(endtoken,result,mTokenDeque);
+      }
+    } //if
+  } //if
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsHTMLTokenizer::ConsumeStartTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+  PRInt32 theDequeSize=mTokenDeque.GetSize(); //remember this for later in case you have to unwind...
+  nsresult result=NS_OK;
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
+  
+  if(aToken) {
+    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+    if(NS_SUCCEEDED(result)) {
+     
+      AddToken(aToken,result,mTokenDeque);
+      eHTMLTags theTag=(eHTMLTags)aToken->GetTypeID();
+      
+      if(((CStartToken*)aToken)->IsAttributed()) {
+        result=ConsumeAttributes(aChar,(CStartToken*)aToken,aScanner);
+      }
+
+      //now that that's over with, we have one more problem to solve.
+      //In the case that we just read a <SCRIPT> or <STYLE> tags, we should go and
+      //consume all the content itself.
+      if(NS_SUCCEEDED(result)) {
+        result=HandleSkippedContent(aScanner,aToken);
+      }
+ 
+      //EEEEECCCCKKKK!!! 
+      //This code is confusing, so pay attention.
+      //If you're here, it's because we were in the midst of consuming a start
+      //tag but ran out of data (not in the stream, but in this *part* of the stream.
+      //For simplicity, we have to unwind our input. Therefore, we pop and discard
+      //any new tokens we've cued this round. Later we can get smarter about this.
+      if(!NS_SUCCEEDED(result)) {
+        while(mTokenDeque.GetSize()>theDequeSize) {
+          theRecycler->RecycleToken((CToken*)mTokenDeque.Pop());
+        }
+      }
+    } //if
+  } //if
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsHTMLTokenizer::ConsumeEndTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
+  nsresult result=NS_OK;
+  
+  if(aToken) {
+    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+    AddToken(aToken,result,mTokenDeque);
+  } //if
+  return result;
+}
+
+/**
+ *  This method is called just after a "&" has been consumed 
+ *  and we know we're at the start of an entity.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeEntity(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+   PRUnichar  theChar;
+   nsresult result=aScanner.GetChar(theChar);
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  if(NS_OK==result) {
+    if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
+       aToken = theRecycler->CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
+       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
+    }
+    else if(kHashsign==theChar) {
+       aToken = theRecycler->CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
+       result=aToken->Consume(0,aScanner);
+    }
+    else {
+       //oops, we're actually looking at plain text...
+       nsAutoString temp("&");
+       aScanner.PutBack(theChar);
+       return ConsumeText(temp,aToken,aScanner);
+    }//if
+    AddToken(aToken,result,mTokenDeque);
+  }//if
+  return result;
+}
+
+
+/**
+ *  This method is called just after whitespace has been 
+ *  consumed and we know we're at the start a whitespace run.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeWhitespace(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken = theRecycler->CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+/**
+ *  This method is called just after a "<!" has been consumed 
+ *  and we know we're at the start of a comment.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeComment(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner){
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken = theRecycler->CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+/**
+ *  This method is called just after a known text char has
+ *  been consumed and we should read a text run.
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */ 
+nsresult nsHTMLTokenizer::ConsumeText(const nsString& aString,CToken*& aToken,nsScanner& aScanner){
+  nsresult result=NS_OK;
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
+  if(aToken) {
+    PRUnichar ch=0;
+    result=aToken->Consume(ch,aScanner);
+    if(result) {
+      nsString& temp=aToken->GetStringValueXXX();
+      if(0==temp.Length()){
+        delete aToken;
+        aToken = nsnull;
+      }
+      else result=NS_OK;
+    }
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+/**
+ *  This method is called just after a newline has been consumed. 
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  aToken is the newly created newline token that is parsing
+ *  @return error code
+ */
+nsresult nsHTMLTokenizer::ConsumeNewline(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner){
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+
+/**
+ *  This method is called just after a ? has been consumed. 
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  aToken is the newly created newline token that is parsing
+ *  @return error code
+ */
+nsresult nsHTMLTokenizer::ConsumeProcessingInstruction(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner){
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
diff --git a/htmlparser/src/nsHTMLTokenizer.h b/htmlparser/src/nsHTMLTokenizer.h
new file mode 100644
index 000000000000..a2f1b8427bd1
--- /dev/null
+++ b/htmlparser/src/nsHTMLTokenizer.h
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#ifndef __NSHTMLTOKENIZER
+#define __NSHTMLTOKENIZER
+
+#include "nsISupports.h"
+#include "nsITokenizer.h"
+#include "nsIDTD.h"
+#include "prtypes.h"
+#include "nsDeque.h"
+#include "nsScanner.h"
+#include "nsHTMLTokens.h"
+
+#define NS_HTMLTOKENIZER_IID      \
+  {0xe4238ddd, 0x9eb6, 0x11d2, \
+  {0xba, 0xa5, 0x0,     0x10, 0x4b, 0x98, 0x3f, 0xd4 }}
+
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+#if defined(XP_PC)
+#pragma warning( disable : 4275 )
+#endif
+
+CLASS_EXPORT_HTMLPARS nsHTMLTokenizer : public nsITokenizer {
+public:
+            nsHTMLTokenizer();
+            ~nsHTMLTokenizer();
+
+            NS_DECL_ISUPPORTS
+
+  virtual nsresult          ConsumeToken(nsScanner& aScanner);
+  virtual nsITokenRecycler* GetTokenRecycler(void);
+
+  virtual CToken*           PushTokenFront(CToken* theToken);
+  virtual CToken*           PushToken(CToken* theToken);
+	virtual CToken*           PopToken(void);
+	virtual CToken*           PeekToken(void);
+	virtual PRInt32           GetCount(void);
+
+protected:
+
+  virtual nsresult HandleSkippedContent(nsScanner& aScanner,CToken*& aToken);
+  virtual nsresult ConsumeTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeStartTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeEndTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeAttributes(PRUnichar aChar,CStartToken* aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeEntity(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeWhitespace(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeComment(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeNewline(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeText(const nsString& aString,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeContentToEndTag(PRUnichar aChar,eHTMLTags aChildTag,nsScanner& aScanner,CToken*& aToken);
+  virtual nsresult ConsumeProcessingInstruction(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+
+protected:
+  
+  nsDeque mTokenDeque;
+  PRBool  mDoXMLEmptyTags;
+};
+
+extern NS_HTMLPARS nsresult NS_NewHTMLTokenizer(nsIDTD** aInstancePtrResult);
+
+#endif
+
+
diff --git a/htmlparser/src/nsHTMLTokens.cpp b/htmlparser/src/nsHTMLTokens.cpp
index a2c8e0d1383c..2f5be8759c66 100644
--- a/htmlparser/src/nsHTMLTokens.cpp
+++ b/htmlparser/src/nsHTMLTokens.cpp
@@ -23,7 +23,7 @@
 #include "nsScanner.h"
 #include "nsToken.h" 
 #include "nsHTMLTokens.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "prtypes.h"
 #include "nsDebug.h"
 #include "nsHTMLTags.h"
@@ -212,7 +212,7 @@ PRBool CStartToken::IsEmpty(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CStartToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CStartToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
   //if you're here, we've already Consumed the < char, and are
    //ready to Consume the rest of the open tag identifier.
@@ -235,14 +235,14 @@ nsresult CStartToken::Consume(PRUnichar aChar, CScanner& aScanner) {
       if(NS_OK==result) {
         if(kGreaterThan!=aChar) { //look for '>' 
          //push that char back, since we apparently have attributes...
-          aScanner.PutBack(aChar);
+          result=aScanner.PutBack(aChar);
           mAttributed=PR_TRUE;
         } //if
       } //if
     }//if
   }
   return result;
-};
+}
 
 
 /*
@@ -290,7 +290,7 @@ CEndToken::CEndToken(const nsString& aName) : CHTMLToken(aName) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CEndToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CEndToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
   //if you're here, we've already Consumed the <! chars, and are
    //ready to Consume the rest of the open tag identifier.
@@ -300,26 +300,26 @@ nsresult CEndToken::Consume(PRUnichar aChar, CScanner& aScanner) {
   mTextValue="";
   nsresult result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_FALSE);
 
-  char buffer[300];
-  mTextValue.ToCString(buffer,sizeof(buffer)-1);
+  if(NS_OK==result){
+    char buffer[300];
+    mTextValue.ToCString(buffer,sizeof(buffer)-1);
 
-  //This code was added to fix Bug#1125.
-  //The problem occurs in bad tags like this: </font size>.
-  //"font size" was being viewed as the tag, which of course doesn't exist.
-  //Instead, we only look at the first word.
-  int theBufPos=-1;
-  while(buffer[++theBufPos]){
-    if(kSpace==buffer[theBufPos]){ 
-      buffer[theBufPos]=0;
-      break;
+    //This code was added to fix Bug#1125.
+    //The problem occurs in bad tags like this: </font size>.
+    //"font size" was being viewed as the tag, which of course doesn't exist.
+    //Instead, we only look at the first word.
+    int theBufPos=-1;
+    while(buffer[++theBufPos]){
+      if(kSpace==buffer[theBufPos]){ 
+        buffer[theBufPos]=0;
+        break;
+      }
     }
-  }
-  mTypeID= NS_TagToEnum(buffer);
-
-  if(NS_OK==result)
+    mTypeID= NS_TagToEnum(buffer);
     result=aScanner.GetChar(aChar); //eat the closing '>;
+  }
   return result;
-};
+}
 
 
 /*
@@ -437,7 +437,7 @@ PRInt32 CTextToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CTextToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CTextToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   static    nsAutoString terminals("&<\r");
   nsresult  result=NS_OK;
   PRBool    done=PR_FALSE;
@@ -446,22 +446,24 @@ nsresult CTextToken::Consume(PRUnichar aChar, CScanner& aScanner) {
     result=aScanner.ReadUntil(mTextValue,terminals,PR_FALSE,PR_FALSE);
     if(NS_OK==result) {
       result=aScanner.Peek(aChar);
-      if(kCR==aChar) {
+      if((kCR==aChar) && (NS_OK==result)) {
         result=aScanner.GetChar(aChar); //strip off the \r
         result=aScanner.Peek(aChar);    //then see what's next.
-        switch(aChar) {
-          case kCR:
-            result=aScanner.GetChar(aChar); //strip off the \r
-            mTextValue.Append("\n\n");
-            break;
-          case kNewLine:
-             //which means we saw \r\n, which becomes \n
-            result=aScanner.GetChar(aChar); //strip off the \n
-                //now fall through on purpose...
-          default:
-            mTextValue.Append("\n");
-            break;
-        }
+        if(NS_OK==result) {
+          switch(aChar) {
+            case kCR:
+              result=aScanner.GetChar(aChar); //strip off the \r
+              mTextValue.Append("\n\n");
+              break;
+            case kNewLine:
+               //which means we saw \r\n, which becomes \n
+              result=aScanner.GetChar(aChar); //strip off the \n
+                  //now fall through on purpose...
+            default:
+              mTextValue.Append("\n");
+              break;
+          }//switch
+        }//if
       }
       else done=PR_TRUE;
     }
@@ -503,7 +505,6 @@ const char*  CCDATASectionToken::GetClassName(void) {
 }
 
 /*
- *  
  *  
  *  @update  vidur 11/12/98
  *  @param   
@@ -521,7 +522,7 @@ PRInt32 CCDATASectionToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CCDATASectionToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CCDATASectionToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   static    nsAutoString terminals("]\r");
   nsresult  result=NS_OK;
   PRBool    done=PR_FALSE;
@@ -530,37 +531,41 @@ nsresult CCDATASectionToken::Consume(PRUnichar aChar, CScanner& aScanner) {
     result=aScanner.ReadUntil(mTextValue,terminals,PR_FALSE,PR_FALSE);
     if(NS_OK==result) {
       result=aScanner.Peek(aChar);
-      if(kCR==aChar) {
+      if((kCR==aChar) && (NS_OK==result)) {
         result=aScanner.GetChar(aChar); //strip off the \r
         result=aScanner.Peek(aChar);    //then see what's next.
-        switch(aChar) {
-          case kCR:
-            result=aScanner.GetChar(aChar); //strip off the \r
-            mTextValue.Append("\n\n");
-            break;
-          case kNewLine:
-             //which means we saw \r\n, which becomes \n
-            result=aScanner.GetChar(aChar); //strip off the \n
-                //now fall through on purpose...
-          default:
-            mTextValue.Append("\n");
-            break;
-        }
+        if(NS_OK==result) {
+          switch(aChar) {
+            case kCR:
+              result=aScanner.GetChar(aChar); //strip off the \r
+              mTextValue.Append("\n\n");
+              break;
+            case kNewLine:
+               //which means we saw \r\n, which becomes \n
+              result=aScanner.GetChar(aChar); //strip off the \n
+                  //now fall through on purpose...
+            default:
+              mTextValue.Append("\n");
+              break;
+          } //switch
+        } //if
       }
       else if (kRightSquareBracket==aChar) {
         result=aScanner.GetChar(aChar); //strip off the ]
         result=aScanner.Peek(aChar);    //then see what's next.
-        if (kRightSquareBracket==aChar) {
+        if((NS_OK==result) && (kRightSquareBracket==aChar)) {
           result=aScanner.GetChar(aChar);    //strip off the second ]
           result=aScanner.Peek(aChar);    //then see what's next.
-          if (kGreaterThan==aChar) {
-            result=aScanner.GetChar(aChar); //strip off the >
-            done=PR_TRUE;
-          }
-          else {
-            // This isn't the end of the CDATA section so go on
-            mTextValue.Append("]");
-          }
+          if(NS_OK==result) {
+            if (kGreaterThan==aChar) {
+              result=aScanner.GetChar(aChar); //strip off the >
+              done=PR_TRUE;
+            }
+            else {
+              // This isn't the end of the CDATA section so go on
+              mTextValue.Append("]");
+            }
+          }//if
         }
         else {
           // This isn't the end of the CDATA section so go on
@@ -573,6 +578,7 @@ nsresult CCDATASectionToken::Consume(PRUnichar aChar, CScanner& aScanner) {
   return result;
 }
 
+
 /*
  *  default constructor
  *  
@@ -604,29 +610,30 @@ CCommentToken::CCommentToken(const nsString& aName) : CHTMLToken(aName) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CCommentToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CCommentToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
   nsresult  result=NS_OK;
     
-  aScanner.GetChar(aChar);
-  mTextValue="<!";
-  if(kMinus==aChar) {
-    mTextValue+="-";
-    result=aScanner.GetChar(aChar);
-    if(NS_OK==result) {
-      if(kMinus==aChar) {
-           //in this case, we're reading a long-form comment <-- xxx -->
-        mTextValue+="-";
-        PRInt32 findpos=-1;
-        while((findpos==kNotFound) && (NS_OK==result)) {
-          result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_TRUE);
-          findpos=mTextValue.RFind("-->");
+  result=aScanner.GetChar(aChar);
+  if(NS_OK==result) {
+    mTextValue="<!";
+    if(kMinus==aChar) {
+      mTextValue+="-";
+      result=aScanner.GetChar(aChar);
+      if(NS_OK==result) {
+        if(kMinus==aChar) {
+             //in this case, we're reading a long-form comment <-- xxx -->
+          mTextValue+="-";
+          PRInt32 findpos=-1;
+          while((findpos==kNotFound) && (NS_OK==result)) {
+            result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_TRUE);
+            findpos=mTextValue.RFind("-->");
+          }
+          return result;
         }
-        return result;
       }
     }
   }
-
   if(NS_OK==result) {
      //if you're here, we're consuming a "short-form" comment
     mTextValue+=aChar;
@@ -721,7 +728,7 @@ nsString& CNewlineToken::GetStringValueXXX(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CNewlineToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CNewlineToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   mTextValue=aChar;
 
     //we already read the \r or \n, let's see what's next!
@@ -843,18 +850,18 @@ void CAttributeToken::DebugDumpToken(ostream& out) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-PRInt32 ConsumeQuotedString(PRUnichar aChar,nsString& aString,CScanner& aScanner){
-  PRInt32 result=kNotFound;
+nsresult ConsumeQuotedString(PRUnichar aChar,nsString& aString,nsScanner& aScanner){
+  nsresult result=NS_OK;
   switch(aChar) {
     case kQuote:
       result=aScanner.ReadUntil(aString,kQuote,PR_TRUE);
-      if(kNoError==result)
-        aScanner.SkipOver(kQuote);  //this code is here in case someone mistakenly adds multiple quotes...
+      if(NS_OK==result)
+        result=aScanner.SkipOver(kQuote);  //this code is here in case someone mistakenly adds multiple quotes...
       break;
     case kApostrophe:
       result=aScanner.ReadUntil(aString,kApostrophe,PR_TRUE);
-      if(kNoError==result)
-        aScanner.SkipOver(kApostrophe); //this code is here in case someone mistakenly adds multiple apostrophes...
+      if(NS_OK==result)
+        result=aScanner.SkipOver(kApostrophe); //this code is here in case someone mistakenly adds multiple apostrophes...
       break;
     default:
       break;
@@ -874,12 +881,9 @@ PRInt32 ConsumeQuotedString(PRUnichar aChar,nsString& aString,CScanner& aScanner
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-PRInt32 ConsumeAttributeValueText(PRUnichar,nsString& aString,CScanner& aScanner){
-
-  PRInt32 result=kNotFound;
+nsresult ConsumeAttributeValueText(PRUnichar,nsString& aString,nsScanner& aScanner){
   static nsAutoString terminals("\b\t\n\r >");
-
-  result=aScanner.ReadUntil(aString,terminals,PR_FALSE,PR_FALSE);
+  nsresult result=aScanner.ReadUntil(aString,terminals,PR_FALSE,PR_FALSE);
   return result;
 }
 
@@ -892,81 +896,86 @@ PRInt32 ConsumeAttributeValueText(PRUnichar,nsString& aString,CScanner& aScanner
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CAttributeToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CAttributeToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
-  aScanner.SkipWhitespace();             //skip leading whitespace                                      
-  nsresult result=aScanner.Peek(aChar);
+  nsresult result=aScanner.SkipWhitespace();             //skip leading whitespace 
   if(NS_OK==result) {
-    if(kQuote==aChar) {               //if you're here, handle quoted key...
-      result=aScanner.GetChar(aChar);        //skip the quote sign...
-      if(NS_OK==result) {
-        mTextKey=aChar;
-        result=ConsumeQuotedString(aChar,mTextKey,aScanner);
-      }
-    }
-    else if(kHashsign==aChar) {
-      result=aScanner.GetChar(aChar);        //skip the hash sign...
-      if(NS_OK==result) {
-        mTextKey=aChar;
-        result=aScanner.ReadWhile(mTextKey,gDigits,PR_TRUE,PR_TRUE);
-      }
-    }
-    else {
-        //If you're here, handle an unquoted key.
-        //Don't forget to reduce entities inline!
-      static nsAutoString terminals("\b\t\n\r \"=>");
-      result=aScanner.ReadUntil(mTextKey,terminals,PR_TRUE,PR_FALSE);
-    }
-
-      //now it's time to Consume the (optional) value...
-    if(NS_OK == (result=aScanner.SkipWhitespace())) { 
-      //Skip ahead until you find an equal sign or a '>'...
-      if(NS_OK == (result=aScanner.Peek(aChar))) {  
-        if(kEqual==aChar){
-          result=aScanner.GetChar(aChar);  //skip the equal sign...
-          if(NS_OK==result) {
-            result=aScanner.SkipWhitespace();     //now skip any intervening whitespace
-            if(NS_OK==result) {
-              result=aScanner.GetChar(aChar);  //and grab the next char.    
-              if(NS_OK==result) {
-                if((kQuote==aChar) || (kApostrophe==aChar)) {
-                  mTextValue=aChar;
-                  result=ConsumeQuotedString(aChar,mTextValue,aScanner);
-                }
-                else if(kGreaterThan==aChar){      
-                  aScanner.PutBack(aChar);
-                }
-                else {
-                  mTextValue=aChar;       //it's an alphanum attribute...
-                  result=ConsumeAttributeValueText(aChar,mTextValue,aScanner);
-                } 
-              }//if
-              if(NS_OK==result)
-                result=aScanner.SkipWhitespace();     
-            }//if
-          }//if
-        }//if
-        else {
-          //This is where we have to handle fairly busted content.
-          //If you're here, it means we saw an attribute name, but couldn't find 
-          //the following equal sign.  <tag NAME=....
-          
-          //Doing this right in all cases is <i>REALLY</i> ugly. 
-          //My best guess is to grab the next non-ws char. We know it's not '=',
-          //so let's see what it is. If it's a '"', then assume we're reading
-          //from the middle of the value. Try stripping the quote and continuing...
-
-          if(kQuote==aChar){
-            result=aScanner.SkipOver(aChar); //strip quote.
-          }
-        }
-      }//if
-    }
+    result=aScanner.Peek(aChar);
     if(NS_OK==result) {
-      result=aScanner.Peek(aChar);
-      mLastAttribute= PRBool((kGreaterThan==aChar) || (kEOF==result));
-    }
-  }
+      if(kQuote==aChar) {               //if you're here, handle quoted key...
+        result=aScanner.GetChar(aChar);        //skip the quote sign...
+        if(NS_OK==result) {
+          mTextKey=aChar;
+          result=ConsumeQuotedString(aChar,mTextKey,aScanner);
+        }
+      }
+      else if(kHashsign==aChar) {
+        result=aScanner.GetChar(aChar);        //skip the hash sign...
+        if(NS_OK==result) {
+          mTextKey=aChar;
+          result=aScanner.ReadWhile(mTextKey,gDigits,PR_TRUE,PR_FALSE);
+        }
+      }
+      else {
+          //If you're here, handle an unquoted key.
+          //Don't forget to reduce entities inline!
+        static nsAutoString terminals("\b\t\n\r \"=>");
+        result=aScanner.ReadUntil(mTextKey,terminals,PR_TRUE,PR_FALSE);
+      }
+
+        //now it's time to Consume the (optional) value...
+      if(NS_OK==result) {
+        result=aScanner.SkipWhitespace();
+        if(NS_OK==result) { 
+          result=aScanner.Peek(aChar);       //Skip ahead until you find an equal sign or a '>'...
+          if(NS_OK==result) {  
+            if(kEqual==aChar){
+              result=aScanner.GetChar(aChar);  //skip the equal sign...
+              if(NS_OK==result) {
+                result=aScanner.SkipWhitespace();     //now skip any intervening whitespace
+                if(NS_OK==result) {
+                  result=aScanner.GetChar(aChar);  //and grab the next char.    
+                  if(NS_OK==result) {
+                    if((kQuote==aChar) || (kApostrophe==aChar)) {
+                      mTextValue=aChar;
+                      result=ConsumeQuotedString(aChar,mTextValue,aScanner);
+                    }
+                    else if(kGreaterThan==aChar){      
+                      result=aScanner.PutBack(aChar);
+                    }
+                    else {
+                      mTextValue=aChar;       //it's an alphanum attribute...
+                      result=ConsumeAttributeValueText(aChar,mTextValue,aScanner);
+                    } 
+                  }//if
+                  if(NS_OK==result)
+                    result=aScanner.SkipWhitespace();     
+                }//if
+              }//if
+            }//if
+            else {
+              //This is where we have to handle fairly busted content.
+              //If you're here, it means we saw an attribute name, but couldn't find 
+              //the following equal sign.  <tag NAME=....
+          
+              //Doing this right in all cases is <i>REALLY</i> ugly. 
+              //My best guess is to grab the next non-ws char. We know it's not '=',
+              //so let's see what it is. If it's a '"', then assume we're reading
+              //from the middle of the value. Try stripping the quote and continuing...
+
+              if(kQuote==aChar){
+                result=aScanner.SkipOver(aChar); //strip quote.
+              }
+            }
+          }//if
+        } //if
+      }//if
+      if(NS_OK==result) {
+        result=aScanner.Peek(aChar);
+        mLastAttribute= PRBool((kGreaterThan==aChar) || (kEOF==result));
+      }
+    } //if
+  }//if
   return result;
 }
 
@@ -1042,7 +1051,7 @@ PRInt32 CWhitespaceToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CWhitespaceToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CWhitespaceToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   
   mTextValue=aChar;
 
@@ -1088,7 +1097,7 @@ CEntityToken::CEntityToken(const nsString& aName) : CHTMLToken(aName) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CEntityToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CEntityToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   if(aChar)
     mTextValue=aChar;
   nsresult result=ConsumeEntity(aChar,mTextValue,aScanner);
@@ -1127,17 +1136,17 @@ PRInt32 CEntityToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-PRInt32 CEntityToken::ConsumeEntity(PRUnichar aChar,nsString& aString,CScanner& aScanner){
+PRInt32 CEntityToken::ConsumeEntity(PRUnichar aChar,nsString& aString,nsScanner& aScanner){
 
   PRInt32 result=aScanner.Peek(aChar);
-  if(kNoError==result) {
+  if(NS_OK==result) {
     if(kLeftBrace==aChar) {
       //you're consuming a script entity...
       static nsAutoString terminals("}>");
       result=aScanner.ReadUntil(aString,terminals,PR_FALSE,PR_FALSE);
-      if(kNoError==result) {
+      if(NS_OK==result) {
         result=aScanner.Peek(aChar);
-        if(kNoError==result) {
+        if(NS_OK==result) {
           if(kRightBrace==aChar) {
             aString+=kRightBrace;   //append rightbrace, and...
             result=aScanner.GetChar(aChar);//yank the closing right-brace
@@ -1147,9 +1156,9 @@ PRInt32 CEntityToken::ConsumeEntity(PRUnichar aChar,nsString& aString,CScanner&
     } //if
     else {
       result=aScanner.ReadWhile(aString,gIdentChars,PR_TRUE,PR_FALSE);
-      if(kNoError==result) {
+      if(NS_OK==result) {
         result=aScanner.Peek(aChar);
-        if(kNoError==result) {
+        if(NS_OK==result) {
           if (kSemicolon == aChar) {
             // consume semicolon that stopped the scan
             result=aScanner.GetChar(aChar);
@@ -1371,9 +1380,9 @@ PRInt32 CSkippedContentToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source 
  *  @return  error result 
  */ 
-nsresult CSkippedContentToken::Consume(PRUnichar aChar,CScanner& aScanner) { 
+nsresult CSkippedContentToken::Consume(PRUnichar aChar,nsScanner& aScanner) { 
   PRBool      done=PR_FALSE; 
-  PRInt32     result=kNoError; 
+  nsresult    result=NS_OK; 
   nsString    temp; 
   PRUnichar   theChar;
 
@@ -1382,16 +1391,16 @@ nsresult CSkippedContentToken::Consume(PRUnichar aChar,CScanner& aScanner) {
  //If we find either, just eat them. If we find text or a tag, then go to the 
  //target endtag, or the start of another comment. 
 
-  while((!done) && (kNoError==result)) { 
+  while((!done) && (NS_OK==result)) { 
     result=aScanner.GetChar(aChar); 
-    if((kNoError==result) && (kLessThan==aChar)) { 
+    if((NS_OK==result) && (kLessThan==aChar)) { 
       //we're reading a tag or a comment... 
       result=aScanner.GetChar(theChar); 
-      if((kNoError==result) && (kExclamation==theChar)) { 
+      if((NS_OK==result) && (kExclamation==theChar)) { 
         //read a comment... 
         static CCommentToken theComment; 
         result=theComment.Consume(aChar,aScanner); 
-        if(kNoError==result) { 
+        if(NS_OK==result) { 
           temp.Append(theComment.GetStringValueXXX()); 
         } 
       } else { 
@@ -1404,7 +1413,7 @@ nsresult CSkippedContentToken::Consume(PRUnichar aChar,CScanner& aScanner) {
     else if(0<=gWhitespace.BinarySearch(aChar)) { 
       static CWhitespaceToken theWS; 
       result=theWS.Consume(aChar,aScanner); 
-      if(kNoError==result) { 
+      if(NS_OK==result) { 
         temp.Append(theWS.GetStringValueXXX()); 
       } 
     } 
@@ -1465,7 +1474,7 @@ CInstructionToken::CInstructionToken(const nsString& aString) : CHTMLToken(aStri
  *  @param   
  *  @return  
  */
-nsresult CInstructionToken::Consume(PRUnichar aChar,CScanner& aScanner){
+nsresult CInstructionToken::Consume(PRUnichar aChar,nsScanner& aScanner){
   mTextValue="<?";
   nsresult result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_TRUE);
   return result;
diff --git a/htmlparser/src/nsHTMLTokens.h b/htmlparser/src/nsHTMLTokens.h
index 34c7105b0c1d..84dbb5cd3fc6 100644
--- a/htmlparser/src/nsHTMLTokens.h
+++ b/htmlparser/src/nsHTMLTokens.h
@@ -43,7 +43,7 @@
 #include "nsHTMLTags.h"
 #include <iostream.h>
 
-class CScanner;
+class nsScanner;
 
   /*******************************************************************
    * This enum defines the set of token types that we currently support.
@@ -58,12 +58,32 @@ enum eHTMLTokenTypes {
   eToken_last //make sure this stays the last token...
 };
 
+enum eHTMLCategory {
+  eHTMLCategory_unknown=0,
+  eHTMLCategory_inline,
+  eHTMLCategory_block,
+  eHTMLCategory_blockAndInline,
+  eHTMLCategory_list,
+  eHTMLCategory_table,
+  eHTMLCategory_tablepart,
+  eHTMLCategory_tablerow,
+  eHTMLCategory_tabledata,
+  eHTMLCategory_head,
+  eHTMLCategory_html,
+  eHTMLCategory_body,
+  eHTMLCategory_form,
+  eHTMLCategory_options,
+  eHTMLCategory_frameset,
+  eHTMLCategory_text
+};
+
+
 #define eHTMLTags nsHTMLTag
 
-PRInt32         ConsumeQuotedString(PRUnichar aChar,nsString& aString,CScanner& aScanner);
-PRInt32         ConsumeAttributeText(PRUnichar aChar,nsString& aString,CScanner& aScanner);
-const char*     GetTagName(PRInt32 aTag);
-//PRInt32         FindEntityIndex(nsString& aString,PRInt32 aCount=-1);
+nsresult      ConsumeQuotedString(PRUnichar aChar,nsString& aString,nsScanner& aScanner);
+nsresult      ConsumeAttributeText(PRUnichar aChar,nsString& aString,nsScanner& aScanner);
+const char*   GetTagName(PRInt32 aTag);
+//PRInt32     FindEntityIndex(nsString& aString,PRInt32 aCount=-1);
 
 
 /**
@@ -90,7 +110,7 @@ class CStartToken: public CHTMLToken {
   public:
                         CStartToken(eHTMLTags aTag);
                         CStartToken(nsString& aName,eHTMLTags aTag=eHTMLTag_unknown);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual PRInt32     GetTypeID(void);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
@@ -119,7 +139,7 @@ class CEndToken: public CHTMLToken {
   public:
                         CEndToken(eHTMLTags aTag);
                         CEndToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual PRInt32     GetTypeID(void);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
@@ -139,7 +159,7 @@ class CCommentToken: public CHTMLToken {
   public:
                         CCommentToken();
                         CCommentToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
             char        mLeadingChar;
@@ -160,8 +180,8 @@ class CEntityToken : public CHTMLToken {
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
             PRInt32     TranslateToUnicodeStr(nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
-    static  PRInt32     ConsumeEntity(PRUnichar aChar,nsString& aString,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
+    static  PRInt32     ConsumeEntity(PRUnichar aChar,nsString& aString,nsScanner& aScanner);
     static  PRInt32     TranslateToUnicodeStr(PRInt32 aValue,nsString& aString);
 //    static  PRInt32     FindEntityIndex(nsString& aString);
 //    static  PRInt32     FindEntityIndexMax(const char* aBuffer,PRInt32 aCount=-1);
@@ -185,7 +205,7 @@ class CWhitespaceToken: public CHTMLToken {
   public:
                         CWhitespaceToken();
                         CWhitespaceToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
 };
@@ -201,7 +221,7 @@ class CTextToken: public CHTMLToken {
   public:
                         CTextToken();
                         CTextToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
 };
@@ -218,12 +238,13 @@ class CCDATASectionToken : public CHTMLToken {
 public:
                         CCDATASectionToken();
                         CCDATASectionToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);  
 };
 
 
+
 /**
  *  Attribute tokens are used to contain attribute key/value
  *  pairs whereever they may occur. Typically, they should
@@ -237,7 +258,7 @@ class CAttributeToken: public CHTMLToken {
                           CAttributeToken();
                           CAttributeToken(const nsString& aString);
                           CAttributeToken(const nsString& aKey, const nsString& aString);
-    virtual nsresult      Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult      Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char*   GetClassName(void);
     virtual PRInt32       GetTokenType(void);
     virtual nsString&     GetKey(void) {return mTextKey;}
@@ -261,7 +282,7 @@ class CNewlineToken: public CHTMLToken {
   public:
                         CNewlineToken();
                         CNewlineToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
     virtual nsString&   GetStringValueXXX(void);
@@ -314,7 +335,7 @@ class CStyleToken: public CHTMLToken {
 class CSkippedContentToken: public CAttributeToken {
   public:
                         CSkippedContentToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
   protected:
@@ -332,7 +353,7 @@ class CInstructionToken: public CHTMLToken {
   public:
                         CInstructionToken();
                         CInstructionToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
 };
diff --git a/htmlparser/src/nsIDTD.h b/htmlparser/src/nsIDTD.h
index 7a27263754cd..1a81a5c058b3 100644
--- a/htmlparser/src/nsIDTD.h
+++ b/htmlparser/src/nsIDTD.h
@@ -15,6 +15,7 @@
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  * Reserved.
  */
+
 #ifndef nsIDTD_h___
 #define nsIDTD_h___
 
@@ -33,6 +34,7 @@
 #include "nshtmlpars.h"
 #include "nsISupports.h"
 #include "prtypes.h"
+#include "nsITokenizer.h"
 
 #define NS_IDTD_IID \
  { 0xa6cf9053, 0x15b3, 0x11d2,{0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}
@@ -48,11 +50,6 @@ class nsITagHandler;
 enum eAutoDetectResult {eUnknownDetect, eValidDetect, eInvalidDetect};
 
 
-class nsITokenRecycler {
-public:
-    virtual void RecycleToken(CToken* aToken)=0;
-};
-
 
 class nsIDTD : public nsISupports {
   public:
@@ -64,6 +61,7 @@ class nsIDTD : public nsISupports {
      */
     virtual ~nsIDTD() {};
 
+    virtual const nsIID&  GetMostDerivedIID(void) const =0;
 
     /**
      * Call this method if you want the DTD to construct a clone of itself.
@@ -109,16 +107,24 @@ class nsIDTD : public nsISupports {
      * @param	anErrorCode - contains error code resulting from parse process
      * @return
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser)=0;
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser)=0;
+
+    /**
+     * Called by the parser after the parsing process has concluded
+     * @update	gess5/18/98
+     * @param	anErrorCode - contains error code resulting from parse process
+     * @return
+     */
+    NS_IMETHOD BuildModel(nsIParser* aParser)=0;
     
     /**
      *	Called during model building phase of parse process. Each token created during
-	 *  the parse phase is stored in a deque (in the parser) and are passed to this method
-	 *  so that the DTD can process the token. Ultimately, the DTD will transform given
-	 *  token into calls onto a contentsink.
+	   *  the parse phase is stored in a deque (in the parser) and are passed to this method
+	   *  so that the DTD can process the token. Ultimately, the DTD will transform given
+	   *  token into calls onto a contentsink.
      *  @update  gess 3/25/98
      *  @param   aToken -- token object to be put into content model
-	 *  @return	 error code (usually 0)
+	   *  @return	 error code (usually 0)
      */
     NS_IMETHOD HandleToken(CToken* aToken,nsIParser* aParser)=0;
 
@@ -130,7 +136,9 @@ class nsIDTD : public nsISupports {
   	 *  @param   aToken -- will contain newly created and consumed token
 	   *  @return	 error code (usually 0)
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser)=0;
+    virtual nsITokenizer* GetTokenizer(void)=0;
+
+    virtual  nsITokenRecycler* GetTokenRecycler(void)=0;
 
     /**
      *  This method causes all tokens to be dispatched to the given tag handler.
@@ -195,14 +203,6 @@ class nsIDTD : public nsISupports {
      * @return
      */
     virtual PRBool Verify(nsString& aURLRef,nsIParser* aParser)=0;
-
-    /**
-     * Retrieve a ptr to the global token recycler...
-     * @update	gess8/4/98
-     * @return  ptr to recycler (or null)
-     */
-    virtual nsITokenRecycler* GetTokenRecycler(void)=0;
-
 };
 
 
diff --git a/htmlparser/src/nsIParser.h b/htmlparser/src/nsIParser.h
index f4818057577f..5a387ac140df 100644
--- a/htmlparser/src/nsIParser.h
+++ b/htmlparser/src/nsIParser.h
@@ -34,24 +34,14 @@
 #include "nsIStreamListener.h"
 #include "nsIDTD.h"
 #include "nsIInputStream.h"
-#include "nsError.h"
 #include <fstream.h>
 
+
 #define NS_IPARSER_IID      \
   {0x355cbba0, 0xbf7d,  0x11d1,  \
   {0xaa, 0xd9, 0x00,    0x80, 0x5f, 0x8a, 0x3e, 0x14}}
 
-/**
- * Return codes for parsing routines.
- * @update vidur 12/11/98
- *
- * NS_ERROR_HTMLPARSER_BLOCK indicates that the parser should
- * block further parsing until it gets a Unblock() method call.
- * NS_ERROR_HTMLPARSER_CONTINUE indicates that the parser should
- * continue parsing
- */
-#define NS_ERROR_HTMLPARSER_BLOCK       NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_HTMLPARSER,1)
-#define NS_ERROR_HTMLPARSER_CONTINUE    NS_OK
+
 
 class nsIContentSink;
 class nsIStreamObserver;
@@ -133,10 +123,10 @@ class nsIParser : public nsISupports {
      *  until you wind up being emitted to the given contentsink (which may or may not
 	   *  be a proxy for the NGLayout content model).
      ******************************************************************************************/
-    virtual PRBool  EnableParser(PRBool aState) = 0;
-    virtual PRInt32 Parse(nsIURL* aURL,nsIStreamObserver* aListener = nsnull,PRBool aEnableVerify=PR_FALSE) = 0;
-    virtual PRInt32 Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE) = 0;
-    virtual PRInt32 Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE) = 0;
+    virtual PRBool    EnableParser(PRBool aState) = 0;
+    virtual nsresult  Parse(nsIURL* aURL,nsIStreamObserver* aListener = nsnull,PRBool aEnableVerify=PR_FALSE) = 0;
+    virtual nsresult  Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE) = 0;
+    virtual nsresult  Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE) = 0;
 
     /**
      * This method gets called when the tokens have been consumed, and it's time
@@ -144,7 +134,7 @@ class nsIParser : public nsISupports {
      * @update	gess5/11/98
      * @return  error code -- 0 if model building went well .
      */
-    virtual PRInt32 BuildModel(void)=0;
+    virtual nsresult  BuildModel(void)=0;
 
 
     /**
@@ -158,4 +148,73 @@ class nsIParser : public nsISupports {
 
 };
 
+/* ===========================================================*
+  Some useful constants...
+ * ===========================================================*/
+
+#include "prtypes.h"
+#include "nsError.h"
+
+#define NS_ERROR_HTMLPARSER_EOF                   NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1000)
+#define NS_ERROR_HTMLPARSER_UNKNOWN               NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1001)
+#define NS_ERROR_HTMLPARSER_CANTPROPAGATE         NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1002)
+#define NS_ERROR_HTMLPARSER_CONTEXTMISMATCH       NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1003)
+#define NS_ERROR_HTMLPARSER_BADFILENAME           NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1004)
+#define NS_ERROR_HTMLPARSER_BADURL                NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1005)
+#define NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1006)
+#define NS_ERROR_HTMLPARSER_INTERRUPTED           NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1007)
+
+/**
+ * Return codes for parsing routines.
+ * @update vidur 12/11/98
+ *
+ * NS_ERROR_HTMLPARSER_BLOCK indicates that the parser should
+ * block further parsing until it gets a Unblock() method call.
+ * NS_ERROR_HTMLPARSER_CONTINUE indicates that the parser should
+ * continue parsing
+ */
+#define NS_ERROR_HTMLPARSER_BLOCK       NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1008)
+#define NS_ERROR_HTMLPARSER_CONTINUE    NS_OK
+
+
+const PRInt32   kEOF              = NS_ERROR_HTMLPARSER_EOF;
+const PRInt32   kUnknownError     = NS_ERROR_HTMLPARSER_UNKNOWN;
+const PRInt32   kCantPropagate    = NS_ERROR_HTMLPARSER_CANTPROPAGATE;
+const PRInt32   kContextMismatch  = NS_ERROR_HTMLPARSER_CONTEXTMISMATCH;
+const PRInt32   kBadFilename      = NS_ERROR_HTMLPARSER_BADFILENAME;
+const PRInt32   kBadURL           = NS_ERROR_HTMLPARSER_BADURL;
+const PRInt32   kInvalidParserContext = NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT;
+const PRInt32   kNotFound         = -1;
+const PRInt32   kBlock            = NS_ERROR_HTMLPARSER_BLOCK;
+
+const PRUint32  kNewLine          = '\n';
+const PRUint32  kCR               = '\r';
+const PRUint32  kLF               = '\n';
+const PRUint32  kTab              = '\t';
+const PRUint32  kSpace            = ' ';
+const PRUint32  kQuote            = '"';
+const PRUint32  kApostrophe       = '\'';
+const PRUint32  kLessThan         = '<';
+const PRUint32  kGreaterThan      = '>';
+const PRUint32  kAmpersand        = '&';
+const PRUint32  kForwardSlash     = '/';
+const PRUint32  kBackSlash        = '\\';
+const PRUint32  kEqual            = '=';
+const PRUint32  kMinus            = '-';
+const PRUint32  kPlus             = '+';
+const PRUint32  kExclamation      = '!';
+const PRUint32  kSemicolon        = ';';
+const PRUint32  kHashsign         = '#';
+const PRUint32  kAsterisk         = '*';
+const PRUint32  kUnderbar         = '_';
+const PRUint32  kComma            = ',';
+const PRUint32  kLeftParen        = '(';
+const PRUint32  kRightParen       = ')';
+const PRUint32  kLeftBrace        = '{';
+const PRUint32  kRightBrace       = '}';
+const PRUint32  kQuestionMark     = '?';
+const PRUint32  kLeftSquareBracket  = '[';
+const PRUint32  kRightSquareBracket = ']';
+const PRUnichar kNullCh           = '\0';
+
 #endif 
diff --git a/htmlparser/src/nsITokenHandler.h b/htmlparser/src/nsITokenHandler.h
index 7e71caf2b888..4abbefd505a7 100644
--- a/htmlparser/src/nsITokenHandler.h
+++ b/htmlparser/src/nsITokenHandler.h
@@ -27,6 +27,7 @@
 #define ITOKENHANDLER__
 
 #include "prtypes.h"
+#include "nsError.h"
 
 class CToken;
 class nsIDTD;
@@ -34,7 +35,7 @@ class nsIDTD;
 class CITokenHandler {
 public:
                           
-  virtual PRInt32 operator()(CToken* aToken,nsIDTD* aDTD)=0;
+  virtual nsresult operator()(CToken* aToken,nsIDTD* aDTD)=0;
   virtual PRInt32 GetTokenType(void)=0;
 
 };
diff --git a/htmlparser/src/nsITokenizer.h b/htmlparser/src/nsITokenizer.h
new file mode 100644
index 000000000000..6e49e1a21b97
--- /dev/null
+++ b/htmlparser/src/nsITokenizer.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL")=0; you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#ifndef __NSITOKENIZER__
+#define __NSITOKENIZER__
+
+#include "nsISupports.h"
+#include "prtypes.h"
+#include "nshtmlpars.h"
+
+class CToken;
+class nsScanner;
+
+#define NS_ITOKENIZER_IID      \
+  {0xe4238ddc, 0x9eb6,  0x11d2, {0xba, 0xa5, 0x0,     0x10, 0x4b, 0x98, 0x3f, 0xd4 }}
+
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+class  nsITokenRecycler {
+public:
+    virtual void RecycleToken(CToken* aToken)=0;
+};
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+class nsITokenizer : public nsISupports {
+public:
+    
+  virtual nsresult          ConsumeToken(nsScanner& aScanner)=0;
+  virtual nsITokenRecycler* GetTokenRecycler(void)=0;
+
+  virtual CToken*           PushTokenFront(CToken* theToken)=0;
+  virtual CToken*           PushToken(CToken* theToken)=0;
+	virtual CToken*           PopToken(void)=0;
+	virtual CToken*           PeekToken(void)=0;
+	virtual PRInt32           GetCount(void)=0;
+  
+};
+
+
+#endif
+
diff --git a/htmlparser/src/nsParser.cpp b/htmlparser/src/nsParser.cpp
index 5c974b9973bb..a39ece85ac51 100644
--- a/htmlparser/src/nsParser.cpp
+++ b/htmlparser/src/nsParser.cpp
@@ -81,7 +81,10 @@ public:
     NS_IF_RELEASE(mTargetDTD);
   }
   virtual void* operator()(void* anObject) {
-    return (anObject==(void*)mTargetDTD) ? anObject : 0;
+    nsIDTD* theDTD=(nsIDTD*)anObject;
+    if(theDTD->GetMostDerivedIID().Equals(mTargetDTD->GetMostDerivedIID()))
+      return anObject;
+    return 0;
   }
   nsIDTD* mTargetDTD;
 };
@@ -90,12 +93,14 @@ class CSharedParserObjects {
 public:
 
   CSharedParserObjects() : mDeallocator(), mDTDDeque(mDeallocator) {
-    nsIDTD* theDTD;
-    NS_NewWellFormed_DTD(&theDTD);
-    RegisterDTD(theDTD);
+    /*
+      nsIDTD* theDTD;
+      NS_NewWellFormed_DTD(&theDTD);
+      RegisterDTD(theDTD);
 
-    NS_NewViewSourceHTML(&theDTD);
-    RegisterDTD(theDTD);
+      NS_NewViewSourceHTML(&theDTD);
+      RegisterDTD(theDTD);
+    */
   }
 
   ~CSharedParserObjects() {
@@ -119,66 +124,6 @@ CSharedParserObjects gSharedParserObjects;
 
 //----------------------------------------
 
-#define NOT_USED 0xfffd
-
-static PRUint16 PA_HackTable[] = {
-	NOT_USED,
-	NOT_USED,
-	0x201a,  /* SINGLE LOW-9 QUOTATION MARK */
-	0x0192,  /* LATIN SMALL LETTER F WITH HOOK */
-	0x201e,  /* DOUBLE LOW-9 QUOTATION MARK */
-	0x2026,  /* HORIZONTAL ELLIPSIS */
-	0x2020,  /* DAGGER */
-	0x2021,  /* DOUBLE DAGGER */
-	0x02c6,  /* MODIFIER LETTER CIRCUMFLEX ACCENT */
-	0x2030,  /* PER MILLE SIGN */
-	0x0160,  /* LATIN CAPITAL LETTER S WITH CARON */
-	0x2039,  /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
-	0x0152,  /* LATIN CAPITAL LIGATURE OE */
-	NOT_USED,
-	NOT_USED,
-	NOT_USED,
-
-	NOT_USED,
-	0x2018,  /* LEFT SINGLE QUOTATION MARK */
-	0x2019,  /* RIGHT SINGLE QUOTATION MARK */
-	0x201c,  /* LEFT DOUBLE QUOTATION MARK */
-	0x201d,  /* RIGHT DOUBLE QUOTATION MARK */
-	0x2022,  /* BULLET */
-	0x2013,  /* EN DASH */
-	0x2014,  /* EM DASH */
-	0x02dc,  /* SMALL TILDE */
-	0x2122,  /* TRADE MARK SIGN */
-	0x0161,  /* LATIN SMALL LETTER S WITH CARON */
-	0x203a,  /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
-	0x0153,  /* LATIN SMALL LIGATURE OE */
-	NOT_USED,
-	NOT_USED,
-	0x0178   /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
-};
-
-static PRUnichar gToUCS2[256];
-
-static void
-MakeConversionTable()
-{
-  static PRBool firstTime = PR_TRUE;
-  if (firstTime) {
-    firstTime = PR_FALSE;
-    PRUnichar* cp = gToUCS2;
-    PRInt32 i;
-    for (i = 0; i < 256; i++) {
-      *cp++ = PRUnichar(i);
-    }
-    cp = gToUCS2;
-    for (i = 0; i < 32; i++) {
-      cp[0x80 + i] = PA_HackTable[i];
-    }
-  }
-}
-
-//----------------------------------------
-
 /**
  *  default constructor
  *  
@@ -195,7 +140,6 @@ nsParser::nsParser() : mCommand("") {
   mParserContext=0;
   mDTDVerification=PR_FALSE;
   mParserEnabled=PR_TRUE;
-  MakeConversionTable();
 }
 
 
@@ -219,7 +163,7 @@ nsParser::~nsParser() {
 
 NS_IMPL_ADDREF(nsParser)
 NS_IMPL_RELEASE(nsParser)
-//NS_IMPL_ISUPPORTS(nsParser,NS_IHTML_PARSER_IID)
+//NS_IMPL_ISUPPORTS(nsParser,NS_IHTML_HTMLPARSER_IID)
 
 
 /**
@@ -348,7 +292,7 @@ void nsParser::RegisterDTD(nsIDTD* aDTD){
  *  @update  gess 6/9/98
  *  @return  ptr to internal scanner
  */
-CScanner* nsParser::GetScanner(void){
+nsScanner* nsParser::GetScanner(void){
   if(mParserContext)
     return mParserContext->mScanner;
   return 0;
@@ -442,7 +386,7 @@ eAutoDetectResult nsParser::AutoDetectContentType(nsString& aBuffer,nsString& aT
 
 
 /**
- *  This is called (by willBuildModel) when it's time to find out 
+ *  This is called when it's time to find out 
  *  what mode the parser/DTD should run for this document.
  *  (Each parsercontext can have it's own mode).
  *  
@@ -453,7 +397,7 @@ eParseMode DetermineParseMode(nsParser& aParser) {
   const char* theModeStr= PR_GetEnv("PARSE_MODE");
   const char* other="other";
   
-  CScanner* theScanner=aParser.GetScanner();
+  nsScanner* theScanner=aParser.GetScanner();
   if(theScanner){
     nsString& theBuffer=theScanner->GetBuffer();
     PRInt32 theIndex=theBuffer.Find("HTML 4.0");
@@ -488,20 +432,28 @@ eParseMode DetermineParseMode(nsParser& aParser) {
  * @param 
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::WillBuildModel(nsString& aFilename,nsIDTD* aDefaultDTD){
+nsresult nsParser::WillBuildModel(nsString& aFilename,nsIDTD* aDefaultDTD){
 
-  mMajorIteration=-1; 
-  mMinorIteration=-1; 
-  PRInt32 result=kNoError;
-  if(mParserContext){
-    mParserContext->mParseMode=DetermineParseMode(*this);  
-    mParserContext->mDTD=aDefaultDTD;
-    if(PR_TRUE==FindSuitableDTD(*mParserContext,mCommand)) {
-      //mParserContext->mDTD->SetContentSink(mSink);
-      mParserContext->mDTD->WillBuildModel(aFilename,PRBool(0==mParserContext->mPrevContext),this);
+  nsresult result=NS_OK;
+
+  if(eOnStart==mStreamListenerState) {  
+    mMajorIteration=-1; 
+    mMinorIteration=-1; 
+    if(eUnknownDetect==mParserContext->mAutoDetectStatus) {
+      if(eValidDetect==AutoDetectContentType(mParserContext->mScanner->GetBuffer(),mParserContext->mSourceType)) {
+        if(mParserContext){
+          mParserContext->mParseMode=DetermineParseMode(*this);  
+          mParserContext->mDTD=aDefaultDTD;
+          if(PR_TRUE==FindSuitableDTD(*mParserContext,mCommand)) {
+            //mParserContext->mDTD->SetContentSink(mSink);
+            mStreamListenerState=eOnDataAvail;
+            mParserContext->mDTD->WillBuildModel(aFilename,PRBool(0==mParserContext->mPrevContext),this);
+          }
+        }
+        else result=kInvalidParserContext;    
+      } //if
     }
   }
-  else result=kInvalidParserContext;
   return result;
 }
 
@@ -513,25 +465,15 @@ PRInt32 nsParser::WillBuildModel(nsString& aFilename,nsIDTD* aDefaultDTD){
  * @param 
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::DidBuildModel(PRInt32 anErrorCode) {
+nsresult nsParser::DidBuildModel(nsresult anErrorCode) {
   //One last thing...close any open containers.
-  PRInt32 result=anErrorCode;
+  nsresult result=anErrorCode;
 
-  if((!mParserContext->mPrevContext) && (mParserContext->mDTD)) {
-    result=mParserContext->mDTD->DidBuildModel(anErrorCode,PRBool(0==mParserContext->mPrevContext),this);
-
-    //Now recycle any tokens that are still hanging around.
-    //Come to think of it, there really shouldn't be any.
-    nsDeque&  theDeque=mParserContext->mTokenDeque;
-    nsITokenRecycler* theRecycler=mParserContext->mDTD->GetTokenRecycler();
-    if(theRecycler) {
-      CToken* theToken=(CToken*)theDeque.Pop();
-      while(theToken) {
-        theRecycler->RecycleToken(theToken);
-        theToken=(CToken*)theDeque.Pop();
-      }
+  if(mParserEnabled) {
+    if((!mParserContext->mPrevContext) && (mParserContext->mDTD)) {
+      result=mParserContext->mDTD->DidBuildModel(anErrorCode,PRBool(0==mParserContext->mPrevContext),this);
     }
-  }
+  }//if
 
   return result;
 }
@@ -589,13 +531,6 @@ PRBool nsParser::EnableParser(PRBool aState){
   if ((PR_FALSE == mParserEnabled) && aState) {
     mParserEnabled = PR_TRUE;
     ResumeParse();
-    // If the stream has already closed, finish out the parsing
-    // process. Note if the parser was disabled when we resumed
-    // parsing, then we have to wait till its reenabled before
-    // finishing.
-    if ((eOnStop == mStreamListenerState) && mParserEnabled) {
-      DidBuildModel(mStreamStatus);
-    }
   }
   else {
     mParserEnabled=aState;
@@ -619,22 +554,23 @@ PRBool nsParser::EnableParser(PRBool aState){
  *  @param   aFilename -- const char* containing file to be parsed.
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aVerifyEnabled) {
+nsresult nsParser::Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aVerifyEnabled) {
   NS_PRECONDITION(0!=aURL,kNullURL);
 
-  PRInt32 status=kBadURL;
+  nsresult result=kBadURL;
   mDTDVerification=aVerifyEnabled;
- 
+  mStreamListenerState=eNone;  
+  mIncremental=PR_TRUE; 
   if(aURL) {
     const char* spec;
     nsresult rv = aURL->GetSpec(&spec);
     if (rv != NS_OK) return rv;
     nsAutoString theName(spec);
-    CParserContext* cp=new CParserContext(new CScanner(theName,PR_FALSE),aURL,aListener);
+    CParserContext* cp=new CParserContext(new nsScanner(theName,PR_FALSE),aURL,aListener);
     PushContext(*cp);
-    status=NS_OK;
+    result=NS_OK;
   }
-  return status;
+  return result;
 }
 
 
@@ -644,27 +580,22 @@ PRInt32 nsParser::Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aVerify
  * @param   aStream is the i/o source
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Parse(fstream& aStream,PRBool aVerifyEnabled){
+nsresult nsParser::Parse(fstream& aStream,PRBool aVerifyEnabled){
 
-  PRInt32 status=kNoError;
   mDTDVerification=aVerifyEnabled;
+  mStreamListenerState=eOnStart;  
   
   //ok, time to create our tokenizer and begin the process
-  CParserContext* pc=new CParserContext(new CScanner(kUnknownFilename,aStream,PR_FALSE),&aStream,0);
+  CParserContext* pc=new CParserContext(new nsScanner(kUnknownFilename,aStream,PR_FALSE),&aStream,0);
   PushContext(*pc);
   pc->mSourceType="text/html";
   mParserContext->mScanner->Eof();
-  if(eValidDetect==AutoDetectContentType(mParserContext->mScanner->GetBuffer(),
-                                         mParserContext->mSourceType)) {
-    WillBuildModel(mParserContext->mScanner->GetFilename(),0);
-    status=ResumeParse();
-    DidBuildModel(status);
-  } //if
-
+  mIncremental=PR_FALSE;
+  nsresult result=ResumeParse();
   pc=PopContext();
   delete pc;
 
-  return status;
+  return result;
 }
 
 
@@ -678,23 +609,21 @@ PRInt32 nsParser::Parse(fstream& aStream,PRBool aVerifyEnabled){
  * @param   anHTMLString tells us whether we should assume the content is HTML (usually true)
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVerifyEnabled){
-  PRInt32 result=kNoError;
+nsresult nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVerifyEnabled){
   mDTDVerification=aVerifyEnabled;
+  mStreamListenerState=eOnStart;  
 
+  nsresult result=NS_OK;
   if(0<aSourceBuffer.Length()){
-    CParserContext* pc=new CParserContext(new CScanner(aSourceBuffer),&aSourceBuffer,0);
+    CParserContext* pc=new CParserContext(new nsScanner(aSourceBuffer),&aSourceBuffer,0);
 
     nsIDTD* thePrevDTD=(mParserContext) ? mParserContext->mDTD: 0;
       
     PushContext(*pc);
     if(PR_TRUE==anHTMLString)
       pc->mSourceType="text/html";
-    if(eValidDetect==AutoDetectContentType(aSourceBuffer,mParserContext->mSourceType)) {
-      WillBuildModel(mParserContext->mScanner->GetFilename(),thePrevDTD);
-      result=ResumeParse();
-      DidBuildModel(result);
-    }
+    mIncremental=PR_FALSE;
+    result=ResumeParse();
     mParserContext->mDTD=0; 
     pc=PopContext();
     delete pc;
@@ -702,7 +631,7 @@ PRInt32 nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVeri
   return result;
 }
 
-
+ 
 /**
  *  This routine is called to cause the parser to continue
  *  parsing it's underlying stream. This call allows the
@@ -713,22 +642,28 @@ PRInt32 nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVeri
  *  @param   
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::ResumeParse() {
-  PRInt32 result=kNoError;
-  PRInt32 buildResult=kNoError;
-
+nsresult nsParser::ResumeParse(nsIDTD* aDefaultDTD) {
+  
+  nsresult result=WillBuildModel(mParserContext->mScanner->GetFilename(),aDefaultDTD);
   mParserContext->mDTD->WillResumeParse();
-  if(kNoError==result) {
+  if(NS_OK==result) {
+     
     result=Tokenize();
-    buildResult=BuildModel();
-    if(kInterrupted==result)
+    result=BuildModel();
+
+    if((!mIncremental) || (eOnStop==mStreamListenerState)){
+      DidBuildModel(mStreamStatus);
+    }
+    else {
       mParserContext->mDTD->WillInterruptParse();
     // If we're told to block the parser, we disable
     // all further parsing (and cache any data coming
     // in) until the parser is enabled.
-    if(NS_ERROR_HTMLPARSER_BLOCK==buildResult) {
-      EnableParser(PR_FALSE);
-    }
+      PRUint32 b1=NS_ERROR_HTMLPARSER_BLOCK;
+      if(NS_ERROR_HTMLPARSER_BLOCK==result) {
+        EnableParser(PR_FALSE);
+      }
+    }//if
   }
   return result;
 }
@@ -741,23 +676,27 @@ PRInt32 nsParser::ResumeParse() {
  *  @param   
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::BuildModel() {
+nsresult nsParser::BuildModel() {
   
-  nsDequeIterator e=mParserContext->mTokenDeque.End(); 
-  nsDequeIterator theMarkPos(e);
+  //nsDequeIterator e=mParserContext->mTokenDeque.End(); 
 
-  if(!mParserContext->mCurrentPos)
-    mParserContext->mCurrentPos=new nsDequeIterator(mParserContext->mTokenDeque.Begin());
+//  if(!mParserContext->mCurrentPos)
+//    mParserContext->mCurrentPos=new nsDequeIterator(mParserContext->mTokenDeque.Begin());
 
     //Get the root DTD for use in model building...
   CParserContext* theRootContext=mParserContext;
-  while(theRootContext->mPrevContext)
+  while(theRootContext->mPrevContext) {
     theRootContext=theRootContext->mPrevContext;
+  }
 
   nsIDTD* theRootDTD=theRootContext->mDTD;
-  
-  PRInt32 result=kNoError;
-  while((kNoError==result) && ((*mParserContext->mCurrentPos<e))){
+  nsresult result=NS_OK;
+  if(theRootDTD) {
+    result=theRootDTD->BuildModel(this);
+  }
+
+/*  
+  while((NS_OK==result) && ((*mParserContext->mCurrentPos<e))){
     mMinorIteration++;
     CToken* theToken=(CToken*)mParserContext->mCurrentPos->GetCurrent();
     theMarkPos=*mParserContext->mCurrentPos;
@@ -771,6 +710,7 @@ PRInt32 nsParser::BuildModel() {
     //The current context has a deque full of them,
     //and the ones that preceed currentpos are no
     //longer needed. Let's recycle them.
+  
   nsITokenRecycler* theRecycler=theRootDTD->GetTokenRecycler();
   if(theRecycler) {
     nsDeque&  theDeque=mParserContext->mTokenDeque;
@@ -785,54 +725,12 @@ PRInt32 nsParser::BuildModel() {
     }
     mParserContext->mCurrentPos->First();
   }
+  */
 
   return result;
 }
 
 
-/**
- * This method provides access to the topmost token in the tokenDeque.
- * The token is not really removed from the list.
- * @update	gess8/2/98
- * @return  ptr to token
- */
-CToken* nsParser::PeekToken() {
-  CToken* theToken=0;
-  if(mParserContext)
-    if(mParserContext->mCurrentPos)
-      theToken=(CToken*)mParserContext->mCurrentPos->GetCurrent();
-  return theToken;
-}
-
-
-/**
- * This method provides access to the topmost token in the tokenDeque.
- * The token is really removed from the list; if the list is empty we return 0.
- * @update	gess8/2/98
- * @return  ptr to token or NULL
- */
-CToken* nsParser::PopToken() {
-  CToken* theToken=0;
-  if(mParserContext)
-    if(mParserContext->mCurrentPos) {
-      theToken=(CToken*)mParserContext->mCurrentPos->GetCurrent();
-      ++(*mParserContext->mCurrentPos);
-    }
-  return theToken;
-}
-
-
-/**
- * 
- * @update	gess8/2/98
- * @param 
- * @return
- */
-CToken* nsParser::PushToken(CToken* theToken) {
-  mParserContext->mTokenDeque.Push(theToken);
-	return theToken;
-}
-
 /*******************************************************************
   These methods are used to talk to the netlib system...
  *******************************************************************/
@@ -883,6 +781,11 @@ nsParser::OnStatus(nsIURL* aURL, const PRUnichar* aMsg)
   return result;
 }
 
+#undef _DEBUGDUMPFILE 
+#ifdef _DEBUGDUMPFILE
+  fstream* gDumpFile;
+#endif
+
 /**
  *  
  *  
@@ -900,72 +803,77 @@ nsresult nsParser::OnStartBinding(nsIURL* aURL, const char *aSourceType){
   mParserContext->mAutoDetectStatus=eUnknownDetect;
   mParserContext->mDTD=0;
   mParserContext->mSourceType=aSourceType;
-  return kNoError;
+
+#ifdef _DEBUGDUMPFILE
+  gDumpFile = new fstream("c:/temp/out.file",ios::trunc);
+#endif
+
+  return NS_OK;
 }
 
 /**
  *  
  *  
- *  @update  vidur 12/11/98
+ *  @update  gess 1/4/99
  *  @param   pIStream contains the input chars
  *  @param   length is the number of bytes waiting input
  *  @return  error code (usually 0)
  */
-nsresult nsParser::OnDataAvailable(nsIURL* aURL, nsIInputStream *pIStream, PRUint32 length){
+nsresult nsParser::OnDataAvailable(nsIURL* aURL, nsIInputStream *pIStream, PRUint32 aLength){
 /*  if (nsnull != mListener) {
       //Rick potts removed this.
       //Does it need to be here?
-    mListener->OnDataAvailable(pIStream, length);
+    mListener->OnDataAvailable(pIStream, aLength);
   }
 */
   NS_PRECONDITION(((eOnStart==mStreamListenerState)||(eOnDataAvail==mStreamListenerState)),kOnStartNotCalled);
 
-  mStreamListenerState=eOnDataAvail;  
   if(eInvalidDetect==mParserContext->mAutoDetectStatus) {
     if(mParserContext->mScanner) {
       mParserContext->mScanner->GetBuffer().Truncate();
     }
   }
 
-  PRUint32 len=1; //init to a non-zero value
-
-  if(!mParserContext->mTransferBuffer)
-    mParserContext->mTransferBuffer = new char[CParserContext::eTransferBufferSize+1];
-
-  while (len > 0) {
-    nsresult rv = pIStream->Read(mParserContext->mTransferBuffer, 0,
-                                 mParserContext->eTransferBufferSize, &len);
-    if((rv == NS_OK) && (len>0)) {
-      if(mParserFilter)
-         mParserFilter->RawBuffer(mParserContext->mTransferBuffer, &len);
-
-      // XXX kipp was here: this is a temporary piece of code that
-      // fixes up the data in the transfer buffer so that the 8 bit
-      // ascii is mapped to ucs2 properly. The problem is that for the
-      // default character set, some web pages use illegal codes (0x80
-      // to 0x9f, inclusive); we already have code to map entities
-      // properly in this range. This code maps raw stream data the
-      // same way.
-      PRUnichar buf[CParserContext::eTransferBufferSize];
-      PRUnichar* dst = buf;
-      const PRUnichar* table = gToUCS2;
-      const char* src = mParserContext->mTransferBuffer;
-      const char* end = src + len;
-      while (src < end) {
-        unsigned char ch = *(unsigned char*)src;
-        *dst++ = table[ch];
-        src++;
-      }
-
-      mParserContext->mScanner->Append(buf, len);
-
-      if(eUnknownDetect==mParserContext->mAutoDetectStatus) {
-        if(eValidDetect==AutoDetectContentType(mParserContext->mScanner->GetBuffer(),mParserContext->mSourceType)) {
-          WillBuildModel(mParserContext->mScanner->GetFilename(),0);
-        } //if
-      }
-    } //if
+  PRInt32 newLength=(aLength>mParserContext->mTransferBufferSize) ? aLength : mParserContext->mTransferBufferSize;
+  if(!mParserContext->mTransferBuffer) {
+    mParserContext->mTransferBufferSize=newLength;
+    mParserContext->mTransferBuffer=new char[newLength+20];
   }
+  else if(aLength>mParserContext->mTransferBufferSize){
+    delete [] mParserContext->mTransferBuffer;
+    mParserContext->mTransferBufferSize=newLength;
+    mParserContext->mTransferBuffer=new char[newLength+20];
+  }
+
+  PRUint32  theTotalRead=0; 
+  PRUint32  theNumRead=1;   //init to a non-zero value
+  int       theStartPos=0;
+  nsresult result=NS_OK;
+
+  while ((theNumRead>0) && (aLength>theTotalRead) && (NS_OK==result)) {
+    result = pIStream->Read(mParserContext->mTransferBuffer, 0, aLength, &theNumRead);
+    if((result == NS_OK) && (theNumRead>0)) {
+      theTotalRead+=theNumRead;
+      if(mParserFilter)
+         mParserFilter->RawBuffer(mParserContext->mTransferBuffer, &theNumRead);
+
+#ifdef  NS_DEBUG
+      int index=0;
+      for(index=0;index<10;index++)
+        mParserContext->mTransferBuffer[theNumRead+index]=0;
+#endif
+
+      mParserContext->mScanner->Append(mParserContext->mTransferBuffer,theNumRead);
+      nsString& theBuffer=mParserContext->mScanner->GetBuffer();
+      theBuffer.ToUCS2(theStartPos);
+
+#ifdef _DEBUGDUMPFILE
+      (*gDumpFile) << mParserContext->mTransferBuffer;
+#endif
+
+    } //if
+    theStartPos+=theNumRead;
+  }//while
 
   if (mParserEnabled) {
     return ResumeParse();
@@ -976,7 +884,8 @@ nsresult nsParser::OnDataAvailable(nsIURL* aURL, nsIInputStream *pIStream, PRUin
 }
 
 /**
- *  
+ *  This is called by the networking library once the last block of data
+ *  has been collected from the net.
  *  
  *  @update  vidur 12/11/98
  *  @param   
@@ -988,14 +897,27 @@ nsresult nsParser::OnStopBinding(nsIURL* aURL, nsresult status, const PRUnichar*
   nsresult result;
   // If the parser isn't enabled, we don't finish parsing till
   // it is reenabled.
+
   if (mParserEnabled) {
-    result=DidBuildModel(status);
+    return ResumeParse();
   }
+  else {
+    return NS_OK;
+  }
+
   // XXX Should we wait to notify our observers as well if the
   // parser isn't yet enabled?
   if (nsnull != mObserver) {
     mObserver->OnStopBinding(aURL, status, aMsg);
   }
+
+#ifdef _DEBUGDUMPFILE
+  if(gDumpFile){
+    gDumpFile->close();
+    delete gDumpFile;
+  }
+#endif
+
   return result;
 }
 
@@ -1028,34 +950,21 @@ PRBool nsParser::WillTokenize(){
  *  @update  gess 3/25/98
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Tokenize(){
-  CToken* theToken=0;
-  PRInt32 result=kNoError;
+nsresult nsParser::Tokenize(){
+
+  nsresult result=NS_OK;
 
   ++mMajorIteration;
 
   WillTokenize();
-  while(kNoError==result) {
+  nsITokenizer* theTokenizer=mParserContext->mDTD->GetTokenizer();
+  while(NS_SUCCEEDED(result)) {
     mParserContext->mScanner->Mark();
-    result=mParserContext->mDTD->ConsumeToken(theToken,this);
-    if(kNoError==result) {
-      if(theToken) {
-
-  #ifdef VERBOSE_DEBUG
-          theToken->DebugDumpToken(cout);
-  #endif
-        mParserContext->mTokenDeque.Push(theToken);
-      }
-
-    }
-    else {
-      if(theToken)
-        delete theToken;
+    result=theTokenizer->ConsumeToken(*mParserContext->mScanner);
+    if(!NS_SUCCEEDED(result)) {
       mParserContext->mScanner->RewindToMark();
     }
   } 
-  if(kProcessComplete==result)
-    result=NS_OK;
   DidTokenize();
   return result;
 }
@@ -1084,6 +993,7 @@ PRBool nsParser::DidTokenize(){
  *  @return  
  */
 void nsParser::DebugDumpTokens(ostream& out) {
+/*
   nsDequeIterator b=mParserContext->mTokenDeque.Begin();
   nsDequeIterator e=mParserContext->mTokenDeque.End();
 
@@ -1092,6 +1002,7 @@ void nsParser::DebugDumpTokens(ostream& out) {
     theToken=(CToken*)(b++);
     theToken->DebugDumpToken(out);
   }
+*/
 }
 
 
@@ -1105,6 +1016,7 @@ void nsParser::DebugDumpTokens(ostream& out) {
  *  @return  
  */
 void nsParser::DebugDumpSource(ostream& out) {
+/*
   nsDequeIterator b=mParserContext->mTokenDeque.Begin();
   nsDequeIterator e=mParserContext->mTokenDeque.End();
 
@@ -1113,7 +1025,7 @@ void nsParser::DebugDumpSource(ostream& out) {
     theToken=(CToken*)(b++);
     theToken->DebugDumpSource(out);
   }
-
+*/
 }
 
 
diff --git a/htmlparser/src/nsParser.h b/htmlparser/src/nsParser.h
index 7aa215aff6b0..d71507924328 100644
--- a/htmlparser/src/nsParser.h
+++ b/htmlparser/src/nsParser.h
@@ -58,7 +58,6 @@
 #include "nsIParser.h"
 #include "nsDeque.h"
 #include "nsParserNode.h"
-#include "nsParserTypes.h"
 #include "nsIURL.h"
 #include "CParserContext.h"
 #include "nsParserCIID.h"
@@ -66,7 +65,7 @@
 class IContentSink;
 class nsIHTMLContentSink;
 class nsIDTD;
-class CScanner;
+class nsScanner;
 class nsIParserFilter;
 #include <fstream.h>
 
@@ -136,7 +135,7 @@ friend class CTokenHandler;
      *  @update  gess 6/9/98
      *  @return  ptr to scanner
      */
-    virtual CScanner* GetScanner(void);
+    virtual nsScanner* GetScanner(void);
 
     /**
      * Cause parser to parse input from given URL 
@@ -145,7 +144,7 @@ friend class CTokenHandler;
      * @param   aListener is a listener to forward notifications to
      * @return  TRUE if all went well -- FALSE otherwise
      */
-    virtual PRInt32 Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aEnableVerify=PR_FALSE);
+    virtual nsresult Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aEnableVerify=PR_FALSE);
 
     /**
      * Cause parser to parse input from given stream 
@@ -153,7 +152,7 @@ friend class CTokenHandler;
      * @param   aStream is the i/o source
      * @return  TRUE if all went well -- FALSE otherwise
      */
-    virtual PRInt32 Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE);
+    virtual nsresult Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE);
 
     /**
      * @update	gess5/11/98
@@ -161,7 +160,7 @@ friend class CTokenHandler;
      * @param   appendTokens tells us whether we should insert tokens inline, or append them.
      * @return  TRUE if all went well -- FALSE otherwise
      */
-    virtual PRInt32 Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE);
+    virtual nsresult Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE);
 
 
     /**
@@ -180,11 +179,7 @@ friend class CTokenHandler;
      * @update	gess5/11/98
      * @return  TRUE if all went well, otherwise FALSE
      */
-    virtual PRInt32 ResumeParse();
-
-		virtual CToken* PushToken(CToken* theToken);
-		virtual CToken* PopToken();
-		virtual CToken* PeekToken();
+    virtual nsresult ResumeParse(nsIDTD* mDefaultDTD=0);
 
     /**
      *  This debug routine is used to cause the tokenizer to
@@ -217,7 +212,7 @@ protected:
      * @param 
      * @return
      */
-    PRInt32 WillBuildModel(nsString& aFilename,nsIDTD* mDefaultDTD=0);
+    nsresult WillBuildModel(nsString& aFilename,nsIDTD* mDefaultDTD=0);
 
     /**
      * 
@@ -225,7 +220,7 @@ protected:
      * @param 
      * @return
      */
-    PRInt32 DidBuildModel(PRInt32 anErrorCode);
+    nsresult DidBuildModel(nsresult anErrorCode);
 
     /**
      * This method gets called when the tokens have been consumed, and it's time
@@ -233,7 +228,7 @@ protected:
      * @update	gess5/11/98
      * @return  YES if model building went well -- NO otherwise.
      */
-    virtual PRInt32 BuildModel(void);
+    virtual nsresult BuildModel(void);
     
 private:
 
@@ -261,7 +256,7 @@ private:
      *  @update  gess 3/25/98
      *  @return  error code 
      */
-    PRInt32 Tokenize();
+    nsresult Tokenize();
 
     /**
      *  This is the tail-end of the code sandwich for the
@@ -320,6 +315,7 @@ protected:
     nsString            mCommand;
     eStreamState        mStreamListenerState; //this is really only here for debug purposes.
     PRInt32             mStreamStatus;
+    PRBool              mIncremental;
 };
 
 
diff --git a/htmlparser/src/nsParserNode.cpp b/htmlparser/src/nsParserNode.cpp
index d4bbcc4069ec..36bfb4891b36 100644
--- a/htmlparser/src/nsParserNode.cpp
+++ b/htmlparser/src/nsParserNode.cpp
@@ -21,6 +21,7 @@
 #include "string.h"
 #include "nsHTMLTokens.h"
 #include "nshtmlpars.h"
+#include "nsITokenizer.h"
 
 const nsAutoString nsCParserNode::mEmptyString("");
 
@@ -35,24 +36,34 @@ static NS_DEFINE_IID(kIParserNodeIID, NS_IPARSER_NODE_IID);
  *  @param   aToken -- token to init internal token
  *  @return  
  */
-nsCParserNode::nsCParserNode(CToken* aToken,PRInt32 aLineNumber): nsIParserNode() {
+nsCParserNode::nsCParserNode(CToken* aToken,PRInt32 aLineNumber,nsITokenRecycler* aRecycler): nsIParserNode() {
   NS_INIT_REFCNT();
   mAttributeCount=0;
   mLineNumber=aLineNumber;
   mToken=aToken;
   memset(mAttributes,0,sizeof(mAttributes));
-  mSkippedContent=nsnull;
+  mSkippedContent=0;
+  mRecycler=aRecycler;
 }
 
 
 /**
  *  default destructor
- *  
+ *  NOTE: We intentionally DONT recycle mToken here.
+ *        It may get cached for use elsewhere
  *  @update  gess 3/25/98
  *  @param   
  *  @return  
  */
 nsCParserNode::~nsCParserNode() {
+  if(mRecycler) {
+    int index=0;
+    for(index=0;index<mAttributeCount;index++){
+      mRecycler->RecycleToken(mAttributes[index]);
+    }
+    if(mSkippedContent)
+      mRecycler->RecycleToken(mSkippedContent);
+  }
 }
 
 NS_IMPL_ADDREF(nsCParserNode)
diff --git a/htmlparser/src/nsParserNode.h b/htmlparser/src/nsParserNode.h
index 5da39d67a3eb..d7ef81d4f4ba 100644
--- a/htmlparser/src/nsParserNode.h
+++ b/htmlparser/src/nsParserNode.h
@@ -41,6 +41,7 @@
 #include "nsString.h"
 #include "nsParserCIID.h"
 
+class nsITokenRecycler;
 
 class nsCParserNode :  public nsIParserNode {
   enum {eMaxAttr=20};
@@ -54,7 +55,7 @@ class nsCParserNode :  public nsIParserNode {
      * @update	gess5/11/98
      * @param   aToken is the token this node "refers" to
      */
-    nsCParserNode(CToken* aToken=nsnull,PRInt32 aLineNumber=1);
+    nsCParserNode(CToken* aToken=nsnull,PRInt32 aLineNumber=1,nsITokenRecycler* aRecycler=0);
 
     /**
      * Destructor
@@ -169,6 +170,8 @@ class nsCParserNode :  public nsIParserNode {
     CToken*   mToken;
     CToken*   mAttributes[eMaxAttr]; // XXX Ack! This needs to be dynamic! 
     CToken*   mSkippedContent;
+    nsITokenRecycler* mRecycler;
+    
     // nsAutoString  mName;
 
     static const nsAutoString  mEmptyString;
diff --git a/htmlparser/src/nsParserTypes.h b/htmlparser/src/nsParserTypes.h
index 090aa7268ac4..9825affaf724 100644
--- a/htmlparser/src/nsParserTypes.h
+++ b/htmlparser/src/nsParserTypes.h
@@ -27,54 +27,6 @@
 #ifndef PARSER_TYPES__
 #define PARSER_TYPES__
 
-/* ===========================================================*
-  Some useful constants...
- * ===========================================================*/
-
-#include "prtypes.h"
-#include "nsError.h"
-
-
-const PRInt32   kEOF              = 10000;
-const PRInt32   kUnknownError     = 10001;
-const PRInt32   kCantPropagate    = 10002;
-const PRInt32   kContextMismatch  = 10003;
-const PRInt32   kBadFilename      = 10004;
-const PRInt32   kBadURL           = 10005;
-const PRInt32   kInterrupted      = 10006;
-const PRInt32   kProcessComplete  = 10007;
-const PRInt32   kInvalidParserContext = 10008;
-const PRInt32   kNotFound         = -1;
-const PRInt32   kNoError          = NS_OK;
-
-const PRUint32  kNewLine          = '\n';
-const PRUint32  kCR               = '\r';
-const PRUint32  kLF               = '\n';
-const PRUint32  kTab              = '\t';
-const PRUint32  kSpace            = ' ';
-const PRUint32  kQuote            = '"';
-const PRUint32  kApostrophe       = '\'';
-const PRUint32  kLessThan         = '<';
-const PRUint32  kGreaterThan      = '>';
-const PRUint32  kAmpersand        = '&';
-const PRUint32  kForwardSlash     = '/';
-const PRUint32  kBackSlash        = '\\';
-const PRUint32  kEqual            = '=';
-const PRUint32  kMinus            = '-';
-const PRUint32  kPlus             = '+';
-const PRUint32  kExclamation      = '!';
-const PRUint32  kSemicolon        = ';';
-const PRUint32  kHashsign         = '#';
-const PRUint32  kAsterisk         = '*';
-const PRUint32  kUnderbar         = '_';
-const PRUint32  kComma            = ',';
-const PRUint32  kLeftParen        = '(';
-const PRUint32  kRightParen       = ')';
-const PRUint32  kLeftBrace        = '{';
-const PRUint32  kRightBrace       = '}';
-const PRUint32  kQuestionMark     = '?';
-const PRUint32  kLeftSquareBracket  = '[';
-const PRUint32  kRightSquareBracket = ']';
 
 #endif
 
diff --git a/htmlparser/src/nsScanner.cpp b/htmlparser/src/nsScanner.cpp
index 5c1c6c8363c8..49f6df5269e3 100644
--- a/htmlparser/src/nsScanner.cpp
+++ b/htmlparser/src/nsScanner.cpp
@@ -40,11 +40,11 @@ const int   kBufsize=64;
  *  @param   aMode represents the parser mode (nav, other)
  *  @return  
  */
-CScanner::CScanner(nsString& anHTMLString) : 
+nsScanner::nsScanner(nsString& anHTMLString) : 
   mBuffer(anHTMLString), mFilename("") 
 {
   mTotalRead=mBuffer.Length();
-  mIncremental=PR_FALSE;
+  mIncremental=PR_TRUE;
   mOwnsStream=PR_FALSE;
   mOffset=0;
   mMarkPos=-1;
@@ -60,7 +60,7 @@ CScanner::CScanner(nsString& anHTMLString) :
  *  @param   aFilename --
  *  @return  
  */
-CScanner::CScanner(nsString& aFilename,PRBool aCreateStream) : 
+nsScanner::nsScanner(nsString& aFilename,PRBool aCreateStream) : 
     mBuffer(""), mFilename(aFilename) 
 {
   mIncremental=PR_TRUE;
@@ -92,7 +92,7 @@ CScanner::CScanner(nsString& aFilename,PRBool aCreateStream) :
  *  @param   aFilename --
  *  @return  
  */
-CScanner::CScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership) :
+nsScanner::nsScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership) :
     mBuffer(""), mFilename(aFilename)
 {    
   mIncremental=PR_TRUE;
@@ -111,7 +111,7 @@ CScanner::CScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership)
  *  @param   
  *  @return  
  */
-CScanner::~CScanner() {
+nsScanner::~nsScanner() {
   if(mFileStream) {
     mFileStream->close();
     if(mOwnsStream)
@@ -130,7 +130,7 @@ CScanner::~CScanner() {
  *  @param   
  *  @return  
  */
-PRUint32 CScanner::RewindToMark(void){
+PRUint32 nsScanner::RewindToMark(void){
   mOffset=mMarkPos;
   return mOffset;
 }
@@ -145,7 +145,7 @@ PRUint32 CScanner::RewindToMark(void){
  *  @param   
  *  @return  
  */
-PRUint32 CScanner::Mark(void){
+PRUint32 nsScanner::Mark(void){
   if((mOffset>0) && (mOffset>eBufferSizeThreshold)) {
     mBuffer.Cut(0,mOffset);   //delete chars up to mark position
     mOffset=0;
@@ -162,7 +162,7 @@ PRUint32 CScanner::Mark(void){
  * @update  gess4/3/98
  * @return  error code 
  */
-PRBool CScanner::Append(nsString& aBuffer) {
+PRBool nsScanner::Append(nsString& aBuffer) {
   mBuffer.Append(aBuffer);
   mTotalRead+=aBuffer.Length();
   return PR_TRUE;
@@ -175,13 +175,13 @@ PRBool CScanner::Append(nsString& aBuffer) {
  *  @param   
  *  @return  
  */
-PRBool CScanner::Append(const char* aBuffer, PRUint32 aLen){
+PRBool nsScanner::Append(const char* aBuffer, PRUint32 aLen){
   mBuffer.Append(aBuffer,aLen);
   mTotalRead+=aLen;
   return PR_TRUE;
 }
 
-PRBool CScanner::Append(const PRUnichar* aBuffer, PRInt32 aLen){
+PRBool nsScanner::Append(const PRUnichar* aBuffer, PRUint32 aLen){
   mBuffer.Append(aBuffer,aLen);
   mTotalRead+=aLen;
   return PR_TRUE;
@@ -193,8 +193,8 @@ PRBool CScanner::Append(const PRUnichar* aBuffer, PRInt32 aLen){
  * @update  gess4/3/98
  * @return  error code
  */
-nsresult CScanner::FillBuffer(void) {
-  nsresult anError=NS_OK;
+nsresult nsScanner::FillBuffer(void) {
+  nsresult result=NS_OK;
 
   if(!mFileStream) {
     //This is DEBUG code!!!!!!  XXX DEBUG XXX
@@ -205,7 +205,7 @@ nsresult CScanner::FillBuffer(void) {
       mBuffer.Append((const char*)kBadHTMLText);
       mBuffer.Append(mFilename);
     }
-    else anError=(mIncremental) ? kInterrupted : kEOF;
+    else result=kEOF;
   }
   else {
     PRInt32 numread=0;
@@ -220,12 +220,12 @@ nsresult CScanner::FillBuffer(void) {
       }
     }
     mOffset=mBuffer.Length();
-    if((0<numread) && (0==anError))
+    if((0<numread) && (0==result))
       mBuffer.Append((const char*)buf,numread);
     mTotalRead+=mBuffer.Length();
   }
 
-  return anError;
+  return result;
 }
 
 /**
@@ -233,9 +233,9 @@ nsresult CScanner::FillBuffer(void) {
  *  
  *  @update  gess 5/12/98
  *  @param   
- *  @return  0=!eof 1=eof kInterrupted=interrupted
+ *  @return  0=!eof 1=eof 
  */
-nsresult CScanner::Eof() {
+nsresult nsScanner::Eof() {
   nsresult theError=NS_OK;
 
   if(mOffset>=(PRUint32)mBuffer.Length()) {
@@ -243,7 +243,7 @@ nsresult CScanner::Eof() {
   }
   
   if(NS_OK==theError) {
-    if (0==mBuffer.Length()) {
+    if (0==(PRUint32)mBuffer.Length()) {
       return kEOF;
     }
   }
@@ -258,9 +258,10 @@ nsresult CScanner::Eof() {
  *  @param   
  *  @return  error code reflecting read status
  */
-nsresult CScanner::GetChar(PRUnichar& aChar) {
+nsresult nsScanner::GetChar(PRUnichar& aChar) {
   nsresult result=NS_OK;
   
+  aChar=0;
   if(mOffset>=(PRUint32)mBuffer.Length()) 
     result=Eof();
 
@@ -279,9 +280,9 @@ nsresult CScanner::GetChar(PRUnichar& aChar) {
  *  @param   
  *  @return  
  */
-nsresult CScanner::Peek(PRUnichar& aChar) {
+nsresult nsScanner::Peek(PRUnichar& aChar) {
   nsresult result=NS_OK;
-  
+  aChar=0;  
   if(mOffset>=(PRUint32)mBuffer.Length()) 
     result=Eof();
 
@@ -299,7 +300,7 @@ nsresult CScanner::Peek(PRUnichar& aChar) {
  *  @param   
  *  @return  error code
  */
-nsresult CScanner::PutBack(PRUnichar aChar) {
+nsresult nsScanner::PutBack(PRUnichar aChar) {
   if(mOffset>0)
     mOffset--;
   else mBuffer.Insert(aChar,0);
@@ -314,7 +315,7 @@ nsresult CScanner::PutBack(PRUnichar aChar) {
  *  @param   
  *  @return  error status
  */
-nsresult CScanner::SkipWhitespace(void) {
+nsresult nsScanner::SkipWhitespace(void) {
   static nsAutoString chars(" \n\r\t");
   return SkipOver(chars);
 }
@@ -326,7 +327,7 @@ nsresult CScanner::SkipWhitespace(void) {
  *  @param   
  *  @return  error code
  */
-nsresult CScanner::SkipOver(PRUnichar aSkipChar){
+nsresult nsScanner::SkipOver(PRUnichar aSkipChar){
   PRUnichar ch=0;
   nsresult   result=NS_OK;
 
@@ -350,16 +351,16 @@ nsresult CScanner::SkipOver(PRUnichar aSkipChar){
  *  @param   aSkipSet is an ordered string.
  *  @return  error code
  */
-nsresult CScanner::SkipOver(nsString& aSkipSet){
-  PRUnichar ch=0;
-  nsresult   result=NS_OK;
+nsresult nsScanner::SkipOver(nsString& aSkipSet){
+  PRUnichar theChar=0;
+  nsresult  result=NS_OK;
 
   while(NS_OK==result) {
-    result=GetChar(ch);
+    result=GetChar(theChar);
     if(NS_OK == result) {
-      PRInt32 pos=aSkipSet.Find(ch);
+      PRInt32 pos=aSkipSet.Find(theChar);
       if(kNotFound==pos) {
-        PutBack(ch);
+        PutBack(theChar);
         break;
       }
     } 
@@ -377,7 +378,7 @@ nsresult CScanner::SkipOver(nsString& aSkipSet){
  *           contains chars you're looking for
  *  @return  error code
  */
-nsresult CScanner::SkipTo(nsString& aValidSet){
+nsresult nsScanner::SkipTo(nsString& aValidSet){
   PRUnichar ch=0;
   nsresult  result=NS_OK;
 
@@ -405,7 +406,7 @@ nsresult CScanner::SkipTo(nsString& aValidSet){
  *           characters you want to skip
  *  @return  error code
  */
-nsresult CScanner::SkipPast(nsString& aValidSet){
+nsresult nsScanner::SkipPast(nsString& aValidSet){
   NS_NOTYETIMPLEMENTED("Error: SkipPast not yet implemented.");
   return NS_OK;
 }
@@ -420,7 +421,7 @@ nsresult CScanner::SkipPast(nsString& aValidSet){
  *           valid characters
  *  @return  error code
  */
-nsresult CScanner::ReadWhile(nsString& aString,
+nsresult nsScanner::ReadWhile(nsString& aString,
                              nsString& aValidSet,
                              PRBool anOrderedSet,
                              PRBool addTerminal){
@@ -456,7 +457,7 @@ nsresult CScanner::ReadWhile(nsString& aString,
  *           the set of INVALID characters
  *  @return  error code
  */
-nsresult CScanner::ReadUntil(nsString& aString,
+nsresult nsScanner::ReadUntil(nsString& aString,
                              nsString& aTerminalSet,
                              PRBool anOrderedSet,
                              PRBool addTerminal){
@@ -490,21 +491,21 @@ nsresult CScanner::ReadUntil(nsString& aString,
  *  @param   
  *  @return  error code
  */
-nsresult CScanner::ReadUntil(nsString& aString,
+nsresult nsScanner::ReadUntil(nsString& aString,
                              PRUnichar aTerminalChar,
                              PRBool addTerminal){
-  PRUnichar ch=0;
-  nsresult   result=NS_OK;
+  PRUnichar theChar=0;
+  nsresult  result=NS_OK;
 
   while(NS_OK==result) {
-    result=GetChar(ch);
-    if(ch==aTerminalChar) {
+    result=GetChar(theChar);
+    if(theChar==aTerminalChar) {
       if(addTerminal)
-        aString+=ch;
-      else PutBack(ch);
+        aString+=theChar;
+      else PutBack(theChar);
       break;
     }
-    else aString+=ch;
+    else aString+=theChar;
   }
   return result;
 }
@@ -515,7 +516,7 @@ nsresult CScanner::ReadUntil(nsString& aString,
  *  @param   
  *  @return  
  */
-nsString& CScanner::GetBuffer(void) {
+nsString& nsScanner::GetBuffer(void) {
   return mBuffer;
 }
 
@@ -527,7 +528,7 @@ nsString& CScanner::GetBuffer(void) {
  *  @update  gess 5/12/98
  *  @return  
  */
-nsString& CScanner::GetFilename(void) {
+nsString& nsScanner::GetFilename(void) {
   return mFilename;
 }
 
@@ -540,7 +541,7 @@ nsString& CScanner::GetFilename(void) {
  *  @return  
  */
 
-void CScanner::SelfTest(void) {
+void nsScanner::SelfTest(void) {
 #ifdef _DEBUG
 #endif
 }
diff --git a/htmlparser/src/nsScanner.h b/htmlparser/src/nsScanner.h
index d9e577c05ee6..39a8c046a913 100644
--- a/htmlparser/src/nsScanner.h
+++ b/htmlparser/src/nsScanner.h
@@ -33,12 +33,12 @@
 #define SCANNER
 
 #include "nsString.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "prtypes.h"
 #include <fstream.h>
 
 
-class CScanner {
+class nsScanner {
   public:
 
       /**
@@ -50,7 +50,7 @@ class CScanner {
        *  @param   aMode represents the parser mode (nav, other)
        *  @return  
        */
-      CScanner(nsString& anHTMLString);
+      nsScanner(nsString& anHTMLString);
 
       /**
        *  Use this constructor if you want i/o to be based on 
@@ -60,7 +60,7 @@ class CScanner {
        *  @param   aMode represents the parser mode (nav, other)
        *  @return  
        */
-      CScanner(nsString& aFilename,PRBool aCreateStream);
+      nsScanner(nsString& aFilename,PRBool aCreateStream);
 
       /**
        *  Use this constructor if you want i/o to be stream based.
@@ -69,10 +69,10 @@ class CScanner {
        *  @param   aMode represents the parser mode (nav, other)
        *  @return  
        */
-      CScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership=PR_TRUE);
+      nsScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership=PR_TRUE);
 
 
-      ~CScanner();
+      ~nsScanner();
 
       /**
        *  retrieve next char from internal input stream
@@ -232,7 +232,7 @@ class CScanner {
        */
       PRBool Append(const char* aBuffer, PRUint32 aLen);
 
-      PRBool Append(const PRUnichar* aBuffer, PRInt32 aLen);
+      PRBool Append(const PRUnichar* aBuffer, PRUint32 aLen);
 
       /**
        *  
diff --git a/htmlparser/src/nsToken.cpp b/htmlparser/src/nsToken.cpp
index 18612f774c22..b8c082ba4bc5 100644
--- a/htmlparser/src/nsToken.cpp
+++ b/htmlparser/src/nsToken.cpp
@@ -100,7 +100,7 @@ void CToken::Reinitialize(PRInt32 aTag, const nsString& aString){
  *  @param  aScanner -- object to retrieve data from
  *  @return int error code
  */
-nsresult CToken::Consume(PRUnichar aChar,CScanner& aScanner) {
+nsresult CToken::Consume(PRUnichar aChar,nsScanner& aScanner) {
   nsresult result=NS_OK;
   return result;
 }
diff --git a/htmlparser/src/nsToken.h b/htmlparser/src/nsToken.h
index 399624f8554c..35afff804092 100644
--- a/htmlparser/src/nsToken.h
+++ b/htmlparser/src/nsToken.h
@@ -39,7 +39,7 @@
 #include "nsString.h"
 #include <iostream.h>
 
-class CScanner;
+class nsScanner;
 
 
 /**
@@ -147,7 +147,7 @@ class CToken {
      * @param   aScanner -- input source where token should get data
      * @return  error code (0 means ok)
      */
-    virtual nsresult Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult Consume(PRUnichar aChar,nsScanner& aScanner);
 
     /**
      * Causes token to dump itself in debug form to given output stream
diff --git a/htmlparser/src/nsTokenHandler.cpp b/htmlparser/src/nsTokenHandler.cpp
index 361961db8b7a..12b5e380ca01 100644
--- a/htmlparser/src/nsTokenHandler.cpp
+++ b/htmlparser/src/nsTokenHandler.cpp
@@ -28,7 +28,7 @@
 #include "nsDebug.h"
 #include "nsIDTD.h"
 #include "nsToken.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 
 
 /**
@@ -74,8 +74,8 @@ PRInt32 CTokenHandler::GetTokenType(void){
  *  @param   
  *  @return  
  */
-PRInt32 CTokenHandler::operator()(CToken* aToken,nsIDTD* aDTD){
-  PRInt32 result=kNoError;
+nsresult CTokenHandler::operator()(CToken* aToken,nsIDTD* aDTD){
+  nsresult result=NS_OK;
   if((0!=aDTD) && (0!=mFP)) {
      result=(*mFP)(aToken,aDTD);
   }
diff --git a/htmlparser/src/nsTokenHandler.h b/htmlparser/src/nsTokenHandler.h
index e846f075774b..00e981b491a0 100644
--- a/htmlparser/src/nsTokenHandler.h
+++ b/htmlparser/src/nsTokenHandler.h
@@ -39,7 +39,7 @@ public:
   virtual               ~CTokenHandler();
                           
   virtual   PRInt32     GetTokenType(void);
-  virtual   PRInt32     operator()(CToken* aToken,nsIDTD* aDTD);
+  virtual   nsresult    operator()(CToken* aToken,nsIDTD* aDTD);
 
 protected:
             PRInt32     mType;
diff --git a/htmlparser/src/nsValidDTD.cpp b/htmlparser/src/nsValidDTD.cpp
index 1e4a8bf02c9d..24b56182ac52 100644
--- a/htmlparser/src/nsValidDTD.cpp
+++ b/htmlparser/src/nsValidDTD.cpp
@@ -36,7 +36,7 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
 
 #include "prenv.h"  //this is here for debug reasons...
@@ -133,6 +133,7 @@ CValidDTD::CValidDTD() : nsIDTD() {
   NS_INIT_REFCNT();
   mParser=0;
   mFilename=0;
+  mTokenizer=0;
 }
 
 /**
@@ -145,6 +146,17 @@ CValidDTD::CValidDTD() : nsIDTD() {
 CValidDTD::~CValidDTD(){
 }
 
+
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CValidDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -206,13 +218,26 @@ NS_IMETHODIMP CValidDTD::WillBuildModel(nsString& aFilename,PRBool aNotifySink,n
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CValidDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CValidDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+NS_IMETHODIMP CValidDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result=NS_OK;
 
   return result;
@@ -226,45 +251,13 @@ NS_IMETHODIMP CValidDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,ns
  *******************************************************************/
 
 /**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
  */
-NS_IMETHODIMP CValidDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser){
-
-  mParser=(nsParser*)aParser;
-  CScanner* theScanner=mParser->GetScanner();
-
-  PRUnichar aChar;
-  nsresult   result=theScanner->GetChar(aChar);
-
-  switch(result) {
-    case kEOF:
-      break;
-
-    case kInterrupted:
-      theScanner->RewindToMark();
-      break; 
-
-    case NS_OK:
-    default:
-      switch(aChar) {
-        case kLessThan:
-        default:
-          break;
-      } //switch
-      break; 
-  } //switch
-  if(NS_OK==result)
-    result=theScanner->Eof();
-  return result;
+nsITokenizer* CValidDTD::GetTokenizer(void){
+  return 0;
 }
 
 /**
diff --git a/htmlparser/src/nsValidDTD.h b/htmlparser/src/nsValidDTD.h
index de2da6d5be46..7d71bdcb65ff 100644
--- a/htmlparser/src/nsValidDTD.h
+++ b/htmlparser/src/nsValidDTD.h
@@ -44,7 +44,7 @@ class nsIDTDDebug;
 class nsIParserNode;
 class CITokenHandler;
 class nsParser;
-
+class nsITokenizer;
 
 
 class CValidDTD : public nsIDTD {
@@ -72,6 +72,8 @@ class CValidDTD : public nsIDTD {
      */
     virtual ~CValidDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -121,6 +123,16 @@ class CValidDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -129,7 +141,7 @@ class CValidDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -159,15 +171,12 @@ class CValidDTD : public nsIDTD {
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
+    nsITokenizer* GetTokenizer(void);
 
     /**
      * 
@@ -238,6 +247,7 @@ protected:
     nsParser*           mParser;
     nsIHTMLContentSink* mSink;
     char*               mFilename;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewValid_DTD(nsIDTD** aInstancePtrResult);
diff --git a/htmlparser/src/nsViewSourceHTML.cpp b/htmlparser/src/nsViewSourceHTML.cpp
index 010884c2ba07..cf1289f4b7b9 100644
--- a/htmlparser/src/nsViewSourceHTML.cpp
+++ b/htmlparser/src/nsViewSourceHTML.cpp
@@ -29,11 +29,12 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
 #include "nsDTDUtils.h"
 #include "nsIContentSink.h"
 #include "nsIHTMLContentSink.h"
+#include "nsHTMLTokenizer.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"  //this is here for debug reasons...
@@ -183,6 +184,7 @@ CViewSourceHTML::CViewSourceHTML() : nsIDTD(), mTokenDeque(gTokenKiller) {
   mSink=0;
   mFilename;
   mLineNumber=0;
+  mTokenizer=0;
   mIsHTML=PR_FALSE;
 }
 
@@ -197,6 +199,16 @@ CViewSourceHTML::~CViewSourceHTML(){
   mParser=0; //just to prove we destructed...
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CViewSourceHTML::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -286,13 +298,45 @@ NS_IMETHODIMP CViewSourceHTML::WillBuildModel(nsString& aFilename,PRBool aNotify
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CViewSourceHTML::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+
+  nsHTMLTokenizer*  theTokenizer=(nsHTMLTokenizer*)GetTokenizer();
+  nsITokenRecycler* theRecycler=GetTokenRecycler();
+  if(theTokenizer) {
+    while(NS_OK==result){
+      CToken* theToken=theTokenizer->PopToken();
+      if(theToken) {
+        result=HandleToken(theToken,aParser);
+        if(NS_SUCCEEDED(result)) {
+          theRecycler->RecycleToken(theToken);
+        }
+        else if(NS_ERROR_HTMLPARSER_BLOCK!=result){
+          theTokenizer->PushTokenFront(theToken);
+        }
+        // theRootDTD->Verify(kEmptyString,aParser);
+      }
+      else break;
+    }
+  }
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CViewSourceHTML::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+NS_IMETHODIMP CViewSourceHTML::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result= NS_OK;
 
   //ADD CODE HERE TO CLOSE OPEN CONTAINERS...
@@ -319,344 +363,27 @@ NS_IMETHODIMP CViewSourceHTML::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifyS
   return result;
 }
 
-
-static eHTMLTags gSkippedContentTags[]={ eHTMLTag_script, eHTMLTag_style,  eHTMLTag_title,  eHTMLTag_textarea};
-
-
 /**
  * 
- * @update	gess11/9/98
+ * @update	gess8/4/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CViewSourceHTML::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
-  
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(NS_OK==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-
-      //EEEEECCCCKKKK!!! 
-      //This code is confusing, so pay attention.
-      //If you're here, it's because we were in the midst of consuming a start
-      //tag but ran out of data (not in the stream, but in this *part* of the stream.
-      //For simplicity, we have to unwind our input. Therefore, we pop and discard
-      //any new tokens we've cued this round. Later we can get smarter about this.
-      if(NS_OK!=result) {
-        while(mTokenDeque.GetSize()>theDequeSize) {
-          delete (CToken*)mTokenDeque.PopBack();
-        }
-      }
-
-
-    } //if
-  } //if
-  return result;
+nsITokenRecycler* CViewSourceHTML::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
+ * Retrieve the preferred tokenizer for use by this DTD.
+ * @update	gess12/28/98
+ * @param   none
+ * @return  ptr to tokenizer
  */
-NS_IMETHODIMP CViewSourceHTML::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
-  if(aToken) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-    if(result) {
-      nsString& temp=aToken->GetStringValueXXX();
-      if(0==temp.Length()){
-        delete aToken;
-        aToken = nsnull;
-      }
-      else result=kNoError;
-    }
-  }
-  return result;
-}
-
-/**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  nsresult result=NS_OK;
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==NS_OK)) {
-    CAttributeToken* theToken= (CAttributeToken*)gTokenRecycler.CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
- 
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else if(NS_OK==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(NS_OK==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  theChar;
-   nsresult result=aScanner.GetChar(theChar);
-
-   if(NS_OK==result) {
-     if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==theChar) {
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       aScanner.PutBack(theChar);
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
-  nsresult result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created newline token that is parsing
- *  @return error code
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gess 5/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsresult result=aScanner.GetChar(aChar);
-
-  if(NS_OK==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(NS_OK==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=gTokenRecycler.CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
-          else aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_unknown,gEmpty);
-        }//if
-        break;
-
-      case kExclamation:
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-        break;
-
-      case kQuestionMark: //it must be an XML processing instruction...
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
-        break;
-
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (NS_OK==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
-}
-
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return NS_OK;
-  }
-
-  mParser=(nsParser*)aParser;
-
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    PRUnichar theChar;
-    result=theScanner->GetChar(theChar);
-    switch(result) {
-      case kEOF:
-          //We convert from eof to complete here, because we never really tried to get data.
-          //All we did was try to see if data was available, which it wasn't.
-          //It's important to return process complete, so that controlling logic can know that
-          //everything went well, but we're done with token processing.
-        result=kProcessComplete;
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(theChar) {
-          case kLessThan:
-            result=ConsumeTag(theChar,*theScanner,aToken);
-            break;
-
-          case kAmpersand:
-            result=ConsumeEntity(theChar,*theScanner,aToken);
-            break;
-          
-          case kCR: case kLF:
-            result=ConsumeNewline(theChar,*theScanner,aToken);
-            break;
-          
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(theChar)) {
-              nsAutoString temp(theChar);
-              result=ConsumeText(temp,*theScanner,aToken);
-              break;
-            }
-            result=ConsumeWhitespace(theChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-//    if(NS_OK==result)
-//      result=theScanner->Eof(); 
-  } //if
-  return result;
+nsITokenizer* CViewSourceHTML::GetTokenizer(void) {
+  if(!mTokenizer)
+    mTokenizer=new nsHTMLTokenizer();
+  return mTokenizer;
 }
 
 /**
@@ -872,20 +599,16 @@ PRBool WriteTag(nsCParserNode& aNode,nsIContentSink& aSink,PRBool anEndToken,PRB
         SetStyle(eHTMLTag_b,PR_FALSE,aSink);
       }
 
-      { //next write the equal sign...
-        theString="=";
-        CTextToken theToken(theString);  
-        nsCParserNode theNode(&theToken,aNode.GetSourceLineNumber());
-        aSink.AddLeaf(theNode);
-      }
-
        //begin by writing the value...
       {
         SetColor("blue",PR_TRUE,aSink);
         theString=aNode.GetValueAt(theIndex);
-        CTextToken theToken(theString);  
-        nsCParserNode theNode(&theToken,aNode.GetSourceLineNumber());
-        aSink.AddLeaf(theNode);
+        if(0<theString.Length()){
+          theString.Insert('=',0);
+          CTextToken theToken(theString);  
+          nsCParserNode theNode(&theToken,aNode.GetSourceLineNumber());
+          aSink.AddLeaf(theNode);
+        }
         SetStyle(eHTMLTag_font,PR_FALSE,aSink);
       }
     }
@@ -975,15 +698,15 @@ NS_IMETHODIMP CViewSourceHTML::HandleToken(CToken* aToken,nsIParser* aParser) {
         if(0<attrCount){ //go collect the attributes...
           int attr=0;
           for(attr=0;attr<attrCount;attr++){
-            CToken* theToken=mParser->PeekToken();
+            CToken* theToken=mTokenizer->PeekToken();
             if(theToken)  {
               eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
               if(eToken_attribute==theType){
-                mParser->PopToken(); //pop it for real...
+                mTokenizer->PopToken(); //pop it for real...
                 theNode.AddAttribute(theToken);
               } 
             }
-            else return kInterrupted;
+            else return kEOF;
           }
         }
       }
@@ -1024,13 +747,3 @@ nsresult CViewSourceHTML::ReleaseTokenPump(nsITagHandler* aHandler){
   nsresult result=NS_OK;
   return result;
 }
-
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* CViewSourceHTML::GetTokenRecycler(void){
-  return &gTokenRecycler;
-}
diff --git a/htmlparser/src/nsViewSourceHTML.h b/htmlparser/src/nsViewSourceHTML.h
index 85cdecd0cabb..df401fb2f01e 100644
--- a/htmlparser/src/nsViewSourceHTML.h
+++ b/htmlparser/src/nsViewSourceHTML.h
@@ -44,7 +44,7 @@ class nsIDTDDebug;
 class nsIParserNode;
 class CITokenHandler;
 class nsParser;
-
+class nsITokenizer;
 
 
 class CViewSourceHTML: public nsIDTD {
@@ -63,6 +63,8 @@ class CViewSourceHTML: public nsIDTD {
      */
     CViewSourceHTML();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      *  
      *  
@@ -111,6 +113,16 @@ class CViewSourceHTML: public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -119,7 +131,7 @@ class CViewSourceHTML: public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -130,14 +142,21 @@ class CViewSourceHTML: public nsIDTD {
     NS_IMETHOD HandleToken(CToken* aToken,nsIParser* aParser);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
+    nsITokenizer* GetTokenizer(void);
+
+    
+    /**
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
+     */
+    virtual  nsITokenRecycler* GetTokenRecycler(void);
 
     /**
      *  This method causes all tokens to be dispatched to the given tag handler.
@@ -213,32 +232,18 @@ class CViewSourceHTML: public nsIDTD {
      */
     virtual PRBool IsContainer(PRInt32 aTag) const;
 
-    /**
-     * Retrieve a ptr to the global token recycler...
-     * @update	gess8/4/98
-     * @return  ptr to recycler (or null)
-     */
-    virtual nsITokenRecycler* GetTokenRecycler(void);
 
     static nsresult WriteText(nsString& aTextString,nsIContentSink& aSink,PRBool aPreserveText);
     
 protected:
 
-    NS_IMETHODIMP ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-
     nsParser*           mParser;
     nsIHTMLContentSink* mSink;
     nsString            mFilename;
     PRInt32             mLineNumber;
     nsDeque             mTokenDeque;
     PRBool              mIsHTML;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewViewSourceHTML(nsIDTD** aInstancePtrResult);
diff --git a/htmlparser/src/nsWellFormedDTD.cpp b/htmlparser/src/nsWellFormedDTD.cpp
index 9bd96e08e2a4..b58b92d966ca 100644
--- a/htmlparser/src/nsWellFormedDTD.cpp
+++ b/htmlparser/src/nsWellFormedDTD.cpp
@@ -29,11 +29,12 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
 #include "nsDTDUtils.h"
 #include "nsIContentSink.h"
 #include "nsIHTMLContentSink.h"
+#include "nsXMLTokenizer.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"  //this is here for debug reasons...
@@ -136,6 +137,7 @@ CWellFormedDTD::CWellFormedDTD() : nsIDTD(), mTokenDeque(gTokenKiller) {
   mSink=0;
   mFilename;
   mLineNumber=0;
+  mTokenizer=0;
 }
 
 /**
@@ -149,6 +151,16 @@ CWellFormedDTD::~CWellFormedDTD(){
   mParser=0; //just to prove we destructed...
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CWellFormedDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -231,13 +243,45 @@ NS_IMETHODIMP CWellFormedDTD::WillBuildModel(nsString& aFilename,PRBool aNotifyS
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess  1/4/99
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CWellFormedDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+
+  nsHTMLTokenizer*  theTokenizer=(nsHTMLTokenizer*)GetTokenizer();
+  nsITokenRecycler* theRecycler=GetTokenRecycler();
+  if(theTokenizer) {
+    while(NS_OK==result){
+      CToken* theToken=theTokenizer->PopToken();
+      if(theToken) {
+        result=HandleToken(theToken,aParser);
+        if(NS_SUCCEEDED(result)) {
+          theRecycler->RecycleToken(theToken);
+        }
+        else {
+          theTokenizer->PushTokenFront(theToken);
+        }
+        // theRootDTD->Verify(kEmptyString,aParser);
+      }
+      else break;
+    }
+  }
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CWellFormedDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+NS_IMETHODIMP CWellFormedDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result= NS_OK;
 
   //ADD CODE HERE TO CLOSE OPEN CONTAINERS...
@@ -270,411 +314,27 @@ NS_IMETHODIMP CWellFormedDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySi
   return result;
 }
 
-static eHTMLTags gSkippedContentTags[]={ eHTMLTag_script, eHTMLTag_style,  eHTMLTag_title,  eHTMLTag_textarea};
-
-
 /**
  * 
- * @update	gess11/9/98
+ * @update	gess8/4/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CWellFormedDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
-  
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(NS_OK==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-
-      //EEEEECCCCKKKK!!! 
-      //This code is confusing, so pay attention.
-      //If you're here, it's because we were in the midst of consuming a start
-      //tag but ran out of data (not in the stream, but in this *part* of the stream.
-      //For simplicity, we have to unwind our input. Therefore, we pop and discard
-      //any new tokens we've cued this round. Later we can get smarter about this.
-      if(NS_OK!=result) {
-        while(mTokenDeque.GetSize()>theDequeSize) {
-          delete (CToken*)mTokenDeque.PopBack();
-        }
-      }
-
-
-    } //if
-  } //if
-  return result;
+nsITokenRecycler* CWellFormedDTD::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
+ * Retrieve the preferred tokenizer for use by this DTD.
+ * @update	gess12/28/98
+ * @param   none
+ * @return  ptr to tokenizer
  */
-NS_IMETHODIMP CWellFormedDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
-  if(aToken) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-    if(result) {
-      nsString& temp=aToken->GetStringValueXXX();
-      if(0==temp.Length()){
-        delete aToken;
-        aToken = nsnull;
-      }
-      else result=kNoError;
-    }
-  }
-  return result;
-}
-
-/**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  nsresult result=NS_OK;
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==NS_OK)) {
-    CAttributeToken* theToken= (CAttributeToken*)gTokenRecycler.CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
- 
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else if(NS_OK==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(NS_OK==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  theChar;
-   nsresult result=aScanner.GetChar(theChar);
-
-   if(NS_OK==result) {
-     if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==theChar) {
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       aScanner.PutBack(theChar);
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
-  nsresult result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/*
- * Consume characters as long as they match the string passed in.
- * If they don't match, put them all back. 
- * XXX The scanner should be able to do this.
- *
- *  @update vidur 11/12/98
- */
-static nsresult
-ConsumeConditional(CScanner& aScanner, 
-                   const nsString& aMatchString,
-                   PRBool& aMatch)
-{
-  nsresult result=NS_OK;
-  PRUnichar matchChar;
-
-  PRInt32 i, count = aMatchString.Length();
-  for (i=0; i < count; i++) {
-    result = aScanner.GetChar(matchChar);
-    if ((NS_OK != result) || (aMatchString.CharAt(i) != matchChar)) {
-      break;
-    }
-  }
-
-  if (NS_OK == result) {
-    if (i != count) {
-      for (; i >= 0; i--) {
-        aScanner.PutBack(aMatchString.CharAt(i));
-      }
-      aMatch = PR_FALSE;
-    }
-    else {
-      aMatch = PR_TRUE;
-    }
-  }
-
-  return result;
-}
-
-/**
- *  This method is called when we see a "<!" sequence. The result
- *  could be a comment or a CDATASection.
- *  XXX "Escaped Content" is not the right term, but I couldn't think
- *  of a good one.
- *  
- *  @update vidur 11/12/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created token (comment or cdatasection)
- *  @return error code
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeEscapedContent(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-  nsAutoString CDATAString("[CDATA[");
-  PRBool isCDATA = PR_FALSE;
-
-  result = ConsumeConditional(aScanner, CDATAString, isCDATA);
-  if (NS_OK == result) {
-    if (isCDATA) {
-      aToken=gTokenRecycler.CreateTokenOfType(eToken_cdatasection,eHTMLTag_unknown,gEmpty);
-    }
-    else {
-      aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-    }
-  }
-
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created newline token that is parsing
- *  @return error code
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  vidur 11/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsresult result=aScanner.GetChar(aChar);
-
-  if(NS_OK==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(NS_OK==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=gTokenRecycler.CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
-          else aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_unknown,gEmpty);
-        }//if
-        break;
-
-      case kExclamation:
-        result = ConsumeEscapedContent(aChar, aScanner, aToken);
-        break;
-
-      case kQuestionMark: //it must be an XML processing instruction...
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
-        break;
-
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (NS_OK==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
-}
-
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return NS_OK;
-  }
-
-  mParser=(nsParser*)aParser;
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    PRUnichar theChar;
-    result=theScanner->GetChar(theChar);
-    switch(result) {
-      case kEOF:
-          //We convert from eof to complete here, because we never really tried to get data.
-          //All we did was try to see if data was available, which it wasn't.
-          //It's important to return process complete, so that controlling logic can know that
-          //everything went well, but we're done with token processing.
-        result=kProcessComplete;
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(theChar) {
-          case kLessThan:
-            result=ConsumeTag(theChar,*theScanner,aToken);
-            break;
-
-          case kAmpersand:
-            result=ConsumeEntity(theChar,*theScanner,aToken);
-            break;
-          
-          case kCR: case kLF:
-            result=ConsumeNewline(theChar,*theScanner,aToken);
-            break;
-            
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(theChar)) {
-              nsAutoString temp(theChar);
-              result=ConsumeText(temp,*theScanner,aToken);
-              break;
-            }
-            result=ConsumeWhitespace(theChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-//    if(NS_OK==result)
-//      result=theScanner->Eof(); 
-  } //if
-  return result;
+nsITokenizer* CWellFormedDTD::GetTokenizer(void) {
+  if(!mTokenizer)
+    mTokenizer=new nsXMLTokenizer();
+  return mTokenizer;
 }
 
 /**
@@ -796,15 +456,15 @@ NS_IMETHODIMP CWellFormedDTD::HandleToken(CToken* aToken,nsIParser* aParser) {
         if(0<attrCount){ //go collect the attributes...
           int attr=0;
           for(attr=0;attr<attrCount;attr++){
-            CToken* theToken=mParser->PeekToken();
+            CToken* theToken=mTokenizer->PeekToken();
             if(theToken)  {
               eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
               if(eToken_attribute==theType){
-                mParser->PopToken(); //pop it for real...
+                mTokenizer->PopToken(); //pop it for real...
                 theNode.AddAttribute(theToken);
               } 
             }
-            else return kInterrupted;
+            else return kEOF;
           }
         }
         if(NS_OK==result){
@@ -852,13 +512,3 @@ nsresult CWellFormedDTD::ReleaseTokenPump(nsITagHandler* aHandler){
   nsresult result=NS_OK;
   return result;
 }
-
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* CWellFormedDTD::GetTokenRecycler(void){
-  return &gTokenRecycler;
-}
diff --git a/htmlparser/src/nsWellFormedDTD.h b/htmlparser/src/nsWellFormedDTD.h
index 171d3b99fe6d..2d1a8dca56e3 100644
--- a/htmlparser/src/nsWellFormedDTD.h
+++ b/htmlparser/src/nsWellFormedDTD.h
@@ -72,6 +72,7 @@ class CWellFormedDTD : public nsIDTD {
      */
     virtual ~CWellFormedDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
 
     /**
      * Call this method if you want the DTD to construct a clone of itself.
@@ -110,6 +111,16 @@ class CWellFormedDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -118,7 +129,7 @@ class CWellFormedDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -147,15 +158,12 @@ class CWellFormedDTD : public nsIDTD {
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
+    nsITokenizer* GetTokenizer(void);
 
     /**
      * 
@@ -220,22 +228,23 @@ class CWellFormedDTD : public nsIDTD {
     virtual nsITokenRecycler* GetTokenRecycler(void);
     
 protected:
-
-    NS_IMETHODIMP ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeEscapedContent(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-
+/*
+    NS_IMETHODIMP ConsumeTag(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeStartTag(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeText(const nsString& aString,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeNewline(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeWhitespace(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeEscapedContent(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeComment(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeEntity(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeAttributes(PRUnichar aChar,nsScanner& aScanner,CStartToken* aToken);
+*/
     nsParser*           mParser;
     nsIContentSink*     mSink;
     nsString            mFilename;
     PRInt32             mLineNumber;
     nsDeque             mTokenDeque;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewWellFormed_DTD(nsIDTD** aInstancePtrResult);
diff --git a/htmlparser/src/nsXIFDTD.cpp b/htmlparser/src/nsXIFDTD.cpp
index 2c80cfbb40db..153786a12b7c 100644
--- a/htmlparser/src/nsXIFDTD.cpp
+++ b/htmlparser/src/nsXIFDTD.cpp
@@ -26,7 +26,7 @@
 #include "nsXIFDTD.h" 
 #include "nsHTMLTokens.h"
 #include "nsCRT.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsParser.h"
 #include "nsScanner.h"
 #include "nsTokenHandler.h"
@@ -34,7 +34,7 @@
 #include "nsIHTMLContentSink.h"
 #include "nsHTMLContentSinkStream.h"
 #include "prmem.h"
-
+#include "nsXMLTokenizer.h"
 
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
 static NS_DEFINE_IID(kIDTDIID,      NS_IDTD_IID);
@@ -321,6 +321,7 @@ static nsXIfTokenDeallocator gTokenKiller;
  */
 nsXIFDTD::nsXIFDTD() : nsIDTD(), mTokenDeque(gTokenKiller)  {
   mParser=0;
+  mTokenizer=0;
   nsCRT::zero(mContextStack,sizeof(mContextStack));
   nsCRT::zero(mTokenHandlers,sizeof(mTokenHandlers));
   
@@ -354,6 +355,17 @@ nsXIFDTD::~nsXIFDTD(){
 }
 
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& nsXIFDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -419,13 +431,26 @@ nsresult nsXIFDTD::WillBuildModel(nsString& aFileName,PRBool aNotifySink,nsIPars
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP nsXIFDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+  return result;
+}
+
 /**
  * 
  * @update	gess 7/24/98
  * @param 
  * @return
  */
-nsresult nsXIFDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+nsresult nsXIFDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result=NS_OK;
 
   if(aParser){
@@ -503,7 +528,7 @@ nsresult nsXIFDTD::ReleaseTokenPump(nsITagHandler* aHandler){
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CStartToken*  st    = (CStartToken*)(aToken);
@@ -512,9 +537,9 @@ PRInt32 nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
   //Begin by gathering up attributes...
   nsCParserNode node((CHTMLToken*)aToken);
   PRInt16       attrCount=aToken->GetAttributeCount();
-  PRInt32       result=(0==attrCount) ? kNoError : CollectAttributes(node,attrCount);
+  nsresult      result=(0==attrCount) ? NS_OK : CollectAttributes(node,attrCount);
 
-  if(kNoError==result)
+  if(NS_OK==result)
   {
     if (mInContent == PR_TRUE)
       mSink->AddLeaf(node);
@@ -532,14 +557,14 @@ PRInt32 nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleTextToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleTextToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CStartToken*    st    = (CStartToken*)(aToken);
   eXIFTags        type  =(eXIFTags)st->GetTypeID();
   nsCParserNode   node((CHTMLToken*)aToken);
 
-  PRInt32 result = kNoError;
+  nsresult result = NS_OK;
 
   if (type == eXIFTag_text)
   {
@@ -555,8 +580,7 @@ PRInt32 nsXIFDTD::HandleTextToken(CToken* aToken) {
 }
 
 
-void nsXIFDTD::AddAttribute(nsIParserNode& aNode)
-{
+void nsXIFDTD::AddAttribute(nsIParserNode& aNode) {
   nsString key;
   nsString value;
   PRBool   hasValue;
@@ -572,12 +596,12 @@ void nsXIFDTD::AddAttribute(nsIParserNode& aNode)
  *  This method gets called when a start token has been 
  *  encountered in the parse process. 
  *  
- *  @update  gpk 06/18/98
+ *  @update  gess 12/28/98
  *  @param   aToken -- next (start) token to be handled
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleStartToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleStartToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CStartToken*  st    = (CStartToken*)(aToken);
@@ -586,10 +610,9 @@ PRInt32 nsXIFDTD::HandleStartToken(CToken* aToken) {
   //Begin by gathering up attributes...
   nsCParserNode   node = ((CHTMLToken*)aToken);
   PRInt16         attrCount=aToken->GetAttributeCount();
-  PRInt32         result=(0==attrCount) ? kNoError : CollectAttributes(node,attrCount);
+  nsresult        result=(0==attrCount) ? NS_OK : CollectAttributes(node,attrCount);
 
-  if(kNoError==result)
-  {
+  if(NS_OK==result)   {
     switch (type)
     {
       case eXIFTag_container:
@@ -647,10 +670,10 @@ PRInt32 nsXIFDTD::HandleStartToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleEndToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleEndToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
-  PRInt32         result        = kNoError;
+  nsresult        result        = NS_OK;
   CEndToken*      et            = (CEndToken*)(aToken);
   eXIFTags        tokenTagType  = (eXIFTags)et->GetTypeID();
   nsCParserNode   node          = ((CHTMLToken*)aToken);
@@ -694,11 +717,11 @@ PRInt32 nsXIFDTD::HandleEndToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleEntityToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleEntityToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CEntityToken* et = (CEntityToken*)(aToken);
-  PRInt32       result=kNoError;
+  nsresult      result=NS_OK;
   eXIFTags      tokenTagType=(eXIFTags)et->GetTypeID();
 
   if(PR_FALSE==CanOmit(GetTopNode(),tokenTagType)) {
@@ -718,9 +741,9 @@ PRInt32 nsXIFDTD::HandleEntityToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleCommentToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleCommentToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
-  return kNoError;
+  return NS_OK;
 }
 
 /**
@@ -733,12 +756,12 @@ PRInt32 nsXIFDTD::HandleCommentToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleAttributeToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleAttributeToken(CToken* aToken) {
   CAttributeToken*  at = (CAttributeToken*)(aToken);
   NS_PRECONDITION(0!=aToken,kNullToken);
   NS_ERROR("attribute encountered -- this shouldn't happen!");
 
-  PRInt32 result=kNoError;
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -836,21 +859,6 @@ PRBool nsXIFDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const {
   return result;
 }
 
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gpk 06/18/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool nsXIFDTD::CanContainIndirect(eXIFTags aParent,eXIFTags aChild) const {
-  PRBool result=PR_FALSE;
-  return result;
-}
-
 /**
  *  This method gets called to determine whether a given 
  *  tag can contain newlines. Most do not.
@@ -975,8 +983,8 @@ eXIFTags nsXIFDTD::GetDefaultParentTagFor(eXIFTags aTag) const{
  * @param   aTag is the id of the html container being opened
  * @return  0 if all is well.
  */
-PRInt32 nsXIFDTD::DidOpenContainer(eXIFTags aTag,PRBool /*anExplicitOpen*/){
-  PRInt32   result=0;
+nsresult nsXIFDTD::DidOpenContainer(eXIFTags aTag,PRBool /*anExplicitOpen*/){
+  nsresult   result=NS_OK;
   return result;
 }
 
@@ -986,8 +994,8 @@ PRInt32 nsXIFDTD::DidOpenContainer(eXIFTags aTag,PRBool /*anExplicitOpen*/){
  * @param 
  * @return
  */
-PRInt32 nsXIFDTD::DidCloseContainer(eXIFTags aTag,PRBool/*anExplicitClosure*/){
-  PRInt32 result=0;
+nsresult nsXIFDTD::DidCloseContainer(eXIFTags aTag,PRBool/*anExplicitClosure*/){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -1046,14 +1054,6 @@ PRInt32 nsXIFDTD::GetTopmostIndexOf(eXIFTags aTag) const {
   *
   */
 
-
-
-
-
-
-
-
-
 PRBool nsXIFDTD::GetAttribute(const nsIParserNode& aNode, const nsString& aKey, nsString& aValue)
 {
   PRInt32   i;
@@ -1073,6 +1073,13 @@ PRBool nsXIFDTD::GetAttribute(const nsIParserNode& aNode, const nsString& aKey,
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 PRBool nsXIFDTD::GetAttributePair(nsIParserNode& aNode, nsString& aKey, nsString& aValue)
 {
  
@@ -1105,6 +1112,13 @@ PRBool nsXIFDTD::GetAttributePair(nsIParserNode& aNode, nsString& aKey, nsString
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 eHTMLTags nsXIFDTD::GetHTMLTag(const nsString& aName)
 {
   eHTMLTags  tag = eHTMLTag_unknown;
@@ -1123,6 +1137,13 @@ eHTMLTags nsXIFDTD::GetHTMLTag(const nsString& aName)
 
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 eHTMLTags nsXIFDTD::GetStartTag(const nsIParserNode& aNode, nsString& aName)
 {
   eXIFTags  type = (eXIFTags)aNode.GetNodeType();  
@@ -1145,6 +1166,13 @@ eHTMLTags nsXIFDTD::GetStartTag(const nsIParserNode& aNode, nsString& aName)
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PushHTMLTag(const eHTMLTags aTag, const nsString& aName)
 {
 
@@ -1153,6 +1181,13 @@ void nsXIFDTD::PushHTMLTag(const eHTMLTags aTag, const nsString& aName)
   mHTMLTagStack[++mHTMLStackPos]=eHTMLTag_unknown;
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PopHTMLTag(eHTMLTags& aTag, nsString*& aName)
 {
   NS_ASSERTION(mHTMLStackPos > 0,"The stack must not be empty");
@@ -1167,6 +1202,13 @@ void nsXIFDTD::PopHTMLTag(eHTMLTags& aTag, nsString*& aName)
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PushNodeAndToken(nsString& aName)
 {
   CToken*         token = new CStartToken(aName);
@@ -1176,6 +1218,13 @@ void nsXIFDTD::PushNodeAndToken(nsString& aName)
   mNodeStack.AppendElement((void*)node);  
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 nsIParserNode* nsXIFDTD::PeekNode()
 {
   PRInt32 count = mNodeStack.Count()-1;
@@ -1185,6 +1234,13 @@ nsIParserNode* nsXIFDTD::PeekNode()
   return nsnull;
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 CToken* nsXIFDTD::PeekToken()
 {
   PRInt32 count = mTokenStack.Count()-1; 
@@ -1193,6 +1249,13 @@ CToken* nsXIFDTD::PeekToken()
   return nsnull;
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PopAndDelete()
 {
   nsIParserNode* node = PeekNode();
@@ -1208,6 +1271,13 @@ void nsXIFDTD::PopAndDelete()
   }
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 PRBool nsXIFDTD::StartTopOfStack()
 {
   // If something is already on the stack, then
@@ -1232,6 +1302,13 @@ PRBool nsXIFDTD::StartTopOfStack()
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::BeginStartTag(const nsIParserNode& aNode)
 {
   eXIFTags  type = (eXIFTags)aNode.GetNodeType();
@@ -1283,10 +1360,10 @@ void nsXIFDTD::AddEndTag(const nsIParserNode& aNode)
  * @param   aNode -- next node to be added to model
  * @return  TRUE if ok, FALSE if error
  */
-PRInt32 nsXIFDTD::OpenContainer(const nsIParserNode& aNode){
+nsresult nsXIFDTD::OpenContainer(const nsIParserNode& aNode){
   NS_PRECONDITION(mContextStackPos > 0, kInvalidTagStackPos);
   
-  PRInt32   result=kNoError; 
+  nsresult  result=NS_OK; 
   eXIFTags  type =(eXIFTags)aNode.GetNodeType();
 
   switch (type)
@@ -1309,10 +1386,10 @@ PRInt32 nsXIFDTD::OpenContainer(const nsIParserNode& aNode){
  * @param   aNode -- next node to be removed from our model
  * @return  TRUE if ok, FALSE if error
  */
-PRInt32 nsXIFDTD::CloseContainer(const nsIParserNode& aNode)
+nsresult nsXIFDTD::CloseContainer(const nsIParserNode& aNode)
 {
   NS_PRECONDITION(mContextStackPos > 0, kInvalidTagStackPos);
-  PRInt32   result=kNoError; //was false
+  nsresult   result=NS_OK; //was false
   eXIFTags type=(eXIFTags)aNode.GetNodeType();
   
   if (type == eXIFTag_container)
@@ -1333,10 +1410,10 @@ PRInt32 nsXIFDTD::CloseContainer(const nsIParserNode& aNode)
  * @param   aNode -- next node to be added to model
  * @return  TRUE if ok, FALSE if error
  */
-PRInt32 nsXIFDTD::AddLeaf(const nsIParserNode& aNode)
+nsresult nsXIFDTD::AddLeaf(const nsIParserNode& aNode)
 {
   eXIFTags  type = (eXIFTags)aNode.GetNodeType();    
-  PRInt32 result=mSink->AddLeaf(aNode); 
+  nsresult result=mSink->AddLeaf(aNode); 
   return result;
 }
 
@@ -1351,345 +1428,34 @@ PRInt32 nsXIFDTD::AddLeaf(const nsIParserNode& aNode)
  *           create a new context vector
  *  @return  true if we succeeded, otherwise false
  */
-PRInt32 nsXIFDTD::CreateContextStackFor(eXIFTags aChildTag)
+nsresult nsXIFDTD::CreateContextStackFor(eXIFTags aChildTag)
 {
   mContextStack[++mContextStackPos] = aChildTag;
-  return kNoError;
+  return NS_OK;
 }
 
 
-
-
-/*******************************************************************
-  These methods used to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
 /**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gpk 06/18/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
  */
-PRInt32 nsXIFDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsAutoString empty("");
-  PRInt32 result=aScanner.GetChar(aChar);
-
-  if(kNoError==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(kNoError==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=new CEndToken(empty);
-          else aToken=new CCommentToken(empty); //Special case: </ ...> is treated as a comment
-        }//if
-        break;
-      case kExclamation:
-        aToken=new CCommentToken(empty);
-        break;
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (kNoError==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
+nsITokenizer* nsXIFDTD::GetTokenizer(void){
+  if(!mTokenizer)
+    mTokenizer=new nsXMLTokenizer();
+  return mTokenizer;
 }
 
 /**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gpk 06/18/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
+ * 
+ * @update	gess8/4/98
+ * @param 
+ * @return
  */
-PRInt32 nsXIFDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  PRInt32 result=kNoError;
-  nsAutoString as("");
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==kNoError)) {
-    CAttributeToken* theToken= new CAttributeToken(as);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else  if(kNoError==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(kNoError==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
-}
-
-/**
- *  This is a special case method. It's job is to consume 
- *  all of the given tag up to an including the end tag.
- *
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null
- */
-PRInt32 nsXIFDTD::ConsumeContentToEndTag(const nsString& aString,PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  
-  //In the case that we just read the given tag, we should go and
-  //consume all the input until we find a matching end tag.
-
-  nsAutoString endTag("</");
-  endTag.Append(aString);
-  endTag.Append(">");
-  aToken=new CSkippedContentToken(endTag);
-  return aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of a tag.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  PRInt32 result=kNoError;
-
-  aToken=new CStartToken(eHTMLTag_unknown);
-
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(kNoError==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-    } //if
-  } //if
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  ch;
-   PRInt32 result=aScanner.GetChar(ch);
-
-   if(kNoError==result) {
-     if(nsString::IsAlpha(ch)) { //handle common enity references &xxx; or &#000.
-       aToken = new CEntityToken(nsAutoString(""));
-       result = aToken->Consume(ch,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==ch) {
-       aToken = new CEntityToken(nsAutoString(""));
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  aToken = new CWhitespaceToken(nsAutoString(""));
-  PRInt32 result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = new CCommentToken(nsAutoString(""));
-  PRInt32 result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-
-  PRInt32 result=kNoError;
-  if(aToken=new CTextToken(aString)) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=new CNewlineToken(nsAutoString(""));
-  PRInt32 result=kNoError;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult nsXIFDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
-  
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return kNoError;
-  }
-
-  mParser=(nsParser*)aParser;
-
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    
-    PRUnichar aChar;
-    result=theScanner->GetChar(aChar);
-    switch(result) {
-      case kEOF:
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(aChar) {
-          case kLessThan:
-            return ConsumeTag(aChar,*theScanner,aToken);
-
-          case kAmpersand:
-            return ConsumeEntity(aChar,*theScanner,aToken);
-          
-          case kCR: case kLF:
-            return ConsumeNewline(aChar,*theScanner,aToken);
-          
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(aChar)) {
-              nsAutoString temp(aChar);
-              return ConsumeText(temp,*theScanner,aToken);
-            }
-            else return ConsumeWhitespace(aChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-    if(NS_OK==result)
-      result=theScanner->Eof();
-  } //while
-  return result;
+nsITokenRecycler* nsXIFDTD::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
@@ -1701,38 +1467,20 @@ nsresult nsXIFDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
  * @param   aCount is the # of attributes you're expecting
  * @return error code (should be 0)
  */
-PRInt32 nsXIFDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
-/*
-  nsDequeIterator end=mParserContext->mTokenDeque.End();
-
-  int attr=0;
-  for(attr=0;attr<aCount;attr++) {
-    if(*mParserContext->mCurrentPos<end) {
-      CToken* tkn=(CToken*)(++(*mParserContext->mCurrentPos));
-      if(tkn){
-        if(eToken_attribute==eHTMLTokenTypes(tkn->GetTokenType())){
-          aNode.AddAttribute(tkn);
-        } 
-        else (*mParserContext->mCurrentPos)--;
-      }
-      else return kInterrupted;
-    }
-    else return kInterrupted;
-  }
-*/
+nsresult nsXIFDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
   int attr=0;
   for(attr=0;attr<aCount;attr++){
-    CToken* theToken=mParser->PeekToken();
+    CToken* theToken=mTokenizer->PeekToken();
     if(theToken)  {
       eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
       if(eToken_attribute==theType){
-        mParser->PopToken(); //pop it for real...
+        mTokenizer->PopToken(); //pop it for real...
         aNode.AddAttribute(theToken);
       } 
     }
-    else return kInterrupted;
+    else return kEOF;
   }
-  return kNoError;
+  return NS_OK;
 }
 
 
@@ -1744,23 +1492,8 @@ PRInt32 nsXIFDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
  * @param   holds the number of skipped content elements encountered
  * @return  Error condition.
  */
-PRInt32 nsXIFDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
-  PRInt32           result=kNoError;
-/*
-  eHTMLTokenTypes   subtype=eToken_attribute;
-  nsDequeIterator   end=mParserContext->mTokenDeque.End();
-
-  aCount=0;
-  while((*mParserContext->mCurrentPos!=end) && (eToken_attribute==subtype)) {
-    CToken* tkn=(CToken*)(++(*mParserContext->mCurrentPos));
-    subtype=eHTMLTokenTypes(tkn->GetTokenType());
-    if(eToken_skippedcontent==subtype) {
-      aNode.SetSkippedContent(tkn);
-      aCount++;
-    } 
-    else (*mParserContext->mCurrentPos)--;
-  }
-*/
+nsresult nsXIFDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
+  nsresult           result=NS_OK;
   return result;
 }
 
@@ -2004,13 +1737,4 @@ void nsXIFDTD::AddCSSDeclaration(const nsIParserNode& aNode)
 }
 
 
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* nsXIFDTD::GetTokenRecycler(void){
-  return 0;
-}
-
+ 
\ No newline at end of file
diff --git a/htmlparser/src/nsXIFDTD.h b/htmlparser/src/nsXIFDTD.h
index 949150d75f7f..1bc9eb20b002 100644
--- a/htmlparser/src/nsXIFDTD.h
+++ b/htmlparser/src/nsXIFDTD.h
@@ -49,6 +49,7 @@ class nsCParserNode;
 class CTokenHandler;
 class nsIDTDDebug;
 class nsIHTMLContentSink;
+class nsITokenizer;
 
 //*** This enum is used to define the known universe of XIF tags.
 //*** The use of this table doesn't preclude of from using non-standard
@@ -117,6 +118,8 @@ class nsXIFDTD : public nsIDTD {
      */
     nsXIFDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      *  
      *  
@@ -163,13 +166,23 @@ class nsXIFDTD : public nsIDTD {
      */
     NS_IMETHOD WillBuildModel(nsString& aFileName,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
     /**
      *  
      * @update	gess 7/24/98
      * @param 
      * @return
      */
-    NS_IMETHOD DidBuildModel(PRInt32 aQualityLevel,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult aQualityLevel,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -197,16 +210,6 @@ class nsXIFDTD : public nsIDTD {
      */
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gpk 06/18/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
 
     /**
      * 
@@ -269,18 +272,6 @@ class nsXIFDTD : public nsIDTD {
      */
     virtual void SetVerification(PRBool aEnable);
 
-
-    /**
-     *  This method is called to determine whether or not a tag
-     *  of one type can contain a tag of another type.
-     *  
-     *  @update  gpk 06/18/98
-     *  @param   aParent -- tag enum of parent container
-     *  @param   aChild -- tag enum of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainIndirect(eXIFTags aParent,eXIFTags aChild) const;
-
     /**
      *  This method gets called to determine whether a given 
      *  tag can contain newlines. Most do not.
@@ -343,7 +334,7 @@ class nsXIFDTD : public nsIDTD {
      * @param 
      * @return
      */
-    virtual PRInt32 DidOpenContainer(eXIFTags aTag,PRBool anExplicitOpen);    
+    virtual nsresult DidOpenContainer(eXIFTags aTag,PRBool anExplicitOpen);    
 
     /**
      * Ask parser if a given container is open ANYWHERE on stack
@@ -375,7 +366,7 @@ class nsXIFDTD : public nsIDTD {
      * @param 
      * @return
      */
-    virtual PRInt32 DidCloseContainer(eXIFTags aTag,PRBool anExplicitClosure);
+    virtual nsresult DidCloseContainer(eXIFTags aTag,PRBool anExplicitClosure);
 
     /**
      * This method gets called when a start token has been consumed and needs 
@@ -384,7 +375,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the start token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleStartToken(CToken* aToken);
+    nsresult HandleStartToken(CToken* aToken);
 
     /**
      * This method gets called when an end token has been consumed and needs 
@@ -393,7 +384,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the end token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleEndToken(CToken* aToken);
+    nsresult HandleEndToken(CToken* aToken);
 
     /**
      * This method gets called when an entity token has been consumed and needs 
@@ -402,7 +393,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the entity token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleEntityToken(CToken* aToken);
+    nsresult HandleEntityToken(CToken* aToken);
 
     /**
      * This method gets called when a comment token has been consumed and needs 
@@ -411,7 +402,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the comment token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleCommentToken(CToken* aToken);
+    nsresult HandleCommentToken(CToken* aToken);
 
     /**
      * This method gets called when an attribute token has been consumed and needs 
@@ -420,11 +411,11 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the attribute token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleAttributeToken(CToken* aToken);
+    nsresult HandleAttributeToken(CToken* aToken);
 
 
-    PRInt32 HandleWhiteSpaceToken(CToken* aToken);
-    PRInt32 HandleTextToken(CToken* aToken);
+    nsresult HandleWhiteSpaceToken(CToken* aToken);
+    nsresult HandleTextToken(CToken* aToken);
 
 
 private:
@@ -455,9 +446,6 @@ private:
      */
     void DeleteTokenHandlers(void);
 
-
-
-
     /**
      * This cover method opens the given node as a generic container in 
      * content sink.
@@ -465,7 +453,7 @@ private:
      * @param   generic container (node) to be opened in content sink.
      * @return  TRUE if all went well.
      */
-    PRInt32 OpenContainer(const nsIParserNode& aNode);
+    nsresult OpenContainer(const nsIParserNode& aNode);
 
     /**
      * This cover method causes a generic containre in the content-sink to be closed
@@ -473,7 +461,7 @@ private:
      * @param   aNode is the node to be closed in sink (usually ignored)
      * @return  TRUE if all went well.
      */
-    PRInt32 CloseContainer(const nsIParserNode& aNode);
+    nsresult CloseContainer(const nsIParserNode& aNode);
 
     /**
      * Causes leaf to be added to sink at current vector pos.
@@ -481,7 +469,7 @@ private:
      * @param   aNode is leaf node to be added.
      * @return  TRUE if all went well -- FALSE otherwise.
      */
-    PRInt32 AddLeaf(const nsIParserNode& aNode);
+    nsresult AddLeaf(const nsIParserNode& aNode);
 
      /**
      * Attempt forward and/or backward propagation for the given
@@ -490,103 +478,22 @@ private:
      * @param   type of child to be propagated.
      * @return  TRUE if succeeds, otherwise FALSE
      */
-    PRInt32 CreateContextStackFor(eXIFTags aChildTag);
-
-
-    /****************************************************
-        These methods interface with the parser to do
-        the tokenization phase.
-     ****************************************************/
-
+    nsresult CreateContextStackFor(eXIFTags aChildTag);
 
     /**
-     * Retrieve the next TAG from the given scanner.
-     * @update	gpk 06/18/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    PRInt32     ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve next START tag from given scanner.
-     * @update	gpk 06/18/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve collection of HTML/XML attributes from given scanner
-     * @update	gpk 06/18/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-    
-    /**
-     * Retrieve a sequence of text from given scanner.
-     * @update	gpk 06/18/98
-     * @param   aString will contain retrieved text.
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve an entity from given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a whitespace sequence from the given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a comment from the given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
+    nsITokenizer* GetTokenizer(void);
 
     /**
-     * Retrieve newlines from given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
+     * Retrieve a ptr to the global token recycler...
+     * @update	gess8/4/98
+     * @return  ptr to recycler (or null)
      */
-    PRInt32     ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Causes content to be skipped up to sequence contained in aString.
-     * @update	gpk 06/18/98
-     * @param   aString ????
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    virtual PRInt32 ConsumeContentToEndTag(const nsString& aString,PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
+    virtual nsITokenRecycler* GetTokenRecycler(void);
 
 private:
     void BeginCSSStyleSheet(const nsIParserNode& aNode);
@@ -619,18 +526,11 @@ private:
     void            PopAndDelete();
 
 
-    /**
-     * Retrieve a ptr to the global token recycler...
-     * @update	gess8/4/98
-     * @return  ptr to recycler (or null)
-     */
-    virtual nsITokenRecycler* GetTokenRecycler(void);
-
 protected:
 
     PRBool			CanContainFormElement(eXIFTags aParent,eXIFTags aChild) const;
-		PRInt32			CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
-		PRInt32			CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
+		nsresult		CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
+		nsresult		CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
     
     nsParser*             mParser;
     nsIHTMLContentSink*   mSink;
@@ -661,6 +561,7 @@ protected:
     PRInt32               mCSSSelectorCount;
     PRBool                mLowerCaseTags;
     PRBool                mLowerCaseAttributes;
+    nsITokenizer*         mTokenizer;
 };
 
 
diff --git a/htmlparser/src/nsXMLTokenizer.cpp b/htmlparser/src/nsXMLTokenizer.cpp
new file mode 100644
index 000000000000..de1f6dfb3112
--- /dev/null
+++ b/htmlparser/src/nsXMLTokenizer.cpp
@@ -0,0 +1,225 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#include "nsXMLTokenizer.h"
+#include "nsParser.h"
+#include "nsScanner.h"
+#include "nsDTDUtils.h"
+#include "nsParser.h"
+
+/************************************************************************
+  And now for the main class -- nsXMLTokenizer...
+ ************************************************************************/
+
+static NS_DEFINE_IID(kISupportsIID,     NS_ISUPPORTS_IID);                 
+static NS_DEFINE_IID(kITokenizerIID,    NS_ITOKENIZER_IID);
+static NS_DEFINE_IID(kHTMLTokenizerIID, NS_HTMLTOKENIZER_IID);
+static NS_DEFINE_IID(kClassIID,         NS_XMLTOKENIZER_IID); 
+static nsAutoString gEmpty;
+
+/**
+ *  This method gets called as part of our COM-like interfaces.
+ *  Its purpose is to create an interface to parser object
+ *  of some type.
+ *  
+ *  @update   gess 4/8/98
+ *  @param    nsIID  id of object to discover
+ *  @param    aInstancePtr ptr to newly discovered interface
+ *  @return   NS_xxx result code
+ */
+nsresult nsXMLTokenizer::QueryInterface(const nsIID& aIID, void** aInstancePtr)  
+{                                                                        
+  if (NULL == aInstancePtr) {                                            
+    return NS_ERROR_NULL_POINTER;                                        
+  }                                                                      
+
+  if(aIID.Equals(kISupportsIID))    {  //do IUnknown...
+    *aInstancePtr = (nsXMLTokenizer*)(this);                                        
+  }
+  else if(aIID.Equals(kITokenizerIID)) {  //do ITOkenizer base class...
+    *aInstancePtr = (nsITokenizer*)(this);                                        
+  }
+  else if(aIID.Equals(kHTMLTokenizerIID)) {  //do nsHTMLTokenizer base class...
+    *aInstancePtr = (nsHTMLTokenizer*)(this);                                        
+  }
+  else if(aIID.Equals(kClassIID)) {  //do this class...
+    *aInstancePtr = (nsXMLTokenizer*)(this);                                        
+  }                 
+  else {
+    *aInstancePtr=0;
+    return NS_NOINTERFACE;
+  }
+  NS_ADDREF_THIS();
+  return NS_OK;                                                        
+}
+
+
+/**
+ *  This method is defined in nsIParser. It is used to 
+ *  cause the COM-like construction of an nsParser.
+ *  
+ *  @update  gess 4/8/98
+ *  @param   nsIParser** ptr to newly instantiated parser
+ *  @return  NS_xxx error result
+ */
+NS_HTMLPARS nsresult NS_NewXMLTokenizer(nsIDTD** aInstancePtrResult) {
+  nsXMLTokenizer* it = new nsXMLTokenizer();
+
+  if (it == 0) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return it->QueryInterface(kClassIID, (void **) aInstancePtrResult);
+}
+
+
+NS_IMPL_ADDREF(nsXMLTokenizer)
+NS_IMPL_RELEASE(nsXMLTokenizer)
+
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsXMLTokenizer::nsXMLTokenizer() : nsHTMLTokenizer() {
+  NS_INIT_REFCNT();
+  mDoXMLEmptyTags=PR_TRUE;
+}
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsXMLTokenizer::~nsXMLTokenizer(){
+}
+
+
+/*******************************************************************
+  Here begins the real working methods for the tokenizer.
+ *******************************************************************/
+
+/**
+ *  This method repeatedly called by the tokenizer. 
+ *  Each time, we determine the kind of token were about to 
+ *  read, and then we call the appropriate method to handle
+ *  that token type.
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsXMLTokenizer::ConsumeToken(nsScanner& aScanner) {
+  return nsHTMLTokenizer::ConsumeToken(aScanner);
+}
+
+
+nsITokenRecycler* nsXMLTokenizer::GetTokenRecycler(void) {
+  return nsHTMLTokenizer::GetTokenRecycler();
+}
+
+/*
+ * Consume characters as long as they match the string passed in.
+ * If they don't match, put them all back. 
+ * XXX The scanner should be able to do this.
+ *
+ *  @update vidur 11/12/98
+ */
+nsresult ConsumeConditional(nsScanner& aScanner,const nsString& aMatchString,PRBool& aMatch) {
+  nsresult result=NS_OK;
+  PRUnichar matchChar;
+
+  PRInt32 i, count = aMatchString.Length();
+  for (i=0; i < count; i++) {
+    result = aScanner.GetChar(matchChar);
+    if ((NS_OK != result) || (aMatchString.CharAt(i) != matchChar)) {
+      break;
+    }
+  }
+
+  if (NS_OK == result) {
+    if (i != count) {
+      for (; i >= 0; i--) {
+        aScanner.PutBack(aMatchString.CharAt(i));
+      }
+      aMatch = PR_FALSE;
+    }
+    else {
+      aMatch = PR_TRUE;
+    }
+  }
+
+  return result;
+}
+
+/**
+ *  This method is called just after a "<!" has been consumed 
+ *  and we know we're at the start of a comment.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsXMLTokenizer::ConsumeComment(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken){
+  nsresult result=NS_OK;
+  nsAutoString CDATAString("[CDATA[");
+  PRBool isCDATA = PR_FALSE;
+
+  result = ConsumeConditional(aScanner, CDATAString, isCDATA);
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+
+  if (NS_OK == result) {
+    if (isCDATA) {
+      aToken=theRecycler->CreateTokenOfType(eToken_cdatasection,eHTMLTag_unknown,gEmpty);
+    }
+    else {
+      aToken=theRecycler->CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
+    }
+  }
+
+  return result;
+}
+
+
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsXMLTokenizer::HandleSkippedContent(nsScanner& aScanner,CToken*& aToken) {
+  nsresult result=NS_OK;
+  return result;
+}
diff --git a/htmlparser/src/nsXMLTokenizer.h b/htmlparser/src/nsXMLTokenizer.h
new file mode 100644
index 000000000000..75bd893e7930
--- /dev/null
+++ b/htmlparser/src/nsXMLTokenizer.h
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#ifndef __NSXMLTOKENIZER
+#define __NSXMLTOKENIZER
+
+#include "nsISupports.h"
+#include "nsHTMLTokenizer.h"
+#include "nsIParser.h"
+#include "nsIDTD.h"
+#include "prtypes.h"
+#include "nsDeque.h"
+#include "nsScanner.h"
+#include "nsHTMLTokens.h"
+
+#define NS_XMLTOKENIZER_IID      \
+  {0xcf22e1fa, 0x9ed2, 0x11d2, { 0xba, 0xa5, 0x0, 0x10, 0x4b, 0x98, 0x3f, 0xd4 }}
+
+
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+#if defined(XP_PC)
+#pragma warning( disable : 4275 )
+#endif
+
+CLASS_EXPORT_HTMLPARS nsXMLTokenizer : public nsHTMLTokenizer {
+public:
+            nsXMLTokenizer();
+            ~nsXMLTokenizer();
+
+            NS_DECL_ISUPPORTS
+
+  virtual nsresult          ConsumeToken(nsScanner& aScanner);
+  virtual nsITokenRecycler* GetTokenRecycler(void);
+
+protected:
+
+  virtual nsresult HandleSkippedContent(nsScanner& aScanner,CToken*& aToken);
+  virtual nsresult ConsumeComment(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+
+};
+
+extern NS_HTMLPARS nsresult NS_NewXMLTokenizer(nsIDTD** aInstancePtrResult);
+
+#endif
+
+
diff --git a/parser/htmlparser/src/CNavDTD.cpp b/parser/htmlparser/src/CNavDTD.cpp
index 5689727bb709..f4fddf881d0a 100644
--- a/parser/htmlparser/src/CNavDTD.cpp
+++ b/parser/htmlparser/src/CNavDTD.cpp
@@ -1,30 +1,30 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
+/*                        
  * The contents of this file are subject to the Netscape Public License
  * Version 1.0 (the "NPL"); you may not use this file except in
  * compliance with the NPL.  You may obtain a copy of the NPL at
  * http://www.mozilla.org/NPL/
- *
+ *                  
  * Software distributed under the NPL is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  * for the specific language governing rights and limitations under the
  * NPL.
- * 
+ *  
  * The Initial Developer of this code under the NPL is Netscape
  * Communications Corporation.  Portions created by Netscape are
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  * Reserved.
- */ 
-
-#include "nsDebug.h"
-#include "nsIDTDDebug.h" 
+ */    
+    
+#include "nsDebug.h" 
+#include "nsIDTDDebug.h"  
 #include "CNavDTD.h" 
 #include "nsHTMLTokens.h"
 #include "nsCRT.h"
 #include "nsParser.h"
+#include "nsIParser.h"
 #include "nsIHTMLContentSink.h" 
 #include "nsScanner.h"
-#include "nsParserTypes.h"
 #include "nsVoidArray.h"
 #include "nsTokenHandler.h"
 #include "nsIDTDDebug.h"
@@ -35,6 +35,7 @@
 #include "nsDTDUtils.h"
 #include "nsTagHandler.h"
 #include "nsViewSourceHTML.h"
+#include "nsHTMLTokenizer.h"
 
 #ifdef XP_PC
 #include <direct.h> //this is here for debug reasons...
@@ -45,7 +46,7 @@
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
 static NS_DEFINE_IID(kIDTDIID,      NS_IDTD_IID);
 static NS_DEFINE_IID(kClassIID,     NS_INAVHTML_DTD_IID); 
-
+ 
 //static const char* kNullURL = "Error: Null URL given";
 //static const char* kNullFilename= "Error: Null filename given";
 static const char* kNullToken = "Error: Null token given";
@@ -53,7 +54,7 @@ static const char* kInvalidTagStackPos = "Error: invalid tag stack position";
 static const char* kHTMLTextContentType = "text/html";
 static char* kVerificationDir = "c:/temp";
 static const char* kViewSourceCommand= "view-source";
-
+ 
 static nsAutoString gEmpty;
 
 static eHTMLTags gFormElementTags[]= {  
@@ -66,6 +67,7 @@ static eHTMLTags gHeadingTags[]={
   eHTMLTag_h1,  eHTMLTag_h2,  eHTMLTag_h3,  
   eHTMLTag_h4,  eHTMLTag_h5,  eHTMLTag_h6};
 
+  
 static eHTMLTags gStyleTags[]={
   eHTMLTag_a,       eHTMLTag_acronym,   eHTMLTag_b,
   eHTMLTag_bdo,     eHTMLTag_big,       eHTMLTag_blink,
@@ -78,210 +80,23 @@ static eHTMLTags gStyleTags[]={
   eHTMLTag_sub,     eHTMLTag_sup,       eHTMLTag_tt,
   eHTMLTag_u,       eHTMLTag_var};
 
-static eHTMLTags gNonContainers[]={
-  eHTMLTag_area,    eHTMLTag_base,    eHTMLTag_basefont,
-  eHTMLTag_bgsound, eHTMLTag_br,      eHTMLTag_col,     
-  eHTMLTag_embed,   eHTMLTag_frame,   eHTMLTag_img, 
-  eHTMLTag_keygen,  eHTMLTag_hr,      eHTMLTag_input,   
-  eHTMLTag_link,    eHTMLTag_isindex,
-  eHTMLTag_meta,    eHTMLTag_param,   eHTMLTag_plaintext,
-  eHTMLTag_sound,   eHTMLTag_style,   eHTMLTag_spacer,  
-  eHTMLTag_wbr,   
-  eHTMLTag_newline, eHTMLTag_text,    eHTMLTag_whitespace,
-  eHTMLTag_unknown, eHTMLTag_xmp};
 
-static eHTMLTags gTableTags[]={ 
+static eHTMLTags gTableChildTags[]={ 
   eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  eHTMLTag_tbody,   
   eHTMLTag_tfoot,   eHTMLTag_tr,  eHTMLTag_thead,     eHTMLTag_td};
   
 static eHTMLTags gWhitespaceTags[]={
   eHTMLTag_newline, eHTMLTag_whitespace};
 
+static eHTMLTags gHeadChildTags[]={ 
+  eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  eHTMLTag_tbody,   
+  eHTMLTag_tfoot,   eHTMLTag_tr,  eHTMLTag_thead,     eHTMLTag_td};
 
-static eHTMLTags gBlockParentTags []={ 
-  eHTMLTag_applet,    eHTMLTag_basefont,    eHTMLTag_blockquote,
-  eHTMLTag_body,      eHTMLTag_center,      eHTMLTag_dd,    
-  eHTMLTag_div,       eHTMLTag_embed,       eHTMLTag_fieldset,
-  eHTMLTag_form,      eHTMLTag_iframe,      eHTMLTag_layer,
-  eHTMLTag_li,        eHTMLTag_listing,     eHTMLTag_multicol,
-  eHTMLTag_noembed,   eHTMLTag_noframes,    eHTMLTag_nolayer,
-  eHTMLTag_noscript,  eHTMLTag_object,      eHTMLTag_plaintext,
-  eHTMLTag_pre,       eHTMLTag_td,          eHTMLTag_th,
-  eHTMLTag_ul,
-  eHTMLTag_xmp,
-};
-
-static eHTMLTags gBlockChildTags []={ 
-  eHTMLTag_a,         eHTMLTag_abbr,        eHTMLTag_acronym,   eHTMLTag_address,     eHTMLTag_applet,
-  eHTMLTag_b,         eHTMLTag_basefont,    eHTMLTag_bdo,       eHTMLTag_bgsound,     eHTMLTag_big,
-  eHTMLTag_blink,     eHTMLTag_blockquote,  eHTMLTag_br,        eHTMLTag_button,
-  eHTMLTag_center,    eHTMLTag_cite,        eHTMLTag_code,      
-  eHTMLTag_del,       eHTMLTag_dfn,         eHTMLTag_dir,       eHTMLTag_div,       eHTMLTag_dl,
-  eHTMLTag_em,        eHTMLTag_embed,
-  eHTMLTag_fieldset,  eHTMLTag_font,        eHTMLTag_form,
-  eHTMLTag_h1,        eHTMLTag_h2,          eHTMLTag_h3,
-  eHTMLTag_h4,        eHTMLTag_h5,          eHTMLTag_h6,
-  eHTMLTag_hr,      
-
-  eHTMLTag_i,         eHTMLTag_iframe,      eHTMLTag_ilayer,    eHTMLTag_img,         
-  eHTMLTag_ins,       eHTMLTag_isindex,     eHTMLTag_input,
-
-  eHTMLTag_kbd,     
-
-  eHTMLTag_label,     eHTMLTag_layer,       eHTMLTag_listing,
-
-  eHTMLTag_map,       /*eHTMLTag_marque,*/  eHTMLTag_menu,      eHTMLTag_multicol,
-  eHTMLTag_nobr,      eHTMLTag_noembed,     eHTMLTag_noframes,  eHTMLTag_nolayer,   eHTMLTag_noscript,
-
-  eHTMLTag_object,    eHTMLTag_ol,
-  eHTMLTag_p,         eHTMLTag_plaintext,   eHTMLTag_pre,         
-  eHTMLTag_q,
-  eHTMLTag_s,         eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    eHTMLTag_small,
-  eHTMLTag_sound,     eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,
-  eHTMLTag_sub,       eHTMLTag_sup,
-
-  eHTMLTag_table,     eHTMLTag_textarea,    eHTMLTag_tt,
-  eHTMLTag_u,         eHTMLTag_ul,          eHTMLTag_userdefined,
-  eHTMLTag_var,       eHTMLTag_wbr,         eHTMLTag_xmp,
-  
-    //a few special cases...
-  eHTMLTag_newline,
-  eHTMLTag_whitespace,
+static eHTMLTags gNonPropagatedTags[]={
+  eHTMLTag_head,  eHTMLTag_html,  eHTMLTag_body};
 
 
-};  
-
-static eHTMLTags gInlineParentTags []={ 
-  eHTMLTag_a,         eHTMLTag_abbr,        eHTMLTag_address,
-  eHTMLTag_b,         eHTMLTag_bdo,         eHTMLTag_big,
-  eHTMLTag_blink,     eHTMLTag_button,      eHTMLTag_caption,
-  eHTMLTag_cite,      eHTMLTag_code,        eHTMLTag_dfn,
-  eHTMLTag_dt,        eHTMLTag_em,          eHTMLTag_font,
-  eHTMLTag_h1,        eHTMLTag_h2,          eHTMLTag_h3,      
-  eHTMLTag_h4,        eHTMLTag_h5,          eHTMLTag_h6,      
-  eHTMLTag_i,         eHTMLTag_ilayer,      eHTMLTag_kbd,
-  eHTMLTag_label,     eHTMLTag_legend,      /*eHTMLTag_marquee,*/
-  eHTMLTag_nobr,      eHTMLTag_ol,          eHTMLTag_p,           
-  eHTMLTag_q,
-  eHTMLTag_s,         eHTMLTag_samp,        eHTMLTag_small,
-  eHTMLTag_span,      eHTMLTag_strike,      eHTMLTag_strong,
-  eHTMLTag_sub,       eHTMLTag_sup,         
-  eHTMLTag_td,        eHTMLTag_th,          eHTMLTag_tt,
-  eHTMLTag_u,         eHTMLTag_ul,          eHTMLTag_var
-};
-
-static eHTMLTags gInlineChildTags []={ 
-  eHTMLTag_a,       eHTMLTag_abbr,        eHTMLTag_acronym,   eHTMLTag_applet,
-  eHTMLTag_b,       eHTMLTag_bdo,         eHTMLTag_bgsound,   eHTMLTag_big,       eHTMLTag_blink,
-  eHTMLTag_br,      eHTMLTag_button,
-
-  eHTMLTag_cite,    eHTMLTag_code,
-  eHTMLTag_dfn,
-  eHTMLTag_em,      eHTMLTag_embed,
-  eHTMLTag_font,
-
-  eHTMLTag_form, //Added this for backward compatibility...
-
-  eHTMLTag_i,       eHTMLTag_iframe,      eHTMLTag_ilayer,    eHTMLTag_img,       eHTMLTag_input,
-  eHTMLTag_kbd,     
-  eHTMLTag_label,   
-  
-  eHTMLTag_layer, //Added this for backward compatibility...
-
-  
-  eHTMLTag_li,
-  eHTMLTag_map,
-  eHTMLTag_nobr,
-  eHTMLTag_object,
-  eHTMLTag_p,
-  eHTMLTag_pre,
-  eHTMLTag_q,
-  eHTMLTag_s,       eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    eHTMLTag_small,
-  eHTMLTag_sound,   eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,
-  eHTMLTag_sub,     eHTMLTag_sup,
-
-  eHTMLTag_table, //Added this for backward compatibility...
-
-  eHTMLTag_textarea,eHTMLTag_tt,
-  eHTMLTag_u,       eHTMLTag_userdefined,
-  eHTMLTag_var,
-  eHTMLTag_wbr,
-  eHTMLTag_text,
-  eHTMLTag_newline,
-  eHTMLTag_whitespace,
-};
-
-//This is a convenience set, which combines block AND inline child lists...
-static eHTMLTags gBlockAndInlineChildTags []={ 
-  eHTMLTag_a,         eHTMLTag_abbr,        eHTMLTag_acronym,   eHTMLTag_address,     eHTMLTag_applet,
-  eHTMLTag_b,         eHTMLTag_basefont,    eHTMLTag_bdo,       eHTMLTag_bgsound,     eHTMLTag_big,
-  eHTMLTag_blink,     eHTMLTag_blockquote,  eHTMLTag_br,        eHTMLTag_button,
-  eHTMLTag_center,    eHTMLTag_cite,        eHTMLTag_code,      
-  eHTMLTag_dfn,       eHTMLTag_del,         eHTMLTag_dir,         eHTMLTag_div,       eHTMLTag_dl,
-  eHTMLTag_em,        eHTMLTag_embed,
-  eHTMLTag_fieldset,  eHTMLTag_font,        eHTMLTag_form,
-  eHTMLTag_h1,        eHTMLTag_h2,          eHTMLTag_h3,
-  eHTMLTag_h4,        eHTMLTag_h5,          eHTMLTag_h6,
-  eHTMLTag_hr,      
-
-  eHTMLTag_i,         eHTMLTag_iframe,      eHTMLTag_ilayer,    eHTMLTag_img,         
-  eHTMLTag_ins,       eHTMLTag_isindex,   eHTMLTag_input,
-
-  eHTMLTag_kbd,     
-
-  eHTMLTag_label,     eHTMLTag_layer,       eHTMLTag_li,        eHTMLTag_listing,
-
-  eHTMLTag_map,       /*eHTMLTag_marque,*/  eHTMLTag_menu,      eHTMLTag_multicol,
-  eHTMLTag_nobr,      eHTMLTag_noembed,     eHTMLTag_noframes,  eHTMLTag_nolayer,   eHTMLTag_noscript,
-
-  eHTMLTag_object,    eHTMLTag_ol,
-  eHTMLTag_p,         eHTMLTag_plaintext,   eHTMLTag_pre,         
-  eHTMLTag_q,
-  eHTMLTag_s,         eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    eHTMLTag_small,
-  eHTMLTag_sound,     eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,
-  eHTMLTag_sub,       eHTMLTag_sup,
-
-  eHTMLTag_table,     eHTMLTag_textarea,    
-  eHTMLTag_tt,        eHTMLTag_u,           eHTMLTag_ul,        eHTMLTag_userdefined,
-  eHTMLTag_var,       eHTMLTag_wbr,         eHTMLTag_xmp,
-  
-    //a few special cases...
-  eHTMLTag_text,
-  eHTMLTag_newline,
-  eHTMLTag_whitespace,
-};  
-
-
-static eHTMLTags gPREChildTags []={ 
-  eHTMLTag_a,       eHTMLTag_abbr,        eHTMLTag_acronym,   
-  eHTMLTag_b,       eHTMLTag_bdo,         eHTMLTag_bgsound,   
-  eHTMLTag_br,      eHTMLTag_button,
-  eHTMLTag_cite,    eHTMLTag_code,        eHTMLTag_dfn,
-  eHTMLTag_em,      eHTMLTag_embed,
-  eHTMLTag_i,       eHTMLTag_ilayer,      eHTMLTag_input,
-  eHTMLTag_kbd,     eHTMLTag_label,       eHTMLTag_li,
-  eHTMLTag_map,     eHTMLTag_q,
-  eHTMLTag_s,       eHTMLTag_samp,        eHTMLTag_script,    eHTMLTag_select,    
-  eHTMLTag_sound,   eHTMLTag_spacer,      eHTMLTag_span,      eHTMLTag_strike,    eHTMLTag_strong,  
-  eHTMLTag_textarea,eHTMLTag_tt,
-  eHTMLTag_u,       eHTMLTag_var,         eHTMLTag_wbr,
-  eHTMLTag_text,    eHTMLTag_newline,     eHTMLTag_whitespace,
-};
-
-
-static eHTMLTags gHeadChildTags []={ 
-  eHTMLTag_base,    eHTMLTag_bgsound,     eHTMLTag_isindex,
-  eHTMLTag_link,    eHTMLTag_meta,        /*eHTMLTag_nextid,*/
-  eHTMLTag_script,  eHTMLTag_sound,       eHTMLTag_style,
-  eHTMLTag_title
-};
-
-static eHTMLTags gFormChildTags []={ 
-  eHTMLTag_button,  eHTMLTag_input,   eHTMLTag_keygen,
-  eHTMLTag_label,   eHTMLTag_select,  eHTMLTag_textarea     
-};
-
-static CTokenRecycler gTokenRecycler;
+#include "nsElementTable.h"
 
 
 /***************************************************************
@@ -440,7 +255,7 @@ PRInt32 NavDispatchTokenHandler(CToken* aToken,nsIDTD* aDTD) {
   if(aDTD) {
     switch(theType) {
       case eToken_start:
-      case eToken_whitespace:
+      case eToken_whitespace: 
       case eToken_newline:
       case eToken_text:
         result=theDTD->HandleStartToken(aToken); break;
@@ -491,21 +306,19 @@ void CNavDTD::InitializeDefaultTokenHandlers() {
 }
 
 
-static CTokenDeallocator gTokenKiller;
-
 /**
  *  Default constructor
- *  
+ *   
  *  @update  gess 4/9/98
  *  @param   
  *  @return  
  */
-CNavDTD::CNavDTD() : nsIDTD(), mTokenDeque(gTokenKiller)  {
+CNavDTD::CNavDTD() : nsIDTD(){
   NS_INIT_REFCNT();
-  mSink = 0;
-  mParser=0;
-  mDTDDebug=0;
-  mLineNumber=1;
+  mSink = 0; 
+  mParser=0;       
+  mDTDDebug=0;   
+  mLineNumber=1;  
   mHasOpenBody=PR_FALSE;
   nsCRT::zero(mTokenHandlers,sizeof(mTokenHandlers));
   mHasOpenForm=PR_FALSE;
@@ -516,7 +329,20 @@ CNavDTD::CNavDTD() : nsIDTD(), mTokenDeque(gTokenKiller)  {
   mBodyContext=new nsDTDContext();
   mFormContext=0;
   mMapContext=0;
-//  DebugDumpContainmentRules(*this,"c:/temp/DTDRules1.out","New CNavDTD Containment Rules");
+  mTokenizer=0;
+
+//  DebugDumpContainmentRules2(*this,"c:/temp/DTDRules.new","New CNavDTD Containment Rules");
+}
+
+
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CNavDTD::GetMostDerivedIID(void)const {
+  return kClassIID;
 }
 
 /**
@@ -544,18 +370,6 @@ nsresult CNavDTD::CreateNewInstance(nsIDTD** aInstancePtrResult){
   return NS_NewNavHTMLDTD(aInstancePtrResult);
 }
 
-
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* CNavDTD::GetTokenRecycler(void){
-//  return 0;
-  return &gTokenRecycler;
-}
-
 /**
  * Called by the parser to initiate dtd verification of the
  * internal context stack.
@@ -575,7 +389,7 @@ PRBool CNavDTD::Verify(nsString& aURLRef,nsIParser* aParser){
     else mDTDDebug->SetVerificationDirectory(kVerificationDir);
   }
   if(mDTDDebug) {
-    mDTDDebug->Verify(this,aParser,mBodyContext->mElements.mCount,mBodyContext->mElements.mTags,aURLRef);
+    // mDTDDebug->Verify(this,aParser,mBodyContext->GetCount(),mBodyContext->mTags,aURLRef);
   }
   return result;
 }
@@ -632,6 +446,7 @@ nsresult CNavDTD::WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParse
     mSink=(nsIHTMLContentSink*)aParser->GetContentSink();
     if((aNotifySink) && (mSink)) {
       mHasOpenBody=PR_FALSE;
+      mHadBodyOrFrameset=PR_FALSE;
       mLineNumber=1;
       result = mSink->WillBuildModel();
     }
@@ -639,16 +454,49 @@ nsresult CNavDTD::WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParse
   return result;
 }
 
+/**
+  * This is called when it's time to read as many tokens from the tokenizer
+  * as you can. Not all tokens may make sense, so you may not be able to
+  * read them all (until more come in later).
+  *
+  * @update	gess5/18/98
+  * @param	aParser is the parser object that's driving this process
+  * @return	error code (almost always 0)
+  */
+nsresult CNavDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+
+  nsHTMLTokenizer*  theTokenizer=(nsHTMLTokenizer*)GetTokenizer();
+  nsITokenRecycler* theRecycler=GetTokenRecycler();
+  if(theTokenizer) {
+    while(NS_OK==result){
+      CToken* theToken=theTokenizer->PopToken();
+      if(theToken) {
+        result=HandleToken(theToken,aParser);
+        if(NS_SUCCEEDED(result)) {
+          theRecycler->RecycleToken(theToken);
+        }
+        else if(NS_ERROR_HTMLPARSER_BLOCK!=result){
+          theTokenizer->PushTokenFront(theToken);
+        }
+        // theRootDTD->Verify(kEmptyString,aParser);
+      }
+      else break;
+    }
+  }
+  return result;
+}
+
 /**
  * 
  * @update  gess5/18/98
  * @param 
  * @return
  */
-nsresult CNavDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+nsresult CNavDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result= NS_OK;
 
-  if((kNoError==anErrorCode) && (!mHasOpenBody)) {
+  if((NS_OK==anErrorCode) && (!mHadBodyOrFrameset)) {
     CStartToken theToken(eHTMLTag_body);  //open the body container...
     result=HandleStartToken(&theToken);
   }
@@ -657,7 +505,7 @@ nsresult CNavDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser
     mSink=(nsIHTMLContentSink*)aParser->GetContentSink();
 
     if(aNotifySink && mSink){
-      if((kNoError==anErrorCode) && (mBodyContext->mElements.mCount>0)) {
+      if((NS_OK==anErrorCode) && (mBodyContext->GetCount()>0)) {
         result = CloseContainersTo(0,eHTMLTag_unknown,PR_FALSE);
       }
 
@@ -695,8 +543,9 @@ nsresult CNavDTD::HandleToken(CToken* aToken,nsIParser* aParser){
       mParser=(nsParser*)aParser;
       mSink=(nsIHTMLContentSink*)mParser->GetContentSink();
       result=(*theHandler)(theToken,this);
-      if (mDTDDebug)
-         mDTDDebug->Verify(this, mParser, mBodyContext->mElements.mCount, mBodyContext->mElements.mTags, mFilename);
+      if (mDTDDebug) {
+         //mDTDDebug->Verify(this, mParser, mBodyContext->GetCount(), mBodyContext->mTags, mFilename);
+      }
     }
 
   }//if
@@ -734,12 +583,18 @@ nsresult CNavDTD::ReleaseTokenPump(nsITagHandler* aHandler){
  * @param   aChildTag is the tag itself.
  * @return  status
  */
-PRInt32 CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
-  PRInt32 result=kNoError;
-  CToken* theNextToken=mParser->PeekToken();
+nsresult CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
+  nsresult result=NS_OK;
 
+  CToken* theNextToken=mTokenizer->PeekToken();
   if(theNextToken){
     switch(aChildTag){
+      case eHTMLTag_body:
+      case eHTMLTag_frameset:
+        mHadBodyOrFrameset=PR_TRUE;
+        break;
+
+
       case eHTMLTag_pre:
       case eHTMLTag_listing:
         {
@@ -751,7 +606,7 @@ PRInt32 CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
                 case eHTMLTag_pre:
                 case eHTMLTag_listing:
                     //we skip the first newline token inside PRE and LISTING
-                  mParser->PopToken();
+                  mTokenizer->PopToken();
                   break;
                 default:
                   break;
@@ -775,23 +630,75 @@ PRInt32 CNavDTD::DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag){
         break;
       default:
         break;
-    }//switch
+    }//switch 
   }
   return result;
-}
-
-
-void CompareResults(PRBool canContain,eHTMLTags aParentTag,eHTMLTags aChildTag){
-/*
-  PRBool theNewResult=CanContainEx(aParentTag,aChildTag);
-  if(canContain!=theNewResult){
-    printf("%s(child:%i,parent:%i)\n","can contain!=can containex",aChildTag,aParentTag);
-  }
-*/
-}
-
-
+} 
+ 
 /**
+ *  Determine whether the given tag is open anywhere
+ *  in our context stack.
+ *  
+ *  @update  gess 4/2/98
+ *  @param   eHTMLTags tag to be searched for in stack
+ *  @return  topmost index of tag on stack
+ */
+PRInt32 GetTopmostIndexOf(eHTMLTags aTag,nsTagStack& aTagStack) {
+  int i=0;
+  for(i=aTagStack.mCount-1;i>=0;i--){
+    if(aTagStack.mTags[i]==aTag)
+      return i;
+  }
+  return kNotFound;
+}
+
+/** 
+ *  This method is called to determine whether or not a START tag
+ *  can be autoclosed. This means that based on the current
+ *  context, the stack should be closed to the nearest matching
+ *  tag.  
+ *   
+ *  @param   aTag -- tag enum of child to be tested
+ *  @return  PR_TRUE if autoclosure should occur
+ */  
+eHTMLTags FindAutoCloseTargetForStartTag(eHTMLTags aCurrentTag,nsTagStack& aTagStack) {
+  int theTopIndex=aTagStack.mCount;
+  eHTMLTags aPrevTag=aTagStack.mTags[theTopIndex-1];
+ 
+  if(nsHTMLElement::IsContainer(aCurrentTag)){
+    if((aPrevTag==aCurrentTag) && (!gHTMLElements[aCurrentTag].CanSelfContain())){
+      return aCurrentTag;
+    }
+    if(nsHTMLElement::IsBlockCloser(aCurrentTag)) {
+
+      CTagList* theRootTags=gHTMLElements[aCurrentTag].GetRootTags();
+      if(theRootTags) {
+        PRInt32 theRootIndex=theRootTags->GetTopmostIndexOf(aTagStack);
+        if(theRootIndex<GetTopmostIndexOf(aCurrentTag,aTagStack)) {
+          return aCurrentTag;
+        }
+      }
+ 
+      CTagList* theCloseTags=gHTMLElements[aCurrentTag].GetAutoCloseStartTags();
+      if(theCloseTags){
+        PRInt32 thePeerIndex=theCloseTags->GetTopmostIndexOf(aTagStack);
+        if(kNotFound!=thePeerIndex){
+          if(thePeerIndex==theTopIndex-1) {
+            //the guy you can autoclose is on the top of the stack...
+            return aPrevTag;
+          } //if
+        } //if
+      }//if
+
+    } //if
+    else if(nsHTMLElement::IsInlineElement(aCurrentTag)) {
+    }//if 
+  } //if
+  return eHTMLTag_unknown;
+}
+
+    
+/** 
  *  This method gets called when a start token has been 
  *  encountered in the parse process. If the current container
  *  can contain this tag, then add it. Otherwise, you have
@@ -799,7 +706,7 @@ void CompareResults(PRBool canContain,eHTMLTags aParentTag,eHTMLTags aChildTag){
  *                  to be stored in
  *               2) close the top container, and add this to
  *                  whatever container ends up on top.
- *  
+ *   
  *  @update  gess 3/25/98
  *  @param   aToken -- next (start) token to be handled
  *  @param   aNode -- CParserNode representing this start token
@@ -809,27 +716,40 @@ nsresult CNavDTD::HandleDefaultStartToken(CToken* aToken,eHTMLTags aChildTag,nsI
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   nsresult  result=NS_OK;
-  eHTMLTags theParentTag=mBodyContext->mElements.Last();
 
-  if(RequiresAutomaticClosure(theParentTag,aChildTag)){
-    result=CloseContainersTo(aChildTag,PR_TRUE);
+    //Sick as it sounds, I have to make sure the body has been
+    //opened before other tags can be added to the content sink...
+
+  static eHTMLTags gBodyBlockers[]={eHTMLTag_body,eHTMLTag_frameset,eHTMLTag_head};
+  PRInt32 theBodyBlocker=GetTopmostIndexOf(gBodyBlockers,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown));
+  if(!theBodyBlocker) {
+    if(CanPropagate(eHTMLTag_body,aChildTag)) {
+      mHasOpenBody=PR_TRUE;
+      CStartToken theToken(eHTMLTag_body);  //open the body container...
+      result=HandleStartToken(&theToken);
+    }
+  }//if                     
+
+  eHTMLTags theParentTag=mBodyContext->Last();
+  PRBool theCanContainResult=CanContain(theParentTag,aChildTag);
+
+  eHTMLTags theTarget=FindAutoCloseTargetForStartTag(aChildTag,mBodyContext->mTags);
+  if(eHTMLTag_unknown!=theTarget){
+    result=CloseContainersTo(theTarget,PR_TRUE);
   }
 
-  PRBool theCanContainResult=CanContain(theParentTag,aChildTag);
-  CompareResults(theCanContainResult,theParentTag,aChildTag);
 
   if(PR_FALSE==theCanContainResult){
     if(CanPropagate(theParentTag,aChildTag))
       result=CreateContextStackFor(aChildTag);
     else result=kCantPropagate;
-    if(NS_OK!=result) {
+    if(NS_OK!=result) { 
       //if you're here, then the new topmost container can't contain aToken.
       //You must determine what container hierarchy you need to hold aToken,
       //and create that on the parsestack.
       result=ReduceContextStackFor(aChildTag);
 
-      PRBool theCanContainResult=CanContain(mBodyContext->mElements.Last(),aChildTag);
-      CompareResults(theCanContainResult,mBodyContext->mElements.Last(),aChildTag);
+      PRBool theCanContainResult=CanContain(mBodyContext->Last(),aChildTag);
 
       if(PR_FALSE==theCanContainResult) {
         //we unwound too far; now we have to recreate a valid context stack.
@@ -839,15 +759,17 @@ nsresult CNavDTD::HandleDefaultStartToken(CToken* aToken,eHTMLTags aChildTag,nsI
   }
 
   if(IsContainer(aChildTag)){
-    if(PR_TRUE==mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]) {
-      CloseTransientStyles(aChildTag);
+      //first, let's see if it's a style element...
+    if(!FindTagInSet(aChildTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
+        //it wasn't a style container, so open the element container...
+      if(mBodyContext->mOpenStyles) {
+        CloseTransientStyles(aChildTag);
+      }
     }
     result=OpenContainer(aNode,PR_TRUE);
   }
-  else {
-    if(PR_FALSE==mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]) {
-      OpenTransientStyles(aChildTag);
-    }
+  else {  //we're writing a leaf...
+    OpenTransientStyles(aChildTag);
     result=AddLeaf(aNode);
   }
 
@@ -870,80 +792,81 @@ nsresult CNavDTD::HandleDefaultStartToken(CToken* aToken,eHTMLTags aChildTag,nsI
  *  @param   aToken -- next (start) token to be handled
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
- */
+ */      
 nsresult CNavDTD::HandleStartToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   //Begin by gathering up attributes...
-  nsCParserNode attrNode((CHTMLToken*)aToken,mLineNumber); 
+  eHTMLTags     theChildTag=(eHTMLTags)aToken->GetTypeID();
+  nsCParserNode attrNode((CHTMLToken*)aToken,mLineNumber,GetTokenRecycler()); 
   PRInt16       attrCount=aToken->GetAttributeCount();
   nsresult      result=(0==attrCount) ? NS_OK : CollectAttributes(attrNode,attrCount);
-  eHTMLTags     theParent=mBodyContext->mElements.Last();
-  eHTMLTags     theChildTag=(eHTMLTags)aToken->GetTypeID();
+  eHTMLTags     theParent=mBodyContext->Last();
   PRInt32       theAttrCount;
-
+ 
   if(NS_OK==result) {
-      //now check to see if this token should be omitted...
+    switch(theChildTag) { 
 
-    if(PR_FALSE==CanOmit(theParent,theChildTag)) {
-  
-      switch(theChildTag) {
-
-        case eHTMLTag_title:
-          {
-            result=OpenHead(attrNode); //open the head...
-            if(NS_OK==result) {
-
-              result=CollectSkippedContent(attrNode,theAttrCount);
-              mSink->SetTitle(attrNode.GetSkippedContent());
-              result=CloseHead(attrNode); //close the head...
-            }
-          }
-          break;
-
-        case eHTMLTag_link:
-        case eHTMLTag_base:
-        case eHTMLTag_meta:
-          result=AddHeadLeaf(attrNode);
-          break;
-
-        case eHTMLTag_style:
-          {
+      case eHTMLTag_title:
+        {
+          PRBool headOpen=mHasOpenHead;
+          if(!headOpen)
             result=OpenHead(attrNode);
+          if(NS_OK==result) {
+            result=CollectSkippedContent(attrNode,theAttrCount);
+            mSink->SetTitle(attrNode.GetSkippedContent());
+            if((NS_OK==result) && (!headOpen))
+              result=CloseHead(attrNode);
+          }
+        }
+        break;
+
+      case eHTMLTag_base:
+      case eHTMLTag_link:
+      case eHTMLTag_meta:
+        result=AddHeadLeaf(attrNode);
+        break;
+
+      case eHTMLTag_style:
+        {
+          PRBool headOpen=mHasOpenHead;
+          if(!headOpen)
+            result=OpenHead(attrNode);
+          if(NS_OK==result) {
+            PRInt32 theCount;
+            CollectSkippedContent(attrNode,theCount);
             if(NS_OK==result) {
-              PRInt32 theCount;
-              CollectSkippedContent(attrNode,theCount);
-              if(NS_OK==result) {
-                result=AddLeaf(attrNode);
-                // XXX If the return value tells us to block, go
-                // ahead and close the tag out anyway, since its
-                // contents will be consumed.
-                if (NS_SUCCEEDED(result)) {
-                  nsresult rv = CloseHead(attrNode);
-                  // XXX Only send along a failure. If the close 
-                  // succeeded we still may need to indicate that the
-                  // parser has blocked (i.e. return the result of
-                  // the AddLeaf.
-                  if (rv != NS_OK) {
-                    result = rv;
-                  }
+              result=AddLeaf(attrNode);
+              // XXX If the return value tells us to block, go
+              // ahead and close the tag out anyway, since its
+              // contents will be consumed.
+              if (NS_SUCCEEDED(result)) {
+                nsresult rv = CloseHead(attrNode);
+                // XXX Only send along a failure. If the close 
+                // succeeded we still may need to indicate that the
+                // parser has blocked (i.e. return the result of
+                // the AddLeaf.
+                if (rv != NS_OK) {
+                  result = rv;
                 }
               }
             }
-          }
-          break;
+          } 
+        }
+        break;
 
-        case eHTMLTag_area:
-          if (mHasOpenMap) {
-            result = mSink->AddLeaf(attrNode);
-          }
-          break;
+      case eHTMLTag_area:
+        if (mHasOpenMap) {
+          result = mSink->AddLeaf(attrNode);
+        }
+        break;
 
-        default:
+      default:
+        if(PR_FALSE==CanOmit(theParent,theChildTag)) {
           result=HandleDefaultStartToken(aToken,theChildTag,attrNode);
-          break;
-      } //switch
-    } //if
+        }
+        break;
+    } //switch
   } //if
 
   if(eHTMLTag_newline==theChildTag)
@@ -953,8 +876,6 @@ nsresult CNavDTD::HandleStartToken(CToken* aToken) {
 }
 
 
-
-
 /**
  *  This method gets called when an end token has been 
  *  encountered in the parse process. If the end tag matches
@@ -974,9 +895,9 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
   nsresult    result=NS_OK;
   CEndToken*  et = (CEndToken*)(aToken);
   eHTMLTags   tokenTagType=(eHTMLTags)et->GetTypeID();
+  
 
-
-  // Here's the hacky part:
+  // Here's the hacky part: 
   // Because we're trying to be backward compatible with Nav4/5, 
   // we have to handle explicit styles the way it does. That means
   // that we keep an internal style stack.When an EndToken occurs, 
@@ -986,7 +907,7 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
 
   //now check to see if this token should be omitted, or 
   //if it's gated from closing by the presence of another tag.
-  if(PR_TRUE==CanOmitEndTag(mBodyContext->mElements.Last(),tokenTagType)) {
+  if(PR_TRUE==CanOmitEndTag(mBodyContext->Last(),tokenTagType)) {
     UpdateStyleStackForCloseTag(tokenTagType,tokenTagType);
     return result;
   }
@@ -999,16 +920,12 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
     case eHTMLTag_meta:
     case eHTMLTag_textarea:
     case eHTMLTag_title:
-    case eHTMLTag_head:
     case eHTMLTag_script:
       break;
 
     case eHTMLTag_map:
     case eHTMLTag_form:
-      {
-        nsCParserNode aNode((CHTMLToken*)aToken,mLineNumber);
-        result=CloseContainer(aNode,tokenTagType,PR_FALSE);
-      }
+      result=CloseContainer(theNode,tokenTagType,PR_FALSE);
       break;
 
     case eHTMLTag_td:
@@ -1017,7 +934,7 @@ nsresult CNavDTD::HandleEndToken(CToken* aToken) {
       // Empty the transient style stack (we just closed any extra
       // ones off so it's safe to do it now) because they don't carry
       // forward across table cell boundaries.
-      mBodyContext->mStyles->mCount=0;
+      //mBodyContext->mStyles->mCount=0;
       break;
 
     default:
@@ -1044,7 +961,7 @@ nsresult CNavDTD::HandleEntityToken(CToken* aToken) {
   CEntityToken* et = (CEntityToken*)(aToken);
   nsresult      result=NS_OK;
 
-  if(PR_FALSE==CanOmit(mBodyContext->mElements.Last(),eHTMLTag_entity)) {
+  if(PR_FALSE==CanOmit(mBodyContext->Last(),eHTMLTag_entity)) {
     nsCParserNode aNode((CHTMLToken*)aToken,mLineNumber);
     result=AddLeaf(aNode);
   }
@@ -1106,7 +1023,7 @@ nsresult CNavDTD::HandleAttributeToken(CToken* aToken) {
 
   return NS_OK;
 }
-
+ 
 /**
  *  This method gets called when a script token has been 
  *  encountered in the parse process. 
@@ -1176,20 +1093,22 @@ nsresult CNavDTD::HandleProcessingInstructionToken(CToken* aToken){
  * @param   aCount is the # of attributes you're expecting
  * @return error code (should be 0)
  */
-PRInt32 CNavDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
+nsresult CNavDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
   int attr=0;
-  for(attr=0;attr<aCount;attr++){
-    CToken* theToken=mParser->PeekToken();
-    if(theToken)  {
-      eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
-      if(eToken_attribute==theType){
-        mParser->PopToken(); //pop it for real...
+
+  nsresult result=NS_OK;
+  if(aCount<=mTokenizer->GetCount()) {
+    for(attr=0;attr<aCount;attr++){
+      CToken* theToken=mTokenizer->PopToken();
+      if(theToken)  {
         aNode.AddAttribute(theToken);
-      } 
+      }
     }
-    else return kInterrupted;
   }
-  return kNoError;
+  else {
+    result=kEOF;
+  }
+  return result;
 }
 
 
@@ -1201,22 +1120,22 @@ PRInt32 CNavDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
  * @param   holds the number of skipped content elements encountered
  * @return  Error condition.
  */
-PRInt32 CNavDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
-  PRInt32         result=kNoError;
-  eHTMLTokenTypes theType;
-  CToken*         theToken;
+nsresult CNavDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
+  nsresult result=NS_OK;
+  eHTMLTokenTypes theType=eToken_unknown;
   aCount=0;
-  do{
-    theToken=mParser->PeekToken();
-    if(theToken) {
-      theType=eHTMLTokenTypes(theToken->GetTokenType());
-      if(eToken_skippedcontent==theType) {
-        mParser->PopToken();
-        aNode.SetSkippedContent(theToken);
-        aCount++;
-      } 
-    }
-  } while(theToken && (eToken_skippedcontent==theType));
+
+  CToken* theToken=mTokenizer->PopToken();
+  if(theToken) {
+    theType=eHTMLTokenTypes(theToken->GetTokenType());
+    if(eToken_skippedcontent==theType) {
+      aNode.SetSkippedContent(theToken);
+      aCount++;
+    } 
+  }
+  else {
+    result=kEOF;
+  }
   return result;
 }
 
@@ -1294,14 +1213,14 @@ PRBool CNavDTD::CanContainStyles(eHTMLTags aParent) const {
       result=PR_FALSE; break;
     default:
       break;
-  }
-  return result;
-}
-
+  }   
+  return result; 
+}      
+       
  /***********************************************************************************
    The preceeding tables determine the set of elements each tag can contain...
   ***********************************************************************************/
-
+  
 /**
  *  This method is called to determine whether or not a tag
  *  of one type can contain a tag of another type.
@@ -1312,426 +1231,13 @@ PRBool CNavDTD::CanContainStyles(eHTMLTags aParent) const {
  *  @return  PR_TRUE if parent can contain child
  */
 PRBool CNavDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const {
-
-  PRBool result=PR_FALSE;
-  if((!IsContainer(aParent)) && (eHTMLTag_unknown!=aParent))
-    return result;
-
- 
-    /***************************************************************************
-     * Handle form elements here. Why? Because as long as a form is open, 
-     * almost any form element is allowed. (Except <option> which must have a 
-     * <select> or <optgroup> as a parent. and <optgroup> which must have a
-     * <select> as a parent) Handling forms here means I don't have to do 
-     * special case form handling in every case statement below.
-     *
-     * Note: ANYONE can contain a form element so long as a form is open.
-     ***************************************************************************/
-  if(FindTagInSet(aChild,gFormElementTags,sizeof(gFormElementTags)/sizeof(eHTMLTag_unknown))) {
-    if(HasOpenContainer(eHTMLTag_form)) {
-      switch((eHTMLTags)aParent) {
-        case eHTMLTag_select:
-          result=PRBool(eHTMLTag_option==aChild || eHTMLTag_optgroup==aChild);
-          break;
-	case eHTMLTag_optgroup:
-	  result=PRBool(eHTMLTag_option==aChild);
-	  break;
-        case eHTMLTag_option:
-          result=PR_FALSE;
-          break;
-        default:
-          result=PR_TRUE;
-          break;
-      } //switch
+  if(mHasOpenForm) {
+    if(FindTagInSet(aChild,gFormElementTags,sizeof(gFormElementTags)/sizeof(eHTMLTag_unknown))) {
+      return PR_TRUE;
     }//if
-    return result;
-  }
-
-  if((aParent) && (FindTagInSet(aParent,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown)))) {
-    if(eHTMLTag_li == aChild) {
-      //This code was added to enforce the rule that listitems
-      //autoclose prior listitems.  Stylistic tags (including <A>)
-      //that get in the way are simply out of luck.
-      result=PR_FALSE;
-    }
-    else
-      result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-  }
-  else {
-    switch((eHTMLTags)aParent) {
-
-      case eHTMLTag_abbr:
-        if(aParent!=aChild)
-          result=FindTagInSet(aChild,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_blockquote:
-      case eHTMLTag_body:
-      case eHTMLTag_ilayer:
-      case eHTMLTag_layer:
-        if(eHTMLTag_userdefined==aChild)
-          result=PR_TRUE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-      break;
-
-      case eHTMLTag_button:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_caption,eHTMLTag_legend};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-          if(PR_FALSE==result)
-            result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_caption:    case eHTMLTag_center:
-      case eHTMLTag_dir:
-      case eHTMLTag_div:        case eHTMLTag_form:
-      case eHTMLTag_label:      case eHTMLTag_legend:
-      case eHTMLTag_menu:       case eHTMLTag_noscript:
-      case eHTMLTag_ol:         case eHTMLTag_ul:
-      case eHTMLTag_embed:      case eHTMLTag_noembed:
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_dd:
-        result=(eHTMLTag_dt==aChild) ? PR_FALSE: FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_colgroup:
-        result=PRBool(eHTMLTag_col==(eHTMLTags)aChild);
-        break;
-
-      case eHTMLTag_dt:
-        {
-          if(eHTMLTag_dt==aChild)
-            result=PR_TRUE;
-          else result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_dl:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_dd,eHTMLTag_dt,eHTMLTag_whitespace,
-                                     eHTMLTag_map,eHTMLTag_form,eHTMLTag_newline,eHTMLTag_p};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_fieldset:
-        if(eHTMLTag_legend==aChild)
-          result=PR_TRUE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_frameset:
-        {
-          static eHTMLTags okTags[]={ eHTMLTag_frame,     eHTMLTag_frameset,  eHTMLTag_noframes,  
-                                      eHTMLTag_newline,   eHTMLTag_whitespace};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_h1: case eHTMLTag_h2:
-      case eHTMLTag_h3: case eHTMLTag_h4:
-      case eHTMLTag_h5: case eHTMLTag_h6:
-        {
-          if(FindTagInSet(aChild,gHeadingTags,sizeof(gHeadingTags)/sizeof(eHTMLTag_unknown)))
-            result=PR_FALSE;
-          else result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_head:
-        {
-          static eHTMLTags okTags[]={
-            eHTMLTag_base,    eHTMLTag_isindex, eHTMLTag_link,  eHTMLTag_meta,
-            eHTMLTag_script,  eHTMLTag_style,   eHTMLTag_title};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_html:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_body,eHTMLTag_frameset,eHTMLTag_head,eHTMLTag_script,eHTMLTag_noscript};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_iframe:/* XXX wrong */
-        if(eHTMLTag_frame==aChild)
-          result=PR_FALSE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_li:
-        if (eHTMLTag_li == aChild) {
-          result = PR_FALSE;
-        }
-        else result=!FindTagInSet(aChild,gHeadingTags,sizeof(gHeadingTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_map:
-        {
-          static eHTMLTags okTags[] = { eHTMLTag_area,eHTMLTag_newline,eHTMLTag_whitespace};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_multicol:
-        if(aParent!=aChild) {
-          result=FindTagInSet(aChild,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_unknown));
-          if(PR_FALSE==result)
-            result=FindTagInSet(aChild,gBlockChildTags,sizeof(gBlockChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_nolayer:
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_noframes:
-        if(eHTMLTag_body==aChild)
-          result=PR_TRUE;
-        else
-          result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_option:
-        //for now, allow an option to contain anything but another option/group
-        result=PRBool((eHTMLTag_option!=aChild) && (eHTMLTag_optgroup!=aChild));
-        break;
-
-      case eHTMLTag_optgroup:
-        //for now, allow an optgroup to hold any child tag
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_applet:
-      case eHTMLTag_object:
-        if(eHTMLTag_param==aChild) {
-          result=PR_TRUE;
-          break;
-        }
-        result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_address:
-        if(eHTMLTag_p==aChild) {
-          result=PR_TRUE;
-          break;
-        }
-        //else fall through...
-
-      case eHTMLTag_p:
-      case eHTMLTag_pre:
-        result=FindTagInSet(aChild,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_unknown));
-        break;
-
-      case eHTMLTag_script:
-        //for now, allow an optgroup to hold itself and options...
-        result=PRBool((eHTMLTag_text==aChild) || (eHTMLTag_comment==aChild));
-        break;
-
-      case eHTMLTag_table:
-        {
-          static eHTMLTags okTags[]={ 
-            eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  
-            eHTMLTag_form,    eHTMLTag_script,
-            eHTMLTag_tbody,   eHTMLTag_tfoot,  /* eHTMLTag_tr,*/  
-            eHTMLTag_thead,   eHTMLTag_map};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_tbody:
-      case eHTMLTag_tfoot:
-      case eHTMLTag_thead:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_script,eHTMLTag_tr,eHTMLTag_map,eHTMLTag_form};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_title:
-      case eHTMLTag_textarea:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_text,eHTMLTag_whitespace,eHTMLTag_newline};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_th:
-      case eHTMLTag_td:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_newline,eHTMLTag_map};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-          if(PR_FALSE==result)
-            result=FindTagInSet(aChild,gBlockAndInlineChildTags,sizeof(gBlockAndInlineChildTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_tr:
-        {
-          static eHTMLTags okTags[]={eHTMLTag_script,eHTMLTag_td,eHTMLTag_th,eHTMLTag_form,eHTMLTag_map};
-          result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-        }
-        break;
-
-      case eHTMLTag_unknown:
-        //the only thing that should ever have an unknown
-        //parent is an HTML Tag. Everything else should propagate.
-        if((eHTMLTag_userdefined==aChild) && mAllowUnknownTags)
-          result=PR_TRUE;
-        else result=PRBool(eHTMLTag_html==aChild);
-        break;
-
-      case eHTMLTag_listing:
-      case eHTMLTag_select:
-      case eHTMLTag_userdefined:
-        result=PR_TRUE; //XXX for now...
-        break;
-
-      default:
-  #ifdef NS_DEBUG
-        printf("XXX: unhandled tag %s in CanContain switch statement\n",
-               NS_EnumToTag((nsHTMLTag)aParent));
-  #endif
-        break;
-    } //switch
-  } //if
-
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 10/28/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool SpecialContainerRuleApplies(PRInt32 aParentTag,PRInt32 aChildTag) {
-  PRBool result=PR_FALSE;
-  
-  switch(aChildTag){
-    case eHTMLTag_area:
-      result=PRBool(eHTMLTag_map==aParentTag);  break;
-    case eHTMLTag_body:
-      result=PRBool(eHTMLTag_html==aParentTag); break;
-    case eHTMLTag_col:
-      result=PRBool(eHTMLTag_colgroup==aParentTag); break;
-    case eHTMLTag_del:
-    case eHTMLTag_ins:
-      result=PRBool(eHTMLTag_body==aParentTag); break;
-    case eHTMLTag_dt:
-    case eHTMLTag_dd:
-      result=PRBool(eHTMLTag_dl==aParentTag); break;
-    case eHTMLTag_frameset:
-      result=PRBool((eHTMLTag_html==aParentTag) || (eHTMLTag_frameset==aParentTag));  break;
-    case eHTMLTag_frame:
-    case eHTMLTag_noframes:
-      result=PRBool(eHTMLTag_frameset==aParentTag); break;
-    case eHTMLTag_head:
-      result=PRBool(eHTMLTag_html==aParentTag); break;
-    case eHTMLTag_legend:
-      result=PRBool(eHTMLTag_fieldset==aParentTag); break;
-    case eHTMLTag_option:
-    case eHTMLTag_optgroup:
-      result=PRBool((eHTMLTag_optgroup==aParentTag) || (eHTMLTag_select==aParentTag)); break;
-    case eHTMLTag_param:
-      result=PRBool((eHTMLTag_applet==aParentTag) || (eHTMLTag_object==aParentTag)); break;
-    case eHTMLTag_td:
-      result=PRBool(eHTMLTag_tr==aParentTag); break;
-    case eHTMLTag_text:
-      result=PRBool((eHTMLTag_option==aParentTag) || (eHTMLTag_body==aParentTag)); break;
-    case eHTMLTag_th:
-      result=PRBool(eHTMLTag_tr==aParentTag); break;
-    case eHTMLTag_tr:
-      result=PRBool((eHTMLTag_tbody==aParentTag) || 
-                    (eHTMLTag_thead==aParentTag) ||
-                    (eHTMLTag_tfoot==aParentTag)); break;
-
-    case eHTMLTag_caption:
-    case eHTMLTag_colgroup:
-    case eHTMLTag_tbody:
-    case eHTMLTag_tfoot:
-    case eHTMLTag_thead:
-      result=PRBool(eHTMLTag_table==aParentTag); break;
-    
-    default:
-      break;
-  }
-
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 10/28/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool CNavDTD::CanContainEx(PRInt32 aParentTag,PRInt32 aChildTag) const {
-
-  //first, handle the case where we have an unknown parent...
-  if(eHTMLTag_unknown==aParentTag){
-    if(eHTMLTag_html==aChildTag)
-      return PR_TRUE;
-  }
-  //next, let's see if the child can be contained by a block-level tag...
-  if(FindTagInSet(aChildTag,gBlockChildTags,sizeof(gBlockChildTags)/sizeof(eHTMLTag_body)))  {
-    if(FindTagInSet(aParentTag,gBlockParentTags,sizeof(gBlockParentTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;
-  }
-  if(FindTagInSet(aChildTag,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_body)))  {
-    if(FindTagInSet(aParentTag,gInlineParentTags,sizeof(gInlineParentTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;
-  }
-  if(FindTagInSet(aChildTag,gHeadChildTags,sizeof(gHeadChildTags)/sizeof(eHTMLTag_unknown))){
-    if(eHTMLTag_head==aParentTag)
-      return PR_TRUE;
-  }
-  if(FindTagInSet(aChildTag,gFormChildTags,sizeof(gFormChildTags)/gFormChildTags[0]))  {
-    if(HasOpenContainer(eHTMLTag_form)) 
-      return PR_TRUE;
-  }
-    //this tag is so bizarre it requires its own special handling...
-  if(aParentTag==eHTMLTag_li){
-
-    if(FindTagInSet(aChildTag,gInlineChildTags,sizeof(gInlineChildTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;
-        
-    PRInt32 count=mBodyContext->mElements.mCount;
-    if(count>1){
-      eHTMLTags penultimate=mBodyContext->mElements.mTags[count-2];
-      if((eHTMLTag_ol==penultimate) || (eHTMLTag_ul==penultimate)){
-        //treat the li container as a block container...
-        if(FindTagInSet(aChildTag,gBlockChildTags,sizeof(gBlockChildTags)/sizeof(eHTMLTag_body)))
-          return PR_TRUE;
-      }
-    }
-  }
-
-  if(aParentTag==eHTMLTag_pre) {
-    //PRE is also very bizarre and deserves it own special handling...
-    if(FindTagInSet(aChildTag,gPREChildTags,sizeof(gPREChildTags)/sizeof(eHTMLTag_body)))
-      return PR_TRUE;    
-  }
-
-  if(SpecialContainerRuleApplies(aParentTag,aChildTag)){
-    return PR_TRUE;
-  }
-  return PR_FALSE;
-}
-
+  }//if
+  return gHTMLElements[aParent].CanContain((eHTMLTags)aChild);
+} 
 
 /**
  *  This method is called to determine whether or not 
@@ -1743,127 +1249,28 @@ PRBool CNavDTD::CanContainEx(PRInt32 aParentTag,PRInt32 aChildTag) const {
  *  @param   aChild -- tag enum of child container
  *  @return  PR_TRUE if propagation should occur
  */
-PRBool CNavDTD::CanPropagate(eHTMLTags aParent,eHTMLTags aChild) const {
-  PRBool result=PR_TRUE;
-
-  switch(aParent) {
-    case eHTMLTag_td:
-    case eHTMLTag_th:
-      
-      {
-        result=CanContain(aParent,aChild);
-        PRBool theCanContainExResult=CanContainEx(aParent,aChild);
-        CompareResults(result,aParent,aChild);
-      }
-      break;
-
-    case eHTMLTag_table:
-      if(aParent==aChild) {
-        break;
-      }
-      //else fall through...
-
-    default:
-      if(IsContainer(aChild) && HasOpenContainer(aChild))
-        result=IsGatedFromClosing(aChild);
-      break;
-  }//switch
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 4/8/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool CNavDTD::CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const {
+PRBool CNavDTD::CanPropagate(eHTMLTags aParentTag,eHTMLTags aChildTag) const {
   PRBool result=PR_FALSE;
 
-  switch(aParent) {
-
-    case eHTMLTag_html:
-      {
-        static eHTMLTags okTags[]={eHTMLTag_head,eHTMLTag_body };
-        result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-      }
-
-    case eHTMLTag_body:
-      result=PR_TRUE; break;
-
-    case eHTMLTag_table:
-      {
-        static eHTMLTags okTags[]={
-          eHTMLTag_caption, eHTMLTag_colgroup,
-          eHTMLTag_tbody,   eHTMLTag_tfoot,
-          eHTMLTag_thead,   eHTMLTag_tr,
-          eHTMLTag_td,      eHTMLTag_th,
-          eHTMLTag_col};
-        result=FindTagInSet(aChild,okTags,sizeof(okTags)/sizeof(eHTMLTag_unknown));
-      }
-      break;
-
-    default:
-      break;
-  }
-  return result;
-}
-
-/**
- *  This method is called to determine whether or not a tag
- *  can be autoclosed. This means that based on the current
- *  context, the stack should be closed to the nearest matching
- *  tag.
- *  
- *  @param   aTag -- tag enum of child to be tested
- *  @return  PR_TRUE if autoclosure should occur
- */
-PRBool CNavDTD::RequiresAutomaticClosure(eHTMLTags aParentTag,eHTMLTags aChildTag) const {
-  static eHTMLTags gAutoCloseTags[]={eHTMLTag_li,eHTMLTag_td,eHTMLTag_tr,eHTMLTag_dt};
-
-  PRBool    result=PR_FALSE;
-  PRInt32   theParentIndex=kNotFound;
-
-/*
-    //force autoclosure if you have p/pre stacks....
-  if((eHTMLTag_p==aChildTag) || (eHTMLTag_pre==aChildTag)){
-    if((eHTMLTag_p==aParentTag) || (eHTMLTag_pre==aParentTag)){
-      return PR_TRUE;
-    }
-  }
-*/
-    //this little bit of code forces DT and DD to autoclose each other.
-  if(eHTMLTag_dd==aChildTag) {
-    if(eHTMLTag_dt==aParentTag)
-      return PR_TRUE;
-  }
-  else if(eHTMLTag_dt==aChildTag) {
-    if(eHTMLTag_dd==aParentTag)
-      return PR_TRUE;
-  }
-
-  /***************************************************************************************
-    How this works:
-      1. Find the nearest parent on the appropriate stack that can gate the given child.
-      2. See if another child tag that matches this one is already open.
-      3. If there is and IT'S NOT GATED then autoclose it.
-   ***************************************************************************************/
-  if(eHTMLTag_unknown!=aParentTag){
-    if(PR_TRUE==FindTagInSet(aChildTag,gAutoCloseTags,sizeof(gAutoCloseTags)/sizeof(eHTMLTag_unknown))) {
-     
-      if(PR_TRUE==HasOpenContainer(aChildTag)) {
-        if(PR_FALSE==IsGatedFromClosing(aChildTag))
+  if(IsContainer(aChildTag)){
+    if(nsHTMLElement::IsBlockParent(aParentTag) || (gHTMLElements[aParentTag].GetSpecialChildren())) {
+      while(eHTMLTag_unknown!=aChildTag) {
+        if(CanContain(aParentTag,aChildTag)){
           result=PR_TRUE;
-      }
-    }
+          break;
+        }//if
+        CTagList* theTagList=gHTMLElements[aChildTag].GetRootTags();
+        aChildTag=theTagList->mTags[0];
+      }//while
+    }//if
+  }//if
+  else if(nsHTMLElement::IsTextTag(aChildTag)){
+
   }
   return result;
 }
 
-
+ 
 /**
  *  This method gets called to determine whether a given 
  *  tag can contain newlines. Most do not.
@@ -1878,14 +1285,26 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
   if((eHTMLTag_userdefined==aParent) && mAllowUnknownTags)
     return result;
 
+  if(eHTMLTag_head==aChild) {
+    if(HasOpenContainer(eHTMLTag_body))
+      return PR_TRUE;
+  }
+
+  static eHTMLTags canSkip[]={eHTMLTag_body,eHTMLTag_html,eHTMLTag_head};
+  if(FindTagInSet(aChild,canSkip,sizeof(canSkip)/sizeof(eHTMLTag_unknown))) {
+    if(HasOpenContainer(aChild))
+      return PR_TRUE;
+  }
+
   //begin with some simple (and obvious) cases...
   switch(aParent) {
     case eHTMLTag_table:
+    case eHTMLTag_tbody:
       if((eHTMLTag_form==aChild) || (eHTMLTag_table==aChild))
         result=PR_FALSE;
       else if(FindTagInSet(aChild,gFormElementTags,sizeof(gFormElementTags)/sizeof(eHTMLTag_unknown)))
         result=!HasOpenContainer(eHTMLTag_form);
-      else result=!FindTagInSet(aChild,gTableTags,sizeof(gTableTags)/sizeof(eHTMLTag_unknown));
+      else result=!FindTagInSet(aChild,gTableChildTags,sizeof(gTableChildTags)/sizeof(eHTMLTag_unknown));
       break;
 
     case eHTMLTag_tr:
@@ -1905,13 +1324,17 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
 
     case eHTMLTag_unknown:
       {
-        static eHTMLTags skippable[]={eHTMLTag_newline,eHTMLTag_whitespace};
-        if(FindTagInSet(aChild,skippable,sizeof(skippable)/sizeof(eHTMLTag_unknown))) {
+        static eHTMLTags canSkip2[]={eHTMLTag_newline,eHTMLTag_whitespace};
+        if(FindTagInSet(aChild,canSkip2,sizeof(canSkip2)/sizeof(eHTMLTag_unknown))) {
           result=PR_TRUE;
         }
       }
       break;
 
+    case eHTMLTag_head:
+      result=!gHeadKids.Contains(aChild);
+      break;
+
     default:
 
         //ok, since no parent claimed it, test based on the child...
@@ -1922,17 +1345,10 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
           result=PR_TRUE; 
           break;
 
-        case eHTMLTag_html:
         case eHTMLTag_body:
-          result=HasOpenContainer(aChild); //don't bother if they're already open...
+          result=HasOpenContainer(eHTMLTag_frameset);
           break;
 
-          //The following line was commented out to fix bug 1166. 
-          //Effectively, this allows a button to exist anywhere in the document,
-          //and not just inside a form.
-
-        //case eHTMLTag_button:       
-
         case eHTMLTag_fieldset:
         case eHTMLTag_input:        case eHTMLTag_isindex:
         case eHTMLTag_label:        case eHTMLTag_legend:
@@ -1952,7 +1368,7 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
             case eHTMLTag_tbody:    case eHTMLTag_col:    
             case eHTMLTag_colgroup: case eHTMLTag_unknown:
             case eHTMLTag_select:   case eHTMLTag_fieldset:
-            case eHTMLTag_frameset:
+            case eHTMLTag_frameset: case eHTMLTag_dl:
               result=PR_TRUE;
             default:
               break;
@@ -1987,7 +1403,7 @@ PRBool CNavDTD::CanOmit(eHTMLTags aParent,eHTMLTags aChild) const {
 
         default:
 
-          static eHTMLTags kNonStylizedTabletags[]={eHTMLTag_table,eHTMLTag_tr};
+          static eHTMLTags kNonStylizedTabletags[]={eHTMLTag_table,eHTMLTag_tbody,eHTMLTag_tr};
           if(FindTagInSet(aChild,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
             if(FindTagInSet(aParent,kNonStylizedTabletags,sizeof(kNonStylizedTabletags)/sizeof(eHTMLTag_unknown)))
               return PR_TRUE;
@@ -2019,6 +1435,46 @@ PRBool IsCompatibleTag(eHTMLTags aTag1,eHTMLTags aTag2) {
     result=FindTagInSet(aTag2,gHeadingTags,sizeof(gHeadingTags)/sizeof(eHTMLTag_unknown));
   }
   return result;
+} 
+  
+/**
+ *  This method is called to determine whether or not an END tag
+ *  can be autoclosed. This means that based on the current
+ *  context, the stack should be closed to the nearest matching
+ *  tag.
+ *   
+ *  @param   aTag -- tag enum of child to be tested
+ *  @return  PR_TRUE if autoclosure should occur
+ */ 
+eHTMLTags FindAutoCloseTargetForEndTag(eHTMLTags aCurrentTag,nsTagStack& aTagStack,PRInt32 aChildIndex) {
+  int theTopIndex=aTagStack.mCount;
+  eHTMLTags aPrevTag=aTagStack.mTags[theTopIndex-1];
+ 
+  if(nsHTMLElement::IsContainer(aCurrentTag)){
+    if(aPrevTag==aCurrentTag){
+      return aCurrentTag;
+    }
+    
+    if(nsHTMLElement::IsBlockCloser(aCurrentTag)) {
+      CTagList* theCloseTags=gHTMLElements[aCurrentTag].GetAutoCloseEndTags();
+      CTagList* theRootTags=gHTMLElements[aCurrentTag].GetRootTags();
+      if(theCloseTags){  
+        PRInt32 thePeerIndex=theCloseTags->GetTopmostIndexOf(aTagStack);
+        if(kNotFound!=thePeerIndex){
+          PRInt32   theRootIndex=theRootTags->GetTopmostIndexOf(aTagStack);
+          if(theRootIndex<thePeerIndex)
+            return aTagStack.mTags[thePeerIndex];
+        } //if
+      }//if
+      else if(theRootTags) {
+        //since we didn't find any close tags, see if there is an instance of aCurrentTag
+        //above the stack from the roottag.
+        PRInt32 theRootIndex=theRootTags->GetTopmostIndexOf(aTagStack);          
+        return (theRootIndex<aChildIndex) ? aCurrentTag : eHTMLTag_unknown;
+      }
+    } //if
+  } //if
+  return eHTMLTag_unknown;
 }
 
 /**
@@ -2077,14 +1533,14 @@ PRBool CNavDTD::CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild) const {
       //Otherwise, IT's OK TO FALL THROUGH HERE...
 
 
-    default:
-      if(IsGatedFromClosing(aChild))
-        result=PR_TRUE;
-      else if(IsCompatibleTag(aChild,mBodyContext->mElements.Last()))
-        result=PR_FALSE;
-      else result=(!HasOpenContainer(aChild));
+    default: 
+      {
+        PRInt32 theTagPos=GetTopmostIndexOf(aChild);
+        eHTMLTags theTarget=FindAutoCloseTargetForEndTag(aChild,mBodyContext->mTags,theTagPos);
+        result=PRBool(eHTMLTag_unknown==theTarget);
+      }
       break;
-  } //switch
+  } //switch 
   return result;
 }
 
@@ -2097,90 +1553,7 @@ PRBool CNavDTD::CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild) const {
  *  @return  PR_TRUE if given tag can contain other tags
  */
 PRBool CNavDTD::IsContainer(PRInt32 aTag) const {
-  PRBool result;
-  if((eHTMLTag_userdefined==aTag) && mAllowUnknownTags)
-    result=PR_TRUE;
-  else result=!FindTagInSet(aTag,gNonContainers,sizeof(gNonContainers)/sizeof(eHTMLTag_unknown));
-  return result;
-}
-
-
-/**
- * This method does two things: 1st, help construct
- * our own internal model of the content-stack; and
- * 2nd, pass this message on to the sink.
- * @update  gess4/6/98
- * @param   aNode -- next node to be added to model
- * @return  TRUE if ok, FALSE if error
- */
-eHTMLTags CNavDTD::GetDefaultParentTagFor(eHTMLTags aChildTag) const{
-  eHTMLTags result=eHTMLTag_unknown;
-  switch(aChildTag) {
-
-    case eHTMLTag_text:
-      result=eHTMLTag_p; break;
-
-    case eHTMLTag_html:
-      result=eHTMLTag_unknown; break;
-
-    case eHTMLTag_body:
-    case eHTMLTag_head:
-    case eHTMLTag_frameset:
-      result=eHTMLTag_html; break;
-
-      //These tags are head specific...
-    case eHTMLTag_style:
-    case eHTMLTag_meta:
-    case eHTMLTag_title:
-    case eHTMLTag_base:
-    case eHTMLTag_link:
-      result=eHTMLTag_head; break;
-
-      //These tags are table specific...
-    case eHTMLTag_caption:
-    case eHTMLTag_colgroup:
-    case eHTMLTag_tbody:
-    case eHTMLTag_tfoot:
-    case eHTMLTag_thead:
-      result=eHTMLTag_table; break;
-
-    case eHTMLTag_tr:
-      result=eHTMLTag_tbody; break;
-
-    case eHTMLTag_td:
-    case eHTMLTag_th:
-      result=eHTMLTag_tr; break;
-
-    case eHTMLTag_col:
-      result=eHTMLTag_colgroup; break;    
-
-    case eHTMLTag_dd:
-    case eHTMLTag_dt:
-      result=eHTMLTag_dl; break;    
-
-    case eHTMLTag_textarea:
-    case eHTMLTag_select:
-      result=eHTMLTag_form; break;
-
-    case eHTMLTag_option:
-      result=eHTMLTag_select; break;    
-
-      //These have to do with image maps...
-    case eHTMLTag_area:
-      result=eHTMLTag_map; break;    
-
-      //These have to do with applets...
-    case eHTMLTag_param:
-      result=eHTMLTag_applet; break;    
-
-      //These have to do with frames...
-    case eHTMLTag_frame:
-      result=eHTMLTag_frameset; break;    
-
-    default:
-      result=eHTMLTag_body; //XXX Hack! Just for now.
-      break;
-  }
+  PRBool result=nsHTMLElement::IsContainer((eHTMLTags)aTag);
   return result;
 }
 
@@ -2213,7 +1586,6 @@ PRBool CNavDTD::ForwardPropagate(nsTagStack& aStack,eHTMLTags aParentTag,eHTMLTa
     case eHTMLTag_tr:
       {  
         PRBool theCanContainResult=CanContain(eHTMLTag_td,aChildTag);
-        CompareResults(theCanContainResult,eHTMLTag_td,aChildTag);
         if(PR_TRUE==theCanContainResult) {
           aStack.Push(eHTMLTag_td);
           result=BackwardPropagate(aStack,aParentTag,eHTMLTag_td);
@@ -2248,13 +1620,13 @@ PRBool CNavDTD::BackwardPropagate(nsTagStack& aStack,eHTMLTags aParentTag,eHTMLT
   eHTMLTags theParentTag=aChildTag;
 
   do {
-    theParentTag=(eHTMLTags)GetDefaultParentTagFor(theParentTag);
+    CTagList* theRootTags=gHTMLElements[theParentTag].GetRootTags();
+    theParentTag=theRootTags->mTags[0];
     if(theParentTag!=eHTMLTag_unknown) {
       aStack.Push(theParentTag);
     }
 
     PRBool theCanContainResult=CanContain(aParentTag,theParentTag);
-    CompareResults(theCanContainResult,aParentTag,theParentTag);
 
     if(theCanContainResult) {
       //we've found a complete sequence, so push the parent...
@@ -2300,95 +1672,15 @@ PRBool CNavDTD::HasOpenContainer(eHTMLTags aContainer) const {
 PRBool CNavDTD::HasOpenContainer(const eHTMLTags aTagSet[],PRInt32 aCount) const {
 
   int theIndex; 
-  int theTopIndex=mBodyContext->mElements.mCount-1;
+  int theTopIndex=mBodyContext->GetCount()-1;
 
   for(theIndex=theTopIndex;theIndex>0;theIndex--){
-    if(FindTagInSet(mBodyContext->mElements.mTags[theIndex],aTagSet,aCount))
+    if(FindTagInSet((*mBodyContext)[theIndex],aTagSet,aCount))
       return PR_TRUE;
   }
   return PR_FALSE;
 }
 
-
-/**
- *  Call this method when you want to determine whether a
- *  given tag should be prevented (gated) from closing.
- *
- *  @update  gess 7/15/96
- *  @param   aTag the tag to be tested for autoclosure
- *  @return  TRUE if tag is gated.
- */
-PRBool CNavDTD::IsGatedFromClosing(eHTMLTags aChildTag) const {
-  PRBool  result=PR_FALSE;
-  PRInt32 tagPos=GetTopmostIndexOf(aChildTag);
-  PRInt32 theGatePos=kNotFound;
-
-  if(FindTagInSet(aChildTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
-    static eHTMLTags theGateTags[]={ 
-      eHTMLTag_caption, eHTMLTag_col, eHTMLTag_colgroup,  eHTMLTag_tbody,   
-      eHTMLTag_tfoot,   eHTMLTag_tr,  eHTMLTag_thead,     eHTMLTag_td, 
-      eHTMLTag_body};
-    theGatePos=GetTopmostIndexOf(theGateTags,sizeof(theGateTags)/sizeof(eHTMLTag_unknown));
-  }
-  else {
-    switch(aChildTag) {
-    case eHTMLTag_li:
-      {
-        static eHTMLTags theGateTags[]={eHTMLTag_ol,eHTMLTag_ul};
-        theGatePos=GetTopmostIndexOf(theGateTags,sizeof(theGateTags)/sizeof(eHTMLTag_unknown));
-      }
-      break;
-
-    case eHTMLTag_td:
-    case eHTMLTag_tr:
-      {      
-          /***************************************************************************
-           * This code may seem confusing, so let me explain it.
-           * We're trying to handle the case where a child tag may be prevented from
-           * closing a tag already on the stack. Here's a case:
-           *
-           *  <table>
-           *    <tr>
-           *      <td>
-           *        <table>
-           *          </tr>
-           *    
-           * In this case, the bottom </tr> is "gated" from closing the bottommost
-           * table.
-           *
-           * HOW THIS CODE WORKS:
-           *
-           *  This block of code compares all the members of the default parent 
-           *  hierarchy for the childtag against the open containers on our stack.
-           *  If they ever match, then the given child should be gated.
-           ***************************************************************************/
-
-        int theIndex; 
-        int theTopIndex=mBodyContext->mElements.mCount-1;
-
-        eHTMLTags theParent=GetDefaultParentTagFor(aChildTag);
-        while(eHTMLTag_unknown!=theParent) {
-          for(theIndex=theTopIndex;theIndex>tagPos;theIndex--){
-            if(mBodyContext->mElements.mTags[theIndex]==theParent){
-              theGatePos=theIndex;
-              break;
-            }
-          }
-          theParent=GetDefaultParentTagFor(theParent);
-        }
-      }
-      break;
-
-    default:
-      break;
-    }
-  }
-  if(kNotFound!=theGatePos)
-    if(kNotFound!=tagPos)
-      result=PRBool(theGatePos>tagPos);
-  return result;
-}
-
 /**
  *  This method retrieves the HTMLTag type of the topmost
  *  container on the stack.
@@ -2397,7 +1689,7 @@ PRBool CNavDTD::IsGatedFromClosing(eHTMLTags aChildTag) const {
  *  @return  tag id of topmost node in contextstack
  */
 eHTMLTags CNavDTD::GetTopNode() const {
-  return mBodyContext->mElements.Last();
+  return mBodyContext->Last();
 }
 
 /**
@@ -2409,10 +1701,10 @@ eHTMLTags CNavDTD::GetTopNode() const {
  *  @return  topmost index of tag on stack
  */
 PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTagSet[],PRInt32 aCount) const {
-  int i=0;
-  for(i=mBodyContext->mElements.mCount-1;i>=0;i--){
-    if(FindTagInSet(mBodyContext->mElements.mTags[i],aTagSet,aCount)) {
-      return i;
+  int theIndex=0;
+  for(theIndex=mBodyContext->GetCount()-1;theIndex>=0;theIndex--){
+    if(FindTagInSet((*mBodyContext)[theIndex],aTagSet,aCount)) {
+      return theIndex;
     }
   }
   return kNotFound;
@@ -2427,12 +1719,7 @@ PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTagSet[],PRInt32 aCount) const {
  *  @return  topmost index of tag on stack
  */
 PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTag) const {
-  int i=0;
-  for(i=mBodyContext->mElements.mCount-1;i>=0;i--){
-    if(mBodyContext->mElements.mTags[i]==aTag)
-      return i;
-  }
-  return kNotFound;
+  return ::GetTopmostIndexOf(aTag,mBodyContext->mTags);
 }
 
 /*********************************************
@@ -2455,34 +1742,34 @@ PRInt32 CNavDTD::GetTopmostIndexOf(eHTMLTags aTag) const {
 nsresult CNavDTD::OpenTransientStyles(eHTMLTags aTag){
   nsresult result=NS_OK;
 
-  if(!FindTagInSet(aTag,gWhitespaceTags,sizeof(gWhitespaceTags)/sizeof(eHTMLTag_unknown))) {
-    PRInt32 pos=0;
+  if(!FindTagInSet(aTag,gWhitespaceTags,sizeof(gWhitespaceTags)/sizeof(aTag))){ 
+      //the following code builds the set of style tags to be opened...
+    eHTMLTags theStyles[50];
+    int theCount=0;
 
-    eHTMLTags parentTag=mBodyContext->mElements.Last();
-    if(CanContainStyles(parentTag)) {
-      for(pos=0;pos<mBodyContext->mStyles->mCount;pos++) {
-        eHTMLTags theTag=mBodyContext->mStyles->mTags[pos]; 
-        if(PR_FALSE==HasOpenContainer(theTag)) {
-
-          CStartToken   token(theTag);
-          nsCParserNode theNode(&token,mLineNumber);
-
-          switch(theTag) {
-            case eHTMLTag_secret_h1style: case eHTMLTag_secret_h2style: 
-            case eHTMLTag_secret_h3style: case eHTMLTag_secret_h4style:
-            case eHTMLTag_secret_h5style: case eHTMLTag_secret_h6style:
-              break;
-            default:
-              token.SetTypeID(theTag);  //open the html container...
-              result=OpenContainer(theNode,PR_FALSE);
-              mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]=PR_TRUE;
-          } //switch
+    int theStackPos=0;
+    for(theStackPos=0;theStackPos<mBodyContext->GetCount();theStackPos++){
+      nsTagStack* theStyleStack=mBodyContext->mStyles[theStackPos];
+      if(theStyleStack) {
+        int theTagPos=0;
+        for(theTagPos=0;theTagPos<theStyleStack->mCount;theTagPos++){
+          if((0==theCount) || (!FindTagInSet(theStyleStack->mTags[theTagPos],theStyles,theCount))) {
+            theStyles[theCount++]=theStyleStack->mTags[theTagPos];
+          }
         }
-        if(NS_OK!=result)
-          break;
-      }//for
+      }
     }
-  }//if
+    theStyles[theCount]=eHTMLTag_unknown;
+
+      //now iterate style set, and open the containers...
+    for(theStackPos=0;theStackPos<theCount;theStackPos++){
+      CStartToken   token(theStyles[theStackPos]);
+      nsCParserNode theNode(&token,mLineNumber);
+      token.SetTypeID(theStyles[theStackPos]); 
+      result=OpenContainer(theNode,PR_FALSE);
+    }
+    mBodyContext->mOpenStyles=theCount;
+  }
   return result;
 }
 
@@ -2501,13 +1788,17 @@ nsresult CNavDTD::OpenTransientStyles(eHTMLTags aTag){
 nsresult CNavDTD::CloseTransientStyles(eHTMLTags aTag){
   nsresult result=NS_OK;
 
-  if((mBodyContext->mStyles->mCount>0) && (mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1])) {
-    if(!FindTagInSet(aTag,gWhitespaceTags,sizeof(gWhitespaceTags)/sizeof(eHTMLTag_unknown))) {
-      result=CloseContainersTo(mBodyContext->mStyles->mTags[0],PR_FALSE);
-      mBodyContext->mElements.mBits[mBodyContext->mElements.mCount-1]=PR_FALSE;
+  int theTagPos=0;
 
-    }//if
-  }//if
+    //now iterate style set, and close the containers...
+  for(theTagPos=mBodyContext->mOpenStyles;theTagPos>0;theTagPos--){
+    eHTMLTags theTag=GetTopNode();
+    CStartToken   token(theTag);
+    nsCParserNode theNode(&token,mLineNumber);
+    token.SetTypeID(theTag); 
+    result=CloseContainer(theNode,theTag,PR_FALSE);
+  }
+  mBodyContext->mOpenStyles=0;
   return result;
 }
 
@@ -2520,10 +1811,10 @@ nsresult CNavDTD::CloseTransientStyles(eHTMLTags aTag){
  * @param   aNode -- next node to be added to model
  */
 nsresult CNavDTD::OpenHTML(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
 
   nsresult result=mSink->OpenHTML(aNode); 
-  mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+  mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
   return result;
 }
 
@@ -2537,9 +1828,9 @@ nsresult CNavDTD::OpenHTML(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseHTML(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult result=mSink->CloseHTML(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
   return result;
 }
 
@@ -2553,8 +1844,9 @@ nsresult CNavDTD::CloseHTML(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::OpenHead(const nsIParserNode& aNode){
-  mBodyContext->mElements.Push(eHTMLTag_head);
+  mBodyContext->Push(eHTMLTag_head);
   nsresult result=mSink->OpenHead(aNode); 
+  mHasOpenHead=PR_TRUE;
   return result;
 }
 
@@ -2568,7 +1860,8 @@ nsresult CNavDTD::OpenHead(const nsIParserNode& aNode){
  */
 nsresult CNavDTD::CloseHead(const nsIParserNode& aNode){
   nsresult result=mSink->CloseHead(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
+  mHasOpenHead=PR_FALSE;
   return result;
 }
 
@@ -2581,10 +1874,10 @@ nsresult CNavDTD::CloseHead(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::OpenBody(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
 
   nsresult result=NS_OK;
-  eHTMLTags topTag=mBodyContext->mElements.Last();
+  eHTMLTags topTag=mBodyContext->Last();
 
   if(eHTMLTag_html!=topTag) {
     
@@ -2611,7 +1904,7 @@ nsresult CNavDTD::OpenBody(const nsIParserNode& aNode){
 
   if(NS_OK==result) {
     result=mSink->OpenBody(aNode); 
-    mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+    mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
   }
   return result;
 }
@@ -2625,9 +1918,9 @@ nsresult CNavDTD::OpenBody(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseBody(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
   nsresult result=mSink->CloseBody(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
   return result;
 }
 
@@ -2708,9 +2001,9 @@ nsresult CNavDTD::CloseMap(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::OpenFrameset(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
   nsresult result=mSink->OpenFrameset(aNode); 
-  mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+  mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
   return result;
 }
 
@@ -2723,9 +2016,9 @@ nsresult CNavDTD::OpenFrameset(const nsIParserNode& aNode){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseFrameset(const nsIParserNode& aNode){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult result=mSink->CloseFrameset(aNode); 
-  mBodyContext->mElements.Pop();
+  mBodyContext->Pop();
   return result;
 }
 
@@ -2740,7 +2033,7 @@ nsresult CNavDTD::CloseFrameset(const nsIParserNode& aNode){
  */
 nsresult
 CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
-  NS_PRECONDITION(mBodyContext->mElements.mCount >= 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() >= 0, kInvalidTagStackPos);
   
   nsresult   result=NS_OK; 
   eHTMLTags nodeType=(eHTMLTags)aNode.GetNodeType();
@@ -2755,7 +2048,6 @@ CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
       result=OpenBody(aNode); break;
 
     case eHTMLTag_style:
-    case eHTMLTag_head:
     case eHTMLTag_title:
       break;
 
@@ -2785,9 +2077,13 @@ CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
       }
       break;
 
+    case eHTMLTag_head:
+      result=OpenHead(aNode); //open the head...
+      break;
+
     default:
       result=mSink->OpenContainer(aNode); 
-      mBodyContext->mElements.Push((eHTMLTags)aNode.GetNodeType());
+      mBodyContext->Push((eHTMLTags)aNode.GetNodeType());
       break;
   }
 
@@ -2809,7 +2105,7 @@ CNavDTD::OpenContainer(const nsIParserNode& aNode,PRBool aUpdateStyleStack){
 nsresult
 CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
                         PRBool aUpdateStyles){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult   result=NS_OK;
   eHTMLTags nodeType=(eHTMLTags)aNode.GetNodeType();
   
@@ -2825,7 +2121,7 @@ CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
       break;
 
     case eHTMLTag_head:
-      //result=CloseHead(aNode); 
+      result=CloseHead(aNode); 
       break;
 
     case eHTMLTag_body:
@@ -2844,11 +2140,10 @@ CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
     case eHTMLTag_title:
     default:
       result=mSink->CloseContainer(aNode); 
-      mBodyContext->mElements.Pop();
+      mBodyContext->Pop();
       break;
   }
 
-  mBodyContext->mElements.mBits[mBodyContext->mElements.mCount]=PR_FALSE;
   if((NS_OK==result) && (PR_TRUE==aUpdateStyles)){
     UpdateStyleStackForCloseTag(nodeType,aTag);
   }
@@ -2867,15 +2162,15 @@ CNavDTD::CloseContainer(const nsIParserNode& aNode,eHTMLTags aTag,
 nsresult
 CNavDTD::CloseContainersTo(PRInt32 anIndex,eHTMLTags aTag,
                            PRBool aUpdateStyles){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
   nsresult result=NS_OK;
 
   static CEndToken aToken(gEmpty);
   nsCParserNode theNode(&aToken,mLineNumber);
 
-  if((anIndex<mBodyContext->mElements.mCount) && (anIndex>=0)) {
-    while(mBodyContext->mElements.mCount>anIndex) {
-      eHTMLTags theTag=mBodyContext->mElements.Last();
+  if((anIndex<mBodyContext->GetCount()) && (anIndex>=0)) {
+    while(mBodyContext->GetCount()>anIndex) {
+      eHTMLTags theTag=mBodyContext->Last();
       aToken.SetTypeID(theTag);
       result=CloseContainer(theNode,aTag,aUpdateStyles);
     }
@@ -2892,7 +2187,7 @@ CNavDTD::CloseContainersTo(PRInt32 anIndex,eHTMLTags aTag,
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
 
   PRInt32 pos=GetTopmostIndexOf(aTag);
 
@@ -2901,7 +2196,7 @@ nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
     return CloseContainersTo(pos,aTag,aUpdateStyles);
   }
 
-  eHTMLTags theTopTag=mBodyContext->mElements.Last();
+  eHTMLTags theTopTag=mBodyContext->Last();
   if(IsCompatibleTag(aTag,theTopTag)) {
     //if you're here, it's because we're trying to close one style tag,
     //but a different one is actually open. Because this is NAV4x
@@ -2915,7 +2210,8 @@ nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
   }
   
   nsresult result=NS_OK;
-  eHTMLTags theParentTag=GetDefaultParentTagFor(aTag);
+  CTagList* theTagList=gHTMLElements[aTag].GetRootTags();
+  eHTMLTags theParentTag=theTagList->mTags[0];
   pos=GetTopmostIndexOf(theParentTag);
   if(kNotFound!=pos) {
     //the parent container is open, so close it instead
@@ -2933,10 +2229,10 @@ nsresult CNavDTD::CloseContainersTo(eHTMLTags aTag,PRBool aUpdateStyles){
  * @return  TRUE if ok, FALSE if error
  */
 nsresult CNavDTD::CloseTopmostContainer(){
-  NS_PRECONDITION(mBodyContext->mElements.mCount > 0, kInvalidTagStackPos);
+  NS_PRECONDITION(mBodyContext->GetCount() > 0, kInvalidTagStackPos);
 
   CEndToken aToken(gEmpty);
-  eHTMLTags theTag=mBodyContext->mElements.Last();
+  eHTMLTags theTag=mBodyContext->Last();
   aToken.SetTypeID(theTag);
   nsCParserNode theNode(&aToken,mLineNumber);
   return CloseContainer(theNode,theTag,PR_TRUE);
@@ -2964,17 +2260,20 @@ nsresult CNavDTD::AddLeaf(const nsIParserNode& aNode){
  * @return  error code; 0 means OK
  */
 nsresult CNavDTD::AddHeadLeaf(const nsIParserNode& aNode){
-  
+  nsresult result=NS_OK;
+
   static eHTMLTags gNoXTags[]={eHTMLTag_noframes,eHTMLTag_nolayer,eHTMLTag_noscript};
   
   //this code has been added to prevent <meta> tags from being processed inside
   //the document if the <meta> tag itself was found in a <noframe>, <nolayer>, or <noscript> tag.
   if(eHTMLTag_meta==aNode.GetNodeType())
     if(HasOpenContainer(gNoXTags,sizeof(gNoXTags)/sizeof(eHTMLTag_unknown))) {
-      return NS_OK;
+      return result;
     }
 
-  nsresult result=OpenHead(aNode);
+  PRBool headOpen=mHasOpenHead;
+  if(!headOpen)
+    result=OpenHead(aNode);
   if(NS_OK==result) {
     result=AddLeaf(aNode);
     // XXX If the return value tells us to block, go
@@ -3014,7 +2313,7 @@ nsresult CNavDTD::CreateContextStackFor(eHTMLTags aChildTag){
   
   nsresult  result=(nsresult)kContextMismatch;
   PRInt32   cnt=0;
-  eHTMLTags theTop=mBodyContext->mElements.Last();
+  eHTMLTags theTop=mBodyContext->Last();
   PRBool    bResult=ForwardPropagate(kPropagationStack,theTop,aChildTag);
   
   if(PR_FALSE==bResult){
@@ -3050,7 +2349,7 @@ nsresult CNavDTD::CreateContextStackFor(eHTMLTags aChildTag){
     else bResult=BackwardPropagate(kPropagationStack,eHTMLTag_html,aChildTag);
   } //elseif
 
-  if((0==mBodyContext->mElements.mCount) || (mBodyContext->mElements.Last()==kPropagationStack.Pop()))
+  if((0==mBodyContext->GetCount()) || (mBodyContext->Last()==kPropagationStack.Pop()))
     result=NS_OK;
 
   //now, build up the stack according to the tags 
@@ -3080,14 +2379,14 @@ nsresult CNavDTD::CreateContextStackFor(eHTMLTags aChildTag){
  *  @return  
  */
 nsresult CNavDTD::ReduceContextStackFor(eHTMLTags aChildTag){
-  nsresult   result=NS_OK;
-  eHTMLTags topTag=mBodyContext->mElements.Last();
+  nsresult  result=NS_OK;
+  eHTMLTags theTopTag=mBodyContext->Last();
 
-  while( (topTag!=kNotFound) && 
-         (PR_FALSE==CanContain(topTag,aChildTag)) &&
-         (PR_FALSE==CanContainIndirect(topTag,aChildTag))) {
+  while( (theTopTag!=kNotFound) && 
+         (PR_FALSE==CanContain(theTopTag,aChildTag)) &&
+         (PR_FALSE==CanPropagate(theTopTag,aChildTag))){
     CloseTopmostContainer();
-    topTag=mBodyContext->mElements.Last();
+    theTopTag=mBodyContext->Last();
   }
   return result;
 }
@@ -3101,26 +2400,17 @@ nsresult CNavDTD::ReduceContextStackFor(eHTMLTags aChildTag){
  * @param   aTag is the id of the html container being opened
  * @return  0 if all is well.
  */
-nsresult
-CNavDTD::UpdateStyleStackForOpenTag(eHTMLTags aTag,eHTMLTags anActualTag){
+nsresult CNavDTD::UpdateStyleStackForOpenTag(eHTMLTags aTag,eHTMLTags anActualTag){
   nsresult   result=0;
-  
-  if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
-    mBodyContext->mStyles->Push(aTag);
-  }
-  else {
-    switch (aTag) {
-    case eHTMLTag_h1: case eHTMLTag_h2:
-    case eHTMLTag_h3: case eHTMLTag_h4:
-    case eHTMLTag_h5: case eHTMLTag_h6:
-      break;
 
-    default:
-      break;
+  if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
+    nsTagStack* theStyleStack=mBodyContext->mStyles[mBodyContext->GetCount()-1];
+    if(theStyleStack){
+      theStyleStack->Push(aTag);
     }
   }
   return result;
-} //update...
+} //update..
 
 
 /**
@@ -3135,440 +2425,43 @@ nsresult
 CNavDTD::UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags anActualTag){
   nsresult result=0;
   
-  if(mBodyContext->mStyles->mCount>0) {
-    if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
-      if(aTag==anActualTag)
-        mBodyContext->mStyles->Pop();
-    }
-    else {
-      switch (aTag) {
-      case eHTMLTag_h1: case eHTMLTag_h2:
-      case eHTMLTag_h3: case eHTMLTag_h4:
-      case eHTMLTag_h5: case eHTMLTag_h6:
-        break;
-
-      default:
-        break;
-      }//switch
-    }
+  if(mBodyContext->mStyles){
+    nsTagStack* theStyleStack=mBodyContext->mStyles[mBodyContext->GetCount()-1];
+    if(theStyleStack){
+      if(FindTagInSet(aTag,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_unknown))) {
+        if(aTag==anActualTag) {
+          theStyleStack->Pop();
+          mBodyContext->mOpenStyles--;
+        }
+      }
+    }//if
   }//if
   return result;
 }
 
-
-/*******************************************************************
-  These methods used to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
 /**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gess 5/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
+ * 
+ * @update	gess8/4/98
+ * @param 
+ * @return
  */
-nsresult
-CNavDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsresult result=aScanner.GetChar(aChar);
-
-  if(NS_OK==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(NS_OK==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=gTokenRecycler.CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
-          else aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_unknown,gEmpty);
-        }//if
-        break;
-
-      case kExclamation:
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-        break;
-
-      case kQuestionMark: //it must be an XML processing instruction...
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
-        break;
-
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (NS_OK==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
+nsITokenRecycler* CNavDTD::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
+ * Retrieve the preferred tokenizer for use by this DTD.
+ * @update	gess12/28/98
+ * @param   none
+ * @return  ptr to tokenizer
  */
-nsresult
-CNavDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  nsresult result=NS_OK;
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==NS_OK)) {
-    CAttributeToken* theToken= (CAttributeToken*)gTokenRecycler.CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
- 
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else if(NS_OK==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(NS_OK==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
+nsITokenizer* CNavDTD::GetTokenizer(void) {
+  if(!mTokenizer)
+    mTokenizer=new nsHTMLTokenizer();
+  return mTokenizer;
 }
 
-/**
- *  This is a special case method. It's job is to consume 
- *  all of the given tag up to an including the end tag.
- *
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null
- */
-nsresult
-CNavDTD::ConsumeContentToEndTag(PRUnichar aChar,
-                                eHTMLTags aChildTag,
-                                CScanner& aScanner,
-                                CToken*& aToken){
-  
-  //In the case that we just read the given tag, we should go and
-  //consume all the input until we find a matching end tag.
-
-  nsAutoString endTag("</");
-  endTag.Append(NS_EnumToTag(aChildTag));
-  endTag.Append(">");
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_skippedcontent,aChildTag,endTag);
-  return aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of a tag.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-
-static eHTMLTags gSkippedContentTags[]=
-  { eHTMLTag_noscript,
-    eHTMLTag_plaintext, eHTMLTag_script,   eHTMLTag_style, 
-    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
-
-static eHTMLTags gSkippedContentTargets[]=
-  { eHTMLTag_noscript,
-    eHTMLTag_html,      eHTMLTag_script,   eHTMLTag_style, 
-    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
-
-nsresult
-CNavDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
-  
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(NS_OK==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-      //now that that's over with, we have one more problem to solve.
-      //In the case that we just read a <SCRIPT> or <STYLE> tags, we should go and
-      //consume all the content itself.
-      if(NS_OK==result) {
-
-        eHTMLTags theTag=(eHTMLTags)aToken->GetTypeID();
-
-        PRInt32 theIndex=IndexOfTagInSet(theTag,gSkippedContentTags,sizeof(gSkippedContentTags)/sizeof(eHTMLTag_unknown));
-        if(-1<theIndex) {
-
-            //Do special case handling for <script>, <style>, <title> or <textarea>...
-          CToken*   skippedToken=0;
-          result=ConsumeContentToEndTag(aChar,gSkippedContentTargets[theIndex],aScanner,skippedToken);
-    
-          if((NS_OK==result) && skippedToken){
-            mTokenDeque.Push(skippedToken);
-  
-            //In the case that we just read a given tag, we should go and
-            //consume all the tag content itself (and throw it all away).
-
-            CToken* endtoken=gTokenRecycler.CreateTokenOfType(eToken_end,theTag,skippedToken->GetStringValueXXX());
-            mTokenDeque.Push(endtoken);
-          } //if
-        } //if
-      } //if
-
-      //EEEEECCCCKKKK!!! 
-      //This code is confusing, so pay attention.
-      //If you're here, it's because we were in the midst of consuming a start
-      //tag but ran out of data (not in the stream, but in this *part* of the stream.
-      //For simplicity, we have to unwind our input. Therefore, we pop and discard
-      //any new tokens we've cued this round. Later we can get smarter about this.
-      if(NS_OK!=result) {
-        while(mTokenDeque.GetSize()>theDequeSize) {
-          delete (CToken*)mTokenDeque.PopBack();
-        }
-      }
-
-
-    } //if
-  } //if
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult
-CNavDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  theChar;
-   nsresult result=aScanner.GetChar(theChar);
-
-   if(NS_OK==result) {
-     if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==theChar) {
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       aScanner.PutBack(theChar);
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult
-CNavDTD::ConsumeWhitespace(PRUnichar aChar,
-                           CScanner& aScanner,
-                           CToken*& aToken) {
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
-  nsresult result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CNavDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CNavDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
-  if(aToken) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-    if(result) {
-      nsString& temp=aToken->GetStringValueXXX();
-      if(0==temp.Length()){
-        delete aToken;
-        aToken = nsnull;
-      }
-      else result=kNoError;
-    }
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created newline token that is parsing
- *  @return error code
- */
-nsresult CNavDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CNavDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser){
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return NS_OK;
-  }
-
-  mParser=(nsParser*)aParser;
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    PRUnichar theChar;
-    result=theScanner->GetChar(theChar);
-    switch(result) {
-      case kEOF:
-          //We convert from eof to complete here, because we never really tried to get data.
-          //All we did was try to see if data was available, which it wasn't.
-          //It's important to return process complete, so that controlling logic can know that
-          //everything went well, but we're done with token processing.
-        result=kProcessComplete;
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(theChar) {
-          case kLessThan:
-            result=ConsumeTag(theChar,*theScanner,aToken);
-            break;
-
-          case kAmpersand:
-            result=ConsumeEntity(theChar,*theScanner,aToken);
-            break;
-          
-          case kCR: case kLF:
-            result=ConsumeNewline(theChar,*theScanner,aToken);
-            break;
-          
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(theChar)) {
-              nsAutoString temp(theChar);
-              result=ConsumeText(temp,*theScanner,aToken);
-              break;
-            }
-            result=ConsumeWhitespace(theChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-//    if(NS_OK==result)
-//      result=theScanner->Eof(); 
-  } //if
-  return result;
-}
-
-
 /**
  * 
  * @update  gess5/18/98
diff --git a/parser/htmlparser/src/CNavDTD.h b/parser/htmlparser/src/CNavDTD.h
index d23f87244db2..648c64b438b4 100644
--- a/parser/htmlparser/src/CNavDTD.h
+++ b/parser/htmlparser/src/CNavDTD.h
@@ -86,7 +86,6 @@
 #include "nsVoidArray.h"
 #include "nsDeque.h"
 
-
 #define NS_INAVHTML_DTD_IID      \
   {0x5c5cce40, 0xcfd6,  0x11d1,  \
   {0xaa, 0xda, 0x00,    0x80, 0x5f, 0x8a, 0x3e, 0x14}}
@@ -100,7 +99,7 @@ class CITokenHandler;
 class nsParser;
 class nsDTDContext;
 class nsTagStack;
-
+class nsITokenizer;
 
 /***************************************************************
   Now the main event: CNavDTD.
@@ -135,6 +134,8 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual ~CNavDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -191,6 +192,16 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -199,7 +210,7 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  This method is called by the parser, once for each token
@@ -229,21 +240,27 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
+    nsITokenizer* GetTokenizer(void);
 
+    
+    /**
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
+     */
+    virtual  nsITokenRecycler* GetTokenRecycler(void);
 
     /**
      * If the parse process gets interrupted, this method gets called
 	   * prior to the process resuming.
      * @update	gess5/18/98
-     * @return	error code -- usually kNoError (0)
+     * @return	error code -- usually NS_OK (0)
      */
     NS_IMETHOD WillResumeParse(void);
 
@@ -251,7 +268,7 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      * If the parse process is about to be interrupted, this method
 	   * will be called just prior.
      * @update	gess5/18/98
-     * @return	error code  -- usually kNoError (0)
+     * @return	error code  -- usually NS_OK (0)
      */
     NS_IMETHOD WillInterruptParse(void);
 
@@ -266,17 +283,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool CanContain(PRInt32 aParent,PRInt32 aChild) const;
 
-    /**
-     *  This method is called to determine whether or not a tag
-     *  of one type can contain a tag of another type.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   aParent -- int tag of parent container
-     *  @param   aChild -- int tag of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainEx(PRInt32 aParent,PRInt32 aChild) const;
-
     /**
      *  This method is called to determine whether or not a tag
      *  of one type can contain a tag of another type.
@@ -288,17 +294,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool CanPropagate(eHTMLTags aParent,eHTMLTags aChild) const;
 
-    /**
-     *  This method is called to determine whether a tag
-     *  of one of its children can contain a given child tag.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   aParent -- tag enum of parent container
-     *  @param   aChild -- tag enum of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const;
-
     /**
      *  This method gets called to determine whether a given 
      *  child tag can be omitted by the given parent.
@@ -331,17 +326,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool IsContainer(PRInt32 aTag) const;
 
-    /**
-     * Call this if you want the DTD to give you a default
-	   * Parent tag for given child tag. This is needed in cases
-	   * such as propagation.
-	   *
-     * @update  gess 7/6/98
-     * @param   aTag --  child to determine dflt parent tag for
-     * @return  enum of parent tag -- potentially eHTMLTag_unknown
-     */
-    virtual eHTMLTags GetDefaultParentTagFor(eHTMLTags aTag) const;
-
     /**
      * This method tries to design a context map (without actually
      * changing our parser state) from the parent down to the
@@ -381,17 +365,6 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
      */
     virtual PRBool HasOpenContainer(const eHTMLTags aTagSet[],PRInt32 aCount) const;
 
-    /**
-     * This method is used to determine the index on the stack of the
-     * nearest container tag that can constrain autoclosure. It is possible
-	   * that no tag on the stack will gate autoclosure.
-	   *
-     * @update	gess 7/15/98
-     * @param   id of tag you want to test for
-     * @return  index of gating tag on context stack. kNotFound otherwise
-     */
-    virtual PRBool IsGatedFromClosing(eHTMLTags aChild) const;
-
     /**
      * Accessor that retrieves the tag type of the topmost item on context 
 	   * vector stack.
@@ -418,9 +391,7 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
     virtual PRInt32 GetTopmostIndexOf(eHTMLTags aTagSet[],PRInt32 aCount) const;
 
 
-    virtual  nsITokenRecycler* GetTokenRecycler(void);
-
-    /**
+    /** 
      * The following methods are use to create and manage
      * the dynamic set of token handlers.
      * @update	gess5/11/98
@@ -538,52 +509,13 @@ CLASS_EXPORT_HTMLPARS CNavDTD : public nsIDTD {
     nsresult  UpdateStyleStackForOpenTag(eHTMLTags aTag,eHTMLTags aActualTag);
     nsresult  UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags aActualTag);
     PRBool    CanContainStyles(eHTMLTags aTag) const;
-    PRBool    RequiresAutomaticClosure(eHTMLTags aParentTag,eHTMLTags aChildTag) const;
-
-    /****************************************************
-        These methods interface with the parser to do
-        the tokenization phase.
-     ****************************************************/
-
-
-    /**
-     * The following methods consume a particular type
-     * of HTML token.
-     *
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-    nsresult     ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    nsresult     ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Causes content to be skipped up to sequence contained in aString.
-     * @update	gess 5/11/98
-     * @param   aString ????
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    virtual nsresult ConsumeContentToEndTag(PRUnichar aChar,
-																						eHTMLTags aChildTag,
-																						CScanner& aScanner,
-																						CToken*& aToken);
 
 
 protected:
 
-		PRInt32			CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
-		PRInt32			CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
-    PRInt32     DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag);    
+		nsresult    CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
+		nsresult    CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
+    nsresult    DidHandleStartTag(CToken* aToken,eHTMLTags aChildTag);    
 
 
     nsIHTMLContentSink* mSink;
@@ -599,11 +531,12 @@ protected:
     PRBool              mHasOpenMap;
     PRBool              mHasOpenHead;
     PRBool              mHasOpenBody;
-    nsDeque             mTokenDeque;
+    PRBool              mHadBodyOrFrameset;
     nsString            mFilename;
     nsIDTDDebug*		    mDTDDebug;
     PRInt32             mLineNumber;
     nsParser*           mParser;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewNavHTMLDTD(nsIDTD** aInstancePtrResult);
diff --git a/parser/htmlparser/src/COtherDTD.cpp b/parser/htmlparser/src/COtherDTD.cpp
index f19a24f85ebf..9e7d08674a19 100644
--- a/parser/htmlparser/src/COtherDTD.cpp
+++ b/parser/htmlparser/src/COtherDTD.cpp
@@ -38,7 +38,7 @@
 #include "nsParser.h"
 #include "nsIHTMLContentSink.h" 
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"
@@ -50,7 +50,7 @@
 #ifdef XP_PC
 #include <direct.h> //this is here for debug reasons...
 #endif
-#include <time.h>
+#include <time.h> 
 #include "prmem.h"
 
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
@@ -148,6 +148,16 @@ COtherDTD::~COtherDTD(){
   //parent does all the real work of destruction.
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& COtherDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh instance
  * of itself
@@ -330,19 +340,6 @@ PRBool COtherDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const {
 }
 
 
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gess 4/8/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool COtherDTD::CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const {
-  return CNavDTD::CanContainIndirect(aParent,aChild);
-}
-
 /**
  *  This method gets called to determine whether a given 
  *  tag can contain newlines. Most do not.
@@ -368,18 +365,6 @@ PRBool COtherDTD::CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild) const {
   return CNavDTD::CanOmitEndTag(aParent,aChild);
 }
 
-/**
- * This method does two things: 1st, help construct
- * our own internal model of the content-stack; and
- * 2nd, pass this message on to the sink.
- * @update  gess4/6/98
- * @param   aNode -- next node to be added to model
- * @return  TRUE if ok, FALSE if error
- */
-eHTMLTags COtherDTD::GetDefaultParentTagFor(eHTMLTags aTag) const{
-  return CNavDTD::GetDefaultParentTagFor(aTag);
-}
-
 
 /*********************************************
   Here comes code that handles the interface
@@ -693,140 +678,6 @@ nsresult COtherDTD::UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags anActua
   return CNavDTD::UpdateStyleStackForCloseTag(aTag,anActualTag);
 } //update...
 
-/*******************************************************************
-  These methods used to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gess 5/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
- */
-nsresult COtherDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeTag(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
- */
-nsresult COtherDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  return CNavDTD::ConsumeAttributes(aChar,aScanner,aToken);
-}
-
-/**
- *  This is a special case method. It's job is to consume 
- *  all of the given tag up to an including the end tag.
- *
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null
- */
-nsresult COtherDTD::ConsumeContentToEndTag(PRUnichar aChar,
-																					 eHTMLTags aChildTag,
-																					 CScanner& aScanner,
-																					 CToken*& aToken){
-  return CNavDTD::ConsumeContentToEndTag(aChar,aChildTag,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of a tag.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeStartTag(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeEntity(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  return CNavDTD::ConsumeWhitespace(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  return CNavDTD::ConsumeComment(aChar,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  return CNavDTD::ConsumeText(aString,aScanner,aToken);
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult COtherDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  return CNavDTD::ConsumeNewline(aChar,aScanner,aToken);
-}
-
-
 /**
  * 
  * @update	gess5/18/98
diff --git a/parser/htmlparser/src/COtherDTD.h b/parser/htmlparser/src/COtherDTD.h
index e3ccac7099ea..6b8686cf050c 100644
--- a/parser/htmlparser/src/COtherDTD.h
+++ b/parser/htmlparser/src/COtherDTD.h
@@ -62,6 +62,8 @@ class COtherDTD : public CNavDTD {
      */
     virtual ~COtherDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -117,17 +119,6 @@ class COtherDTD : public CNavDTD {
      */
     virtual PRBool CanContain(PRInt32 aParent,PRInt32 aChild) const;
 
-    /**
-     *  This method is called to determine whether or not a tag
-     *  of one type can contain a tag of another type.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   aParent -- tag enum of parent container
-     *  @param   aChild -- tag enum of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainIndirect(eHTMLTags aParent,eHTMLTags aChild) const;
-
     /**
      *  This method gets called to determine whether a given 
      *  tag can contain newlines. Most do not.
@@ -148,17 +139,6 @@ class COtherDTD : public CNavDTD {
      *  @return  PR_TRUE if given tag can contain other tags
      */
     virtual PRBool CanOmitEndTag(eHTMLTags aParent,eHTMLTags aChild)const;
-
-    /**
-     * This method does two things: 1st, help construct
-     * our own internal model of the content-stack; and
-     * 2nd, pass this message on to the sink.
-     * @update  gess4/6/98
-     * @param   aNode -- next node to be added to model
-     * @return  TRUE if ok, FALSE if error
-     */
-    virtual eHTMLTags GetDefaultParentTagFor(eHTMLTags aTag) const;
-
    
     /**
      * This method gets called when a start token has been consumed and needs 
@@ -428,104 +408,6 @@ private:
     nsresult UpdateStyleStackForCloseTag(eHTMLTags aTag,eHTMLTags aActualTag);
 
 
-    /****************************************************
-        These methods interface with the parser to do
-        the tokenization phase.
-     ****************************************************/
-
-
-    /**
-     * Retrieve the next TAG from the given scanner.
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve next START tag from given scanner.
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve collection of HTML/XML attributes from given scanner
-     * @update	gess 5/11/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-    
-    /**
-     * Retrieve a sequence of text from given scanner.
-     * @update	gess 5/11/98
-     * @param   aString will contain retrieved text.
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve an entity from given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a whitespace sequence from the given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a comment from the given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Retrieve newlines from given scanner
-     * @update	gess 5/11/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    nsresult     ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Causes content to be skipped up to sequence contained in aString.
-     * @update	gess 5/11/98
-     * @param   aString ????
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    virtual nsresult ConsumeContentToEndTag(PRUnichar aChar,
-																						eHTMLTags aChildTag,
-																						CScanner& aScanner,
-																						CToken*& aToken);
-
-
 protected:
 
     
diff --git a/parser/htmlparser/src/CParserContext.cpp b/parser/htmlparser/src/CParserContext.cpp
index 90b2cf9226a5..67850f48ed8d 100644
--- a/parser/htmlparser/src/CParserContext.cpp
+++ b/parser/htmlparser/src/CParserContext.cpp
@@ -9,7 +9,7 @@
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  * for the specific language governing rights and limitations under the
  * NPL.
- *
+ * 
  * The Initial Developer of this code under the NPL is Netscape
  * Communications Corporation.  Portions created by Netscape are
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
@@ -20,7 +20,7 @@
 #include "CParserContext.h"
 #include "nsToken.h"
 
-
+/*
 class CTokenDeallocator: public nsDequeFunctor{
 public:
   virtual void* operator()(void* anObject) {
@@ -32,7 +32,7 @@ public:
 
 CTokenDeallocator gTokenDeallocator;
 
-
+*/
 
 /**
  * Your friendly little constructor. Ok, it's not the friendly, but the only guy
@@ -42,9 +42,9 @@ CTokenDeallocator gTokenDeallocator;
  * @param   aKey
  * @param   aListener
  */
-CParserContext::CParserContext(CScanner* aScanner,void* aKey,nsIStreamObserver* aListener) :
-  mSourceType(),
-  mTokenDeque(gTokenDeallocator)
+CParserContext::CParserContext(nsScanner* aScanner,void* aKey,nsIStreamObserver* aListener) :
+  mSourceType()
+  //,mTokenDeque(gTokenDeallocator)
 {
   mScanner=aScanner;
   mKey=aKey;
@@ -54,9 +54,8 @@ CParserContext::CParserContext(CScanner* aScanner,void* aKey,nsIStreamObserver*
   mParseMode=eParseMode_unknown;
   mAutoDetectStatus=eUnknownDetect;
   mTransferBuffer=0;
-  mCurrentPos=0;
-  mMarkPos=0;
   mDTD=0;
+  mTransferBufferSize=eTransferBufferSize;
 }
 
 
@@ -67,11 +66,6 @@ CParserContext::CParserContext(CScanner* aScanner,void* aKey,nsIStreamObserver*
  */
 CParserContext::~CParserContext(){
 
-  if(mCurrentPos)
-    delete mCurrentPos;
-  if(mMarkPos)
-    delete mMarkPos;
-
   if(mScanner)
     delete mScanner;
 
diff --git a/parser/htmlparser/src/CParserContext.h b/parser/htmlparser/src/CParserContext.h
index 9a8d1d678a04..55b4fcbe72b7 100644
--- a/parser/htmlparser/src/CParserContext.h
+++ b/parser/htmlparser/src/CParserContext.h
@@ -26,13 +26,12 @@
 #define __CParserContext
 
 #include "nsIParser.h"
-#include "nsDeque.h"
-#include "nsParserTypes.h"
 #include "nsIURL.h"
 #include "nsIDTD.h"
 #include "nsScanner.h"
 #include "nsIStreamListener.h"
 #include "nsString.h"
+#include "nshtmlpars.h"
 
 /**
  * Note that the parser is given FULL access to all
@@ -45,7 +44,7 @@ public:
 
     enum {eTransferBufferSize=4096};
 
-    CParserContext( CScanner* aScanner,
+    CParserContext( nsScanner* aScanner,
                     void* aKey=0,
                     nsIStreamObserver* aListener=0);
 
@@ -56,10 +55,7 @@ public:
     nsString            mSourceType;
     eAutoDetectResult   mAutoDetectStatus;
 
-    nsDequeIterator*    mCurrentPos;
-    nsDequeIterator*    mMarkPos;
-    nsDeque             mTokenDeque;
-    CScanner*           mScanner;
+    nsScanner*          mScanner;
     nsIDTD*             mDTD;
 
     eParseMode          mParseMode;
@@ -68,7 +64,8 @@ public:
 
     CParserContext*     mPrevContext;
     void*               mKey;
-
+    PRUint32            mTransferBufferSize;
+    // nsDeque          mTokenDeque;
 };
 
 
diff --git a/parser/htmlparser/src/CRtfDTD.cpp b/parser/htmlparser/src/CRtfDTD.cpp
index 222cd9807407..285e4d3fefe2 100644
--- a/parser/htmlparser/src/CRtfDTD.cpp
+++ b/parser/htmlparser/src/CRtfDTD.cpp
@@ -36,8 +36,9 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
+#include "nsITokenizer.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"  //this is here for debug reasons...
@@ -198,6 +199,7 @@ CRtfDTD::CRtfDTD() : nsIDTD() {
   NS_INIT_REFCNT();
   mParser=0;
   mFilename=0;
+  mTokenizer=0;
 }
 
 /**
@@ -210,6 +212,16 @@ CRtfDTD::CRtfDTD() : nsIDTD() {
 CRtfDTD::~CRtfDTD(){
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CRtfDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct fresh instance
  * of itself.
@@ -261,141 +273,39 @@ NS_IMETHODIMP CRtfDTD::WillBuildModel(nsString& aFilename,PRInt32 aLevel,nsIPars
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CRtfDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CRtfDTD::DidBuildModel(PRInt32 anErrorCode,PRInt32 aLevel,nsIParser* aParser){
+NS_IMETHODIMP CRtfDTD::DidBuildModel(nsresult anErrorCode,PRInt32 aLevel,nsIParser* aParser){
   nsresult result=NS_OK;
 
   return result;
 }
 
-
-
-/*******************************************************************
-  These methods use to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
 /**
- *  This gets called when we've just read a '\' char. 
- *  It means we need to read an RTF control word.
- *  
- *  @update gess 3/25/98
- *  @param  aToken ptr-ref to new token we create
- *  @return error code -- preferably kNoError
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
  */
-PRInt32 CRtfDTD::ConsumeControlWord(CToken*& aToken){
-  PRInt32 result=kNoError;
-  CRTFControlWord* cw=new CRTFControlWord("");
-  if(cw){
-    CScanner* theScanner=mParser->GetScanner();
-    cw->Consume(*theScanner);
-    aToken=cw;
-  }
-  return result;
-}
-
-/**
- *  This gets called when we've just read a '{' or '}' group char. 
- *  It means we have just started or ended an RTF group.
- *  
- *  @update gess 3/25/98
- *  @param  aToken ptr-ref to new token we create
- *  @return error code -- preferably kNoError
- */
-static char* keys[] = {"}","{"};
-
-PRInt32 CRtfDTD::ConsumeGroupTag(CToken*& aToken,PRBool aStartGroup){
-  PRInt32 result=kNoError;
-  CRTFGroup* cw=new CRTFGroup(keys[PR_TRUE==aStartGroup],aStartGroup);
-  if(cw){
-    CScanner* theScanner=mParser->GetScanner();
-    cw->Consume(*theScanner);
-    aToken=cw;
-  }
-  return result;
-}
-
-/**
- *  This gets called when we've just read plain text char.
- *  It means we need to read RTF content.
- *  
- *  @update gess 3/25/98
- *  @param  aToken ptr-ref to new token we create
- *  @return error code -- preferably kNoError
- */
-PRInt32 CRtfDTD::ConsumeContent(PRUnichar aChar,CToken*& aToken){
-  PRInt32 result=kNoError;
-  PRUnichar buffer[2] = {0,0};
-  buffer[0]=aChar;
-  CRTFContent * cw=new CRTFContent(buffer);
-  if(cw){
-    CScanner* theScanner=mParser->GetScanner();
-    cw->Consume(*theScanner);
-    aToken=cw;
-  }
-  return result;
-}
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult CRtfDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser){
-
-  mParser=(nsParser*)aParser;
-  CScanner* theScanner=mParser->GetScanner();
-
-  PRUnichar aChar;
-  nsresult   result=theScanner->GetChar(aChar);
-
-  switch(result) {
-    case kEOF:
-      break;
-
-    case kInterrupted:
-      theScanner->RewindToMark();
-      break; 
-
-    case NS_OK:
-    default:
-      switch(aChar) {
-        case kLeftBrace:
-          result=ConsumeGroupTag(aToken,PR_TRUE); break;
-
-        case kRightBrace:
-          result=ConsumeGroupTag(aToken,PR_FALSE); break;
-
-        case kBackSlash:
-          result=ConsumeControlWord(aToken); break;
-
-        case kCR:
-        case kSpace:
-        case kTab:
-        case kLF:
-          break;
-
-        default:
-          result=ConsumeContent(aChar,aToken); break;
-      } //switch
-      break; 
-  } //switch
-  if(NS_OK==result)
-    result=theScanner->Eof();
-  return result;
+nsITokenizer* CRtfDTD::GetTokenizer(void){
+  return 0;
 }
 
 /**
@@ -474,8 +384,8 @@ PRBool CRtfDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const{
  *  @param   aToken -- token object to be put into content model
  *  @return  0 if all is well; non-zero is an error
  */
-PRInt32 CRtfDTD::HandleGroup(CToken* aToken){
-  PRInt32 result=kNoError;
+nsresult CRtfDTD::HandleGroup(CToken* aToken){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -485,8 +395,8 @@ PRInt32 CRtfDTD::HandleGroup(CToken* aToken){
  *  @param   aToken -- token object to be put into content model
  *  @return  0 if all is well; non-zero is an error
  */
-PRInt32 CRtfDTD::HandleControlWord(CToken* aToken){
-  PRInt32 result=kNoError;
+nsresult CRtfDTD::HandleControlWord(CToken* aToken){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -496,8 +406,8 @@ PRInt32 CRtfDTD::HandleControlWord(CToken* aToken){
  *  @param   aToken -- token object to be put into content model
  *  @return  0 if all is well; non-zero is an error
  */
-PRInt32 CRtfDTD::HandleContent(CToken* aToken){
-  PRInt32 result=kNoError;
+nsresult CRtfDTD::HandleContent(CToken* aToken){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -582,9 +492,9 @@ PRInt32 CRTFControlWord::GetTokenType() {
 }
 
 
-PRInt32 CRTFControlWord::Consume(CScanner& aScanner){
+PRInt32 CRTFControlWord::Consume(nsScanner& aScanner){
   PRInt32 result=aScanner.ReadWhile(mTextValue,gAlphaChars,PR_TRUE,PR_FALSE);
-  if(kNoError==result) {
+  if(NS_OK==result) {
     //ok, now look for an option parameter...
     PRUnichar ch;
     result=aScanner.Peek(ch);
@@ -601,7 +511,7 @@ PRInt32 CRTFControlWord::Consume(CScanner& aScanner){
         break;
     }
   }
-  if(kNoError==result)
+  if(NS_OK==result)
     result=aScanner.SkipWhitespace();
   return result;
 }
@@ -614,7 +524,7 @@ PRInt32 CRTFControlWord::Consume(CScanner& aScanner){
 CRTFGroup::CRTFGroup(char* aKey,PRBool aStartGroup) : CToken(aKey) {
   mStart=aStartGroup;
 }
-
+ 
 
 PRInt32 CRTFGroup::GetTokenType() {
   return eRTFToken_group;
@@ -628,8 +538,8 @@ PRBool CRTFGroup::IsGroupStart(){
   return mStart;
 }
 
-PRInt32 CRTFGroup::Consume(CScanner& aScanner){
-  PRInt32 result=kNoError;
+PRInt32 CRTFGroup::Consume(nsScanner& aScanner){
+  PRInt32 result=NS_OK;
   if(PR_FALSE==mStart)
     result=aScanner.SkipWhitespace();
   return result;
@@ -658,7 +568,7 @@ PRInt32 CRTFContent::GetTokenType() {
  * @return
  */
 static nsString textTerminators("\\{}");
-PRInt32 CRTFContent::Consume(CScanner& aScanner){
+PRInt32 CRTFContent::Consume(nsScanner& aScanner){
   PRInt32 result=aScanner.ReadUntil(mTextValue,textTerminators,PR_FALSE,PR_FALSE);
   return result;
 }
diff --git a/parser/htmlparser/src/CRtfDTD.h b/parser/htmlparser/src/CRtfDTD.h
index 55ffb3b40509..cfc1f82bb83e 100644
--- a/parser/htmlparser/src/CRtfDTD.h
+++ b/parser/htmlparser/src/CRtfDTD.h
@@ -40,7 +40,7 @@
 
 class nsIParserNode;
 class nsParser;
-
+class nsITokenizer;
 
 enum eRTFTokenTypes {
   eRTFToken_unknown=0,
@@ -102,7 +102,7 @@ class CRTFControlWord : public CToken {
 public:
                   CRTFControlWord(char* aKey);
   virtual PRInt32 GetTokenType();
-  virtual PRInt32 Consume(CScanner& aScanner);
+  virtual PRInt32 Consume(nsScanner& aScanner);
 protected:
   nsString  mArgument;
 };
@@ -120,7 +120,7 @@ public:
   virtual PRInt32 GetTokenType();
   virtual void    SetGroupStart(PRBool aFlag);
   virtual PRBool  IsGroupStart();
-  virtual PRInt32 Consume(CScanner& aScanner);
+  virtual PRInt32 Consume(nsScanner& aScanner);
 protected:
           PRBool  mStart;
 };
@@ -136,7 +136,7 @@ class CRTFContent: public CToken {
 public:
                   CRTFContent(PRUnichar* aValue);
   virtual PRInt32 GetTokenType();
-  virtual PRInt32 Consume(CScanner& aScanner);
+  virtual PRInt32 Consume(nsScanner& aScanner);
 };
 
 
@@ -165,6 +165,8 @@ class CRtfDTD : public nsIDTD {
      */
     virtual ~CRtfDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -202,6 +204,16 @@ class CRtfDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRInt32 aLevel,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -210,7 +222,7 @@ class CRtfDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRInt32 aLevel,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRInt32 aLevel,nsIParser* aParser);
 
     /**
      *  
@@ -218,7 +230,7 @@ class CRtfDTD : public nsIDTD {
      *  @param   aToken -- token object to be put into content model
      *  @return  0 if all is well; non-zero is an error
      */
-    virtual PRInt32 HandleGroup(CToken* aToken);
+    NS_IMETHOD HandleGroup(CToken* aToken);
 
     /**
      *  
@@ -226,7 +238,7 @@ class CRtfDTD : public nsIDTD {
      *  @param   aToken -- token object to be put into content model
      *  @return  0 if all is well; non-zero is an error
      */
-    virtual PRInt32 HandleControlWord(CToken* aToken);
+    NS_IMETHOD HandleControlWord(CToken* aToken);
 
     /**
      *  
@@ -234,7 +246,7 @@ class CRtfDTD : public nsIDTD {
      *  @param   aToken -- token object to be put into content model
      *  @return  0 if all is well; non-zero is an error
      */
-    virtual PRInt32 HandleContent(CToken* aToken);
+    NS_IMETHOD HandleContent(CToken* aToken);
 
     /**
      *  
@@ -262,47 +274,14 @@ class CRtfDTD : public nsIDTD {
      */
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
-   
+  
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    virtual PRInt32 ConsumeControlWord(CToken*& aToken);
-
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    virtual PRInt32 ConsumeGroupTag(CToken*& aToken,PRBool aStartTag);
-
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    virtual PRInt32 ConsumeContent(PRUnichar aChar,CToken*& aToken);
-
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
+    nsITokenizer* GetTokenizer(void);
 
     /**
      * 
@@ -371,6 +350,7 @@ protected:
     
     nsParser*           mParser;
     char*               mFilename;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewRTF_DTD(nsIDTD** aInstancePtrResult);
diff --git a/parser/htmlparser/src/MANIFEST b/parser/htmlparser/src/MANIFEST
index 2948935a25f2..49874d39525d 100644
--- a/parser/htmlparser/src/MANIFEST
+++ b/parser/htmlparser/src/MANIFEST
@@ -6,6 +6,7 @@ nshtmlpars.h
 nsIContentSink.h
 nsIHTMLContentSink.h
 nsHTMLContentSinkStream.h
+nsITokenizer.h
 nsHTMLTokens.h
 nsIParserNode.h
 nsIParser.h
diff --git a/parser/htmlparser/src/Makefile.in b/parser/htmlparser/src/Makefile.in
index 67f88033590e..26b831a1eedf 100644
--- a/parser/htmlparser/src/Makefile.in
+++ b/parser/htmlparser/src/Makefile.in
@@ -30,6 +30,8 @@ DEFINES += -D_IMPL_NS_HTMLPARS
 
 CPPSRCS=					\
 	nsDTDUtils.cpp				\
+	nsHTMLTokenizer.cpp \
+	nsXMLTokenizer.cpp \
 	CNavDTD.cpp				\
 	COtherDTD.cpp				\
 	CRtfDTD.cpp				\
@@ -57,6 +59,7 @@ CPPSRCS=					\
 EXPORTS =     \
   nshtmlpars.h    \
   nsIContentSink.h  \
+	nsITokenizer.h \
   nsIHTMLContentSink.h  \
   nsHTMLContentSinkStream.h \
   nsHTMLEntities.h    \
diff --git a/parser/htmlparser/src/makefile.win b/parser/htmlparser/src/makefile.win
index e7c3361c46e7..326e407708cb 100644
--- a/parser/htmlparser/src/makefile.win
+++ b/parser/htmlparser/src/makefile.win
@@ -25,6 +25,8 @@ REQUIRES=xpcom raptor netlib
 
 CPPSRCS=					\
 	nsDTDUtils.cpp				\
+	nsHTMLTokenizer.cpp \
+	nsXMLTokenizer.cpp \
 	CNavDTD.cpp				\
 	COtherDTD.cpp				\
 	CRtfDTD.cpp				\
@@ -51,6 +53,8 @@ CPPSRCS=					\
 
 CPP_OBJS=					\
 	.\$(OBJDIR)\nsDTDUtils.obj			\
+	.\$(OBJDIR)\nsHTMLTokenizer.obj \
+	.\$(OBJDIR)\nsXMLTokenizer.obj \
 	.\$(OBJDIR)\CNavDTD.obj			\
 	.\$(OBJDIR)\COtherDTD.obj		\
 	.\$(OBJDIR)\CRtfDTD.obj			\
@@ -77,6 +81,7 @@ CPP_OBJS=					\
 
 EXPORTS=					\
 	nshtmlpars.h				\
+	nsITokenizer.h \
 	nsIContentSink.h			\
 	nsIHTMLContentSink.h			\
 	nsILoggingSink.h			\
diff --git a/parser/htmlparser/src/nsDTDDebug.cpp b/parser/htmlparser/src/nsDTDDebug.cpp
index 3e9a37f69dae..9c02e2774ad4 100644
--- a/parser/htmlparser/src/nsDTDDebug.cpp
+++ b/parser/htmlparser/src/nsDTDDebug.cpp
@@ -17,7 +17,7 @@
  */
   
 /**
- * MODULE NOTES:
+ * MODULE NOTES: 
  * @update  jevering 06/18/98
  * 
  * This file contains the parser debugger object which aids in
diff --git a/parser/htmlparser/src/nsDTDUtils.cpp b/parser/htmlparser/src/nsDTDUtils.cpp
index 18c2a47a72ee..3550a4549df4 100644
--- a/parser/htmlparser/src/nsDTDUtils.cpp
+++ b/parser/htmlparser/src/nsDTDUtils.cpp
@@ -15,10 +15,10 @@
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  * Reserved.
  */
-
+ 
 
 #include "nsDTDUtils.h"
-
+#include "CNavDTD.h"
 
 static CTokenDeallocator gTokenKiller;
  
@@ -27,23 +27,17 @@ static CTokenDeallocator gTokenKiller;
  ***************************************************************/
 
 
-
 /**
  * Default constructor
  * @update	gess9/10/98
  */
 nsTagStack::nsTagStack(int aDefaultSize) {
-#ifndef rickgdebug
-  mSize=aDefaultSize;
-  mTags =new eHTMLTags[mSize];
-  mBits =new PRBool[mSize];
-#else
-  mSize=eStackSize;
+#ifndef NS_DEBUG
+  mTags =new eHTMLTags[mCapacity];
 #endif
+  mCapacity=aDefaultSize;
   mCount=0;
-  mPrevious=0;
-  nsCRT::zero(mTags,mSize*sizeof(eHTMLTags));
-  nsCRT::zero(mBits,mSize*sizeof(PRBool));
+  nsCRT::zero(mTags,mCapacity*sizeof(eHTMLTags));
 }
 
 /**
@@ -51,14 +45,12 @@ nsTagStack::nsTagStack(int aDefaultSize) {
  * @update  gess7/9/98
  */
 nsTagStack::~nsTagStack() {
-#ifndef rickgdebug
-    delete mTags;
-    delete mBits;
-    mTags=0;
-    mBits=0;
+#ifndef NS_DEBUG
+  delete mTags;
+  mTags=0;
 #endif
-    mSize=mCount=0; 
-  }
+  mCapacity=mCount=0; 
+}
 
 /**
  * Resets state of stack to be empty.
@@ -73,27 +65,17 @@ void nsTagStack::Empty(void) {
  * @update  gess7/9/98 
  */
 void nsTagStack::Push(eHTMLTags aTag) {
-
-  if(mCount>=mSize) {
-#ifndef rickgdebug
-      //regrow the dynamic stack... 
-    eHTMLTags* tmp=new eHTMLTags[2*mSize];
-    nsCRT::zero(tmp,2*mSize*sizeof(eHTMLTag_html));
-    nsCRT::memcpy(tmp,mTags,mSize*sizeof(eHTMLTag_html));
+  if(mCount>=mCapacity) {
+#ifndef NS_DEBUG
+    eHTMLTags* tmp=new eHTMLTags[2*mCapacity];
+    nsCRT::zero(tmp,2*mCapacity*sizeof(eHTMLTag_html));
+    nsCRT::memcpy(tmp,mTags,mCapacity*sizeof(eHTMLTag_html));
     delete mTags;
     mTags=tmp;
-
-    PRBool* tmp2=new PRBool[2*mSize];
-    nsCRT::zero(tmp2,2*mSize*sizeof(PRBool));
-    nsCRT::memcpy(tmp2,mBits,mSize*sizeof(PRBool));
-    delete mBits;
-    mBits=tmp2;
-    mSize*=2;
 #else
     NS_PRECONDITION(mCount<eStackSize,"TagStack Overflow: DEBUG VERSION!");
 #endif
   }
-
   mTags[mCount++]=aTag;
 }
 
@@ -106,7 +88,6 @@ eHTMLTags nsTagStack::Pop() {
   if(mCount>0) {
     result=mTags[--mCount];
     mTags[mCount]=eHTMLTag_unknown;
-    mBits[mCount]=PR_FALSE;
   }
   return result;
 }
@@ -121,6 +102,29 @@ eHTMLTags nsTagStack::First() const {
   return eHTMLTag_unknown;
 }
 
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsTagStack::TagAt(PRInt32 anIndex) const {
+  if((anIndex>=0) && (anIndex<mCount))
+    return mTags[anIndex];
+  return eHTMLTag_unknown;
+}
+
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsTagStack::operator[](PRInt32 anIndex) const {
+  if((anIndex>=0) && (anIndex<mCount))
+    return mTags[anIndex];
+  return eHTMLTag_unknown;
+}
+
+
+
 /**
  * 
  * @update  gess7/9/98
@@ -141,9 +145,13 @@ eHTMLTags nsTagStack::Last() const {
  * 
  * @update	gess9/10/98
  */
-nsDTDContext::nsDTDContext(int aDefaultSize) : mElements(aDefaultSize) {
-  mStyles=new nsTagStack(aDefaultSize);
-}
+nsDTDContext::nsDTDContext(int aDefaultSize) {
+#ifndef NS_DEBUG
+  mStyles =new nsTagStack*[mCapacity];
+#endif
+  mOpenStyles=0;
+  nsCRT::zero(mStyles,mTags.mCapacity*sizeof(void*));
+} 
  
 
 /**
@@ -151,43 +159,88 @@ nsDTDContext::nsDTDContext(int aDefaultSize) : mElements(aDefaultSize) {
  * @update	gess9/10/98
  */
 nsDTDContext::~nsDTDContext() {
-  while(mStyles){
-    nsTagStack* next=mStyles->mPrevious;
+#ifndef NS_DEBUG
+  delete mTags;
+  delete mStyles;
+  mTags=0;
+  mStyles=0;
+#endif
+}
+
+/**
+ * 
+ * @update  gess7/9/98 
+ */
+PRInt32 nsDTDContext::GetCount(void) {
+  return mTags.mCount;
+}
+
+/**
+ * 
+ * @update  gess7/9/98 
+ */
+void nsDTDContext::Push(eHTMLTags aTag) {
+  if(mTags.mCount>=mTags.mCapacity) {
+#ifndef NS_DEBUG
+    nsTagStack** tmp2=new nsTagStack*[2*mTags.mCapacity];
+    nsCRT::zero(tmp2,2*mTags.mCapacity*sizeof(void*));
+    nsCRT::memcpy(tmp2,mStyles,mTags.mCapacity*sizeof(void*));
     delete mStyles;
-    mStyles=next;
+    mStyles=tmp2;
+    //mCapacity*=2;
+#else
+    NS_PRECONDITION(mTags.mCount<nsTagStack::eStackSize,"TagStack Overflow: DEBUG VERSION!");
+#endif
   }
+  mTags.Push(aTag);
 }
 
-
 /**
- * Creates and pushes a new style stack onto our
- * internal list of style stacks.
- * @update	gess9/10/98
+ * 
+ * @update  gess7/9/98
  */
-void nsDTDContext::pushStyleStack(nsTagStack* aStyleStack){
-  if(!aStyleStack)
-    aStyleStack=new nsTagStack();
-  if(aStyleStack){
-    mStyles->mPrevious=mStyles;
-    mStyles=aStyleStack;
-  }
-}
-
-
-/**
- * Pops the topmost style stack off our internal
- * list of style stacks.
- * @update	gess9/10/98
- */
-nsTagStack* nsDTDContext::popStyleStack(){
-  nsTagStack* result=0;
-  if(mStyles) {
-    result=mStyles;
-    mStyles=mStyles->mPrevious;
+eHTMLTags nsDTDContext::Pop() {
+  eHTMLTags result=eHTMLTag_unknown;
+  if(mTags.mCount>0) {
+    result=mTags.Pop();
+    mStyles[mTags.mCount]=0;
   }
   return result;
 }
 
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::First() const {
+  return mTags.First();
+}
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::TagAt(PRInt32 anIndex) const {
+  return mTags.TagAt(anIndex);
+}
+
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::operator[](PRInt32 anIndex) const {
+  return mTags[anIndex];
+}
+
+/**
+ * 
+ * @update  gess7/9/98
+ */
+eHTMLTags nsDTDContext::Last() const {
+  return mTags.Last();
+}
+
 
 /**************************************************************
   Now define the tokenrecycler class...
@@ -202,7 +255,7 @@ CTokenRecycler::CTokenRecycler() : nsITokenRecycler() {
   int i=0;
   for(i=0;i<eToken_last-1;i++) {
     mTokenCache[i]=new nsDeque(gTokenKiller);
-//    mTotals[i]=0;
+    //mTotals[i]=0;
   }
 }
 
@@ -219,6 +272,17 @@ CTokenRecycler::~CTokenRecycler() {
   }
 }
 
+class CTokenFinder: public nsDequeFunctor{
+public:
+  CTokenFinder(CToken* aToken) {mToken=aToken;}
+  virtual void* operator()(void* anObject) {
+    if(anObject==mToken) {
+      return anObject;
+    }
+    return 0;
+  }
+  CToken* mToken;
+};
 
 /**
  * This method gets called when someone wants to recycle a token
@@ -229,6 +293,10 @@ CTokenRecycler::~CTokenRecycler() {
 void CTokenRecycler::RecycleToken(CToken* aToken) {
   if(aToken) {
     PRInt32 theType=aToken->GetTokenType();
+    CToken* theMatch=(CToken*)mTokenCache[theType-1]->FirstThat(CTokenFinder(aToken));
+    if(theMatch) {
+      int x=5;
+    }
     mTokenCache[theType-1]->Push(aToken);
   }
 }
@@ -248,7 +316,7 @@ CToken* CTokenRecycler::CreateTokenOfType(eHTMLTokenTypes aType,eHTMLTags aTag,
     result->Reinitialize(aTag,aString);
   }
   else {
-//    mTotals[aType-1]++;
+    //mTotals[aType-1]++;
     switch(aType){
       case eToken_start:      result=new CStartToken(aTag); break;
       case eToken_end:        result=new CEndToken(aTag); break;
diff --git a/parser/htmlparser/src/nsDTDUtils.h b/parser/htmlparser/src/nsDTDUtils.h
index e7260ea8932c..c5f326c466f4 100644
--- a/parser/htmlparser/src/nsDTDUtils.h
+++ b/parser/htmlparser/src/nsDTDUtils.h
@@ -28,11 +28,12 @@
 
 #include "nsHTMLTags.h"
 #include "nsHTMLTokens.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsCRT.h"
 #include "nsDeque.h"
 #include "nsIDTD.h"
 #include <fstream.h>
+#include "nsITokenizer.h"
 
 /***************************************************************
   Before digging into the NavDTD, we'll define a helper 
@@ -48,36 +49,33 @@
  ***************************************************************/
 
 void DebugDumpContainmentRules(nsIDTD& theDTD,const char* aFilename,const char* aTitle);
-
-//#define rickgdebug 1
+void DebugDumpContainmentRules2(nsIDTD& theDTD,const char* aFilename,const char* aTitle);
 
 class nsTagStack {
 public:
 
-#ifdef rickgdebug
+#ifdef NS_DEBUG
   enum {eStackSize=200};
 #else
   enum {eStackSize=30};
 #endif
+              nsTagStack(int aDefaultSize=eStackSize);
+              ~nsTagStack();
+  void        Push(eHTMLTags aTag);
+  eHTMLTags   Pop();
+  eHTMLTags   First() const;
+  eHTMLTags   TagAt(PRInt32 anIndex) const;
+  eHTMLTags   operator[](PRInt32 anIndex) const;
+  eHTMLTags   Last() const;
+  void        Empty(void); 
 
-            nsTagStack(int aDefaultSize=eStackSize);
-            ~nsTagStack();
-  void      Push(eHTMLTags aTag);
-  eHTMLTags Pop();
-  eHTMLTags First() const;
-  eHTMLTags Last() const;
-  void      Empty(void); 
-
-  nsTagStack* mPrevious;
-  int         mSize;
+  int         mCapacity;
   int         mCount;
 
-#ifndef rickgdebug
+#ifndef NS_DEBUG
   eHTMLTags*  mTags;
-  PRBool*     mBits;
 #else
   eHTMLTags   mTags[eStackSize];
-  PRBool      mBits[eStackSize];
 #endif
 };
 
@@ -93,11 +91,23 @@ class nsDTDContext {
 public:
                 nsDTDContext(int aDefaultSize=nsTagStack::eStackSize);
                 ~nsDTDContext();
-  void          pushStyleStack(nsTagStack* aStack=0);
-  nsTagStack*   popStyleStack();
+  void          Push(eHTMLTags aTag);
+  eHTMLTags     Pop();
+  eHTMLTags     First() const;
+  eHTMLTags     TagAt(PRInt32 anIndex) const;
+  eHTMLTags     operator[](PRInt32 anIndex) const;
+  eHTMLTags     Last() const;
+  void          Empty(void); 
+  PRInt32       GetCount(void);
 
-  nsTagStack    mElements;  //no need to hide these members. 
-  nsTagStack*   mStyles;    //the dtd should have direct access to them.
+  nsTagStack    mTags;
+
+#ifndef NS_DEBUG
+  nsTagStack**  mStyles;
+#else
+  nsTagStack*   mStyles[nsTagStack::eStackSize];
+#endif
+  int           mOpenStyles;
 };
 
 
@@ -132,6 +142,7 @@ public:
 
 protected:
     nsDeque*  mTokenCache[eToken_last-1];
+    // int       mTotals[eToken_last-1];
 };
 
 /************************************************************************
diff --git a/parser/htmlparser/src/nsElementTable.h b/parser/htmlparser/src/nsElementTable.h
new file mode 100644
index 000000000000..e9487bf11ff9
--- /dev/null
+++ b/parser/htmlparser/src/nsElementTable.h
@@ -0,0 +1,724 @@
+
+class CTagList {
+public:
+  CTagList( int aCount,
+            eHTMLTags aTag1=eHTMLTag_unknown,
+            eHTMLTags aTag2=eHTMLTag_unknown,
+            eHTMLTags aTag3=eHTMLTag_unknown,
+            eHTMLTags aTag4=eHTMLTag_unknown,
+            eHTMLTags aTag5=eHTMLTag_unknown,
+            eHTMLTags aTag6=eHTMLTag_unknown,
+            eHTMLTags aTag7=eHTMLTag_unknown,
+            eHTMLTags aTag8=eHTMLTag_unknown,
+            eHTMLTags aTag9=eHTMLTag_unknown,
+            eHTMLTags aTag10=eHTMLTag_unknown){
+    mCount=aCount;
+    mTags[0]=aTag1; mTags[1]=aTag2;
+    mTags[2]=aTag3; mTags[3]=aTag4;
+    mTags[4]=aTag5; mTags[5]=aTag6;
+    mTags[6]=aTag7; mTags[7]=aTag8;
+    mTags[8]=aTag9; mTags[9]=aTag10;  
+  }
+
+  PRInt32 GetTopmostIndexOf(nsTagStack& aTagStack);
+  PRBool  Contains(eHTMLTags aTag);
+
+  eHTMLTags mTags[10];
+  int       mCount;
+};
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool CTagList::Contains(eHTMLTags aTag){
+  return FindTagInSet(aTag,mTags,mCount);
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRInt32 CTagList::GetTopmostIndexOf(nsTagStack& aTagStack){
+  int max=aTagStack.mCount;
+  int index;
+  for(index=max-1;index>0;index--){
+    if(FindTagInSet(aTagStack.mTags[index],mTags,mCount)) {
+      return index;
+    }
+  }
+  return kNotFound;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+struct nsHTMLElement {
+
+  static  PRBool  IsBlockElement(eHTMLTags aChild);
+  static  PRBool  IsInlineElement(eHTMLTags aChild);
+  static  PRBool  IsBlockCloser(eHTMLTags aChild);
+
+  CTagList*       GetRootTags(void) const {return mRootNodes;}
+  CTagList*       GetAutoCloseStartTags(void) const {return mAutocloseStart;}
+  CTagList*       GetAutoCloseEndTags(void) const {return mAutocloseEnd;}
+
+  static  PRBool  IsBlockParent(eHTMLTags aChild);
+  static  PRBool  IsInlineParent(eHTMLTags aChild); 
+
+  CTagList*       GetSpecialChildren(void) const {return mSpecialKids;}
+  CTagList*       GetSpecialParents(void) const {return mSpecialParents;}
+    
+  eHTMLTags       GetTag(void) const {return mTagID;}
+  PRBool          CanContain(eHTMLTags aChild) const;
+  PRBool          CanOmitStartTag(eHTMLTags aChild) const;
+  PRBool          CanOmitEndTag(eHTMLTags aChild) const;
+  PRBool          CanSelfContain() const {return mSelfContained;}
+  PRBool          HasBits(PRInt32 aBitset) const;
+
+  static  PRBool  CanContain(eHTMLTags aParent,eHTMLTags aChild);
+  static  PRBool  IsContainer(eHTMLTags aTag) ;
+  static  PRBool  IsStyleTag(eHTMLTags aTag) ;
+  static  PRBool  IsTextTag(eHTMLTags aTag);
+
+  eHTMLTags   mTagID;
+  CTagList*   mRootNodes;         //These are the tags above which you many not autoclose
+  CTagList*   mAutocloseStart;    //these are the start tags that you can automatically close with this START tag
+  CTagList*   mAutocloseEnd;      //these are the start tags that you can automatically close with this END tag
+  int         mBits;              //defines parental and containment rules
+  CTagList*   mSpecialParents;    //These are the extra tags that can contain you
+  CTagList*   mSpecialKids;       //These are th extra things you can contain
+  PRBool      mSelfContained;
+}; 
+
+    
+/***************************************************************************** 
+  Now it's time to list all the html elements all with their capabilities...
+******************************************************************************/
+
+// id, hasblockparent, hasinlineparent,isBlockContainer,isInlineContainer
+
+//First, define the set of taglists for tags with special parents...
+CTagList  gAParents(1,eHTMLTag_map);
+CTagList  gInHead(1,eHTMLTag_head);
+CTagList  gInTable(1,eHTMLTag_table);
+CTagList  gInHTML(1,eHTMLTag_html);
+CTagList  gInBody(1,eHTMLTag_body);
+CTagList  gInForm(1,eHTMLTag_form);
+CTagList  gInTR(1,eHTMLTag_tr);
+CTagList  gInDL(1,eHTMLTag_dl);
+CTagList  gInFrameset(1,eHTMLTag_frameset);
+CTagList  gOptgroupParents(2,eHTMLTag_optgroup,eHTMLTag_select);
+CTagList  gBodyParents(2,eHTMLTag_html,eHTMLTag_noframes);
+CTagList  gColParents(2,eHTMLTag_colgroup,eHTMLTag_table);
+CTagList  gFramesetParents(2,eHTMLTag_frameset,eHTMLTag_html);
+CTagList  gLegendParents(1,eHTMLTag_fieldset);
+CTagList  gAreaParent(1,eHTMLTag_map);
+CTagList  gParamParents(2,eHTMLTag_applet,eHTMLTag_object);
+CTagList  gTRParents(4,eHTMLTag_tbody,eHTMLTag_tfoot,eHTMLTag_thead,eHTMLTag_table);
+
+//*********************************************************************************************
+//  Next, define the set of taglists for tags with special kids...
+//*********************************************************************************************
+CTagList  gContainsText(4,eHTMLTag_text,eHTMLTag_newline,eHTMLTag_whitespace,eHTMLTag_entity);
+CTagList  gContainsHTML(1,eHTMLTag_html);
+CTagList  gContainsOpts(2,eHTMLTag_option,eHTMLTag_optgroup);
+CTagList  gContainsParam(1,eHTMLTag_param);
+CTagList  gColgroupKids(1,eHTMLTag_col); 
+CTagList  gBodyKids(2,eHTMLTag_noscript,eHTMLTag_script);
+CTagList  gButtonKids(2,eHTMLTag_caption,eHTMLTag_legend);
+CTagList  gDLKids(2,eHTMLTag_dd,eHTMLTag_dt);
+CTagList  gDTKids(1,eHTMLTag_dt);
+CTagList  gFieldsetKids(1,eHTMLTag_legend);
+CTagList  gFormKids(1,eHTMLTag_keygen);
+CTagList  gFramesetKids(3,eHTMLTag_frame,eHTMLTag_frameset,eHTMLTag_noframes);
+CTagList  gHtmlKids(5,eHTMLTag_body,eHTMLTag_frameset,eHTMLTag_head,eHTMLTag_noscript,eHTMLTag_script);
+CTagList  gHeadKids(7,eHTMLTag_base,eHTMLTag_bgsound,eHTMLTag_link,eHTMLTag_meta,eHTMLTag_script,eHTMLTag_style,eHTMLTag_title);
+CTagList  gMapKids(1,eHTMLTag_area);
+CTagList  gNoframesKids(1,eHTMLTag_body);
+CTagList  gPreKids(1,eHTMLTag_hr);
+CTagList  gTableKids(9,eHTMLTag_caption,eHTMLTag_col,eHTMLTag_colgroup,eHTMLTag_form,eHTMLTag_map,eHTMLTag_thead,eHTMLTag_tbody,eHTMLTag_tfoot,eHTMLTag_script);
+CTagList  gTableElemKids(7,eHTMLTag_form,eHTMLTag_map,eHTMLTag_noscript,eHTMLTag_script,eHTMLTag_td,eHTMLTag_th,eHTMLTag_tr);
+CTagList  gTBodyKids(1,eHTMLTag_tr);
+CTagList  gTRKids(6,eHTMLTag_form,eHTMLTag_map,eHTMLTag_noscript,eHTMLTag_script,eHTMLTag_td,eHTMLTag_th);
+CTagList  gULKids(2,eHTMLTag_li,eHTMLTag_p);
+
+//*********************************************************************************************
+// The following tag lists are used to define common set of root notes for the HTML elements...
+//*********************************************************************************************
+CTagList  gRootTags(2,eHTMLTag_body,eHTMLTag_td);
+CTagList  gHTMLRootTags(1,eHTMLTag_unknown);
+CTagList  gLIRootTags(7,eHTMLTag_ul,eHTMLTag_ol,eHTMLTag_dir,eHTMLTag_menu,eHTMLTag_p,eHTMLTag_body,eHTMLTag_td);
+CTagList  gTextRootTags(2,eHTMLTag_p,eHTMLTag_body);
+CTagList  gTDRootTags(3,eHTMLTag_tr,eHTMLTag_tbody,eHTMLTag_table);
+CTagList  gOptionRootTags(1,eHTMLTag_select);
+
+
+//*********************************************************************************************
+// The following tag lists are used to define the autoclose properties of the html elements...
+//*********************************************************************************************
+CTagList  gAutoClose(2,eHTMLTag_body,eHTMLTag_td);
+CTagList  gBodyAutoClose(1,eHTMLTag_head);
+CTagList  gCaptionAutoClose(1,eHTMLTag_tbody);
+CTagList  gLIAutoClose(2,eHTMLTag_p,eHTMLTag_li);
+CTagList  gPAutoClose(2,eHTMLTag_p,eHTMLTag_li);
+CTagList  gHxAutoClose(6,eHTMLTag_h1,eHTMLTag_h2,eHTMLTag_h3,eHTMLTag_h4,eHTMLTag_h5,eHTMLTag_h6);
+CTagList  gTRCloseTags(2,eHTMLTag_td,eHTMLTag_th);
+CTagList  gTDCloseTags(2,eHTMLTag_td,eHTMLTag_th);
+CTagList  gDTCloseTags(2,eHTMLTag_dt,eHTMLTag_dd);
+
+ 
+static const int kNone= 0x0;
+static const int kBP  = 0x1;  //has block parent
+static const int kIP  = 0x2;  //has inline parent
+static const int kCB  = 0x4;  //can close blocks (even if it's not a block elements)
+static const int kBC  = 0x8;  //contains block child
+static const int kIC  = 0x10;  //contains inline child
+
+static const int kBPIP   = (kBP | kIP);
+static const int kBPIPIC = (kBP | kIP | kIC);
+static const int kBPBCIC = (kBP | kBC | kIC);
+static const int kBCIC   = (kBC | kIC);
+static const int kAll    = (kBPIP | kBCIC);
+
+
+//*********************************************************************************************
+//Lastly, bind tags with their rules, their special parents and special kids.
+//*********************************************************************************************
+
+static nsHTMLElement gHTMLElements[] = {
+
+  //                                                               
+  //                      Root          Autoclose-    Autoclose-      Container     Special       Special
+  //    tag-id            Nodes         starttags     endtags         -rules        Parents       Kids
+
+  {eHTMLTag_unknown,    &gRootTags,    0,              0,              kNone,        0,            &gContainsHTML},
+  {eHTMLTag_a,          &gRootTags,    0,              0,              kBPIPIC,     &gAParents,   0},
+  {eHTMLTag_abbr,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_acronym,    &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_address,    &gRootTags,    0,              0,              kBP|kIC},
+  {eHTMLTag_applet,     &gRootTags,    0,              0,              kAll,         0,            &gContainsParam},
+  {eHTMLTag_area,       &gAreaParent,  &gAutoClose,    0,              kNone},
+  
+  {eHTMLTag_b,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_base,       &gInHead,      0,              0,              kNone,        &gInHead,     0},
+  {eHTMLTag_basefont,   &gRootTags,    0,              0,              kBP},
+  {eHTMLTag_bdo,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_bgsound,    &gRootTags,    0,              0,              kBPIP,        &gInHead,     0},
+  {eHTMLTag_big,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_blink,      &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_blockquote, &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_body,       &gInHTML,      &gBodyAutoClose,0,              kBCIC|kCB,    &gBodyParents,&gBodyKids},
+  {eHTMLTag_br,         &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_button,     &gRootTags,    0,              0,              kAll,         0,            &gButtonKids},
+
+  {eHTMLTag_caption,    &gRootTags,    &gCaptionAutoClose,  0,         kIC|kCB,      &gInTable,    0},
+  {eHTMLTag_center,     &gRootTags,    0,              0,              kAll},
+  {eHTMLTag_cite,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_code,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_col,        &gColParents,  0,              0,              kNone,        &gColParents, 0},
+  {eHTMLTag_colgroup,   &gRootTags,    0,              0,              kNone,        0,            &gColgroupKids},  
+
+  {eHTMLTag_dd,         &gInDL,        &gDTCloseTags,  0,              kBCIC|kCB,    &gInDL,       0},
+  {eHTMLTag_del,        &gRootTags,    0,              0,              kAll,         0,0},
+  {eHTMLTag_dfn,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_dir,        &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_div,        &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_dl,         &gRootTags,    0,              0,              kBP|kIC,      0,            &gDLKids},
+  {eHTMLTag_dt,         &gInDL,        &gDTCloseTags,  0,              kIC|kCB,      &gInDL,       &gDTKids},
+
+  {eHTMLTag_em,         &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_embed,      &gRootTags,    0,              0,              kAll,         0,            &gContainsParam},
+
+  {eHTMLTag_fieldset,   &gRootTags,    0,              0,              kBPBCIC,   0,            &gFieldsetKids},
+  {eHTMLTag_font,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_form,       &gRootTags,    0,              0,              kAll,         0,            &gFormKids},
+  {eHTMLTag_frame,      &gInFrameset,  0,              0,              kNone,        &gInFrameset, 0},
+  {eHTMLTag_frameset,   &gInHTML,      0,              0,              kNone,        &gFramesetParents,  &gFramesetKids},
+
+  {eHTMLTag_h1,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h2,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h3,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h4,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h5,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_h6,         &gRootTags,    &gHxAutoClose,  &gHxAutoClose,  kBPBCIC},
+  {eHTMLTag_head,       &gInHTML,      0,              0,              kNone,        &gInHTML,     &gHeadKids},
+  {eHTMLTag_hr,         &gRootTags,    0,              0,              kBP},
+  {eHTMLTag_html,       &gHTMLRootTags,&gAutoClose,    0,              kNone,        0,            &gHtmlKids},
+  
+  {eHTMLTag_i,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_iframe,     &gRootTags,    0,              0,              kAll},
+  {eHTMLTag_ilayer,     &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_img,        &gRootTags,    0,              0,              kBPIP},  
+  {eHTMLTag_input,      &gRootTags,    0,              0,              kBPIP},  //NOT DONE!!!
+  {eHTMLTag_ins,        &gRootTags,    0,              0,              kAll,         &gInBody,     0},
+  {eHTMLTag_isindex,    &gRootTags,    0,              0,              kBP,          &gInHead,     0},
+
+  {eHTMLTag_kbd,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_keygen,     &gRootTags,    0,              0,              kNone,        &gInForm,     0},
+
+  {eHTMLTag_label,      &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_layer,      &gRootTags,    0,              0,              kAll},
+  {eHTMLTag_legend,     &gRootTags,    0,              0,              kIC,          &gLegendParents,0},
+  {eHTMLTag_li,         &gLIRootTags,  &gLIAutoClose,   0,             kAll},
+  {eHTMLTag_link,       &gInHead,      0,              0,              kNone,        &gInHead,     0},
+  {eHTMLTag_listing,    &gRootTags,    0,              0,              kAll}, 
+
+  {eHTMLTag_map,        &gRootTags,    0,              0,              kBPIP,        0,            &gMapKids},
+  {eHTMLTag_menu,       &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_meta,       &gInHead,      0,              0,              kNone,        &gInHead,     0},
+  {eHTMLTag_multicol,   &gRootTags,    0,              0,              kBPBCIC},
+
+  {eHTMLTag_nobr,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_noembed,    &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_noframes,   &gRootTags,    0,              0,              kBPBCIC,  &gInFrameset, &gNoframesKids},
+  {eHTMLTag_nolayer,    &gRootTags,    0,              0,              kBPBCIC},
+  {eHTMLTag_noscript,   &gRootTags,    0,              0,              kBPBCIC},
+  
+  {eHTMLTag_object,     &gRootTags,    0,              0,              kAll,         0,            &gContainsParam},
+  {eHTMLTag_ol,         &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_optgroup,   &gRootTags,    0,              0,              kNone, &gOptgroupParents,   &gContainsOpts},
+  {eHTMLTag_option,     &gOptionRootTags,0,              0,            kNone, &gOptgroupParents,   &gContainsText},
+
+  //                                                               
+  //                      Root          Autoclose-    Autoclose-      Container     Special       Special
+  //    tag-id            Nodes         starttags     endtags         -rules        Parent        Kids
+
+  {eHTMLTag_p,          &gRootTags,    &gPAutoClose,   0,              kBPBCIC},
+  {eHTMLTag_param,      &gParamParents,0,              0,              kNone,    &gParamParents,   0},
+  {eHTMLTag_plaintext,  &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_pre,        &gRootTags,    0,              0,              kBP|kIC,   0,  &gPreKids},
+  {eHTMLTag_q,          &gRootTags,    0,              0,              kBPIPIC}, 
+
+  {eHTMLTag_s,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_samp,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_script,     &gRootTags,    0,              0,              kBPIP,        &gInHead,     &gContainsText},
+  {eHTMLTag_select,     &gInForm,      0,              0,              kBPIP,        0,            &gContainsOpts},
+  {eHTMLTag_server,     &gRootTags,    0,              0,              kNone},
+  {eHTMLTag_small,      &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_sound,      &gRootTags,    0,              0,              kBPIP,        &gInHead,     0},
+  {eHTMLTag_spacer,     &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_span,       &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_strike,     &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_strong,     &gRootTags,    0,              0,              kBPIPIC,      &gInHead,     &gContainsText},
+  {eHTMLTag_style,      &gInHead,      0,              0,              kNone,        &gInHead},
+  {eHTMLTag_sub,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_sup,        &gRootTags,    0,              0,              kBPIPIC},
+
+  {eHTMLTag_table,      &gRootTags,    0,              0,              kBP,          0,            &gTableKids},
+  {eHTMLTag_tbody,      &gInTable,     0,              0,              kNone,        &gInTable,    &gTBodyKids},
+  {eHTMLTag_td,         &gTDRootTags,  &gTDCloseTags,  0,              kBCIC|kCB,    &gInTR,       0},
+  {eHTMLTag_textarea,   &gInForm,      0,              0,              kBPIP,        0,            &gContainsText},
+  {eHTMLTag_tfoot,      &gInTable,     0,              0,              kCB,          &gInTable,    &gTableElemKids},
+  {eHTMLTag_th,         &gTDRootTags,  0,              0,              kBCIC|kCB,    &gInTR,       0},
+  {eHTMLTag_thead,      &gInTable,     0,              0,              kCB,          &gInTable,    &gTableElemKids},
+  {eHTMLTag_title,      &gInHead,      0,              0,              kNone,        &gInHead,     &gContainsText},
+  {eHTMLTag_tr,         &gTRParents,   &gTRCloseTags,  0,              kCB,          &gTRParents,  &gTRKids},
+  {eHTMLTag_tt,         &gRootTags,    0,              0,              kBPIPIC},
+
+  {eHTMLTag_u,          &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_ul,         &gRootTags,    0,              0,              kAll,         0,            &gULKids},
+  {eHTMLTag_var,        &gRootTags,    0,              0,              kBPIPIC},
+  {eHTMLTag_wbr,        &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_xmp,        &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_text,       &gTextRootTags,0,             0,              kBPIP},
+  {eHTMLTag_whitespace, &gTextRootTags,0,              0,              kBPIP},
+  {eHTMLTag_newline,    &gTextRootTags,0,              0,              kBPIP},
+  {eHTMLTag_comment,    &gRootTags,    0,              0,              kBPIP},
+  {eHTMLTag_entity,     &gTextRootTags,0,              0,              kBPIP},
+  {eHTMLTag_userdefined,&gRootTags,    0,              0,              kBPIP},
+};
+
+/**
+ * This class is here to finalize the initialization of the
+ * nsHTMLElement table.
+ */
+class CTableInitializer {
+public:
+  CTableInitializer(){
+    int index=0;
+    for(index=0;index<eHTMLTag_userdefined;index++){
+      gHTMLElements[index].mSelfContained=PR_FALSE;
+      //gHTMLElements[index].mBits&=kTC;
+    }
+
+    //now initalize tags that can contain themselves...
+    int max=sizeof(gStyleTags)/sizeof(eHTMLTag_unknown);
+    for(index=0;index<max;index++){
+      gHTMLElements[gStyleTags[index]].mSelfContained=PR_TRUE;
+    }
+    gHTMLElements[eHTMLTag_frameset].mSelfContained=PR_TRUE;
+  }
+};
+CTableInitializer gTableInitializer;
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsContainer(eHTMLTags aChild) {
+  PRBool result=PR_FALSE;
+
+  if((eHTMLTag_userdefined==aChild) || (eHTMLTag_unknown==aChild))
+    result=PR_TRUE;
+  else if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    if((gHTMLElements[aChild].HasBits(kBC))  ||
+       (gHTMLElements[aChild].HasBits(kIC)) || 
+       (gHTMLElements[aChild].mSpecialKids)) {
+      result=PR_TRUE;
+    }
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsBlockElement(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kBP);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsBlockCloser(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kCB|kBP);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsInlineElement(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kIP);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsBlockParent(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kBC);
+  } 
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsInlineParent(eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aChild>=eHTMLTag_unknown) & (aChild<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].HasBits(kIC);
+  } 
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanContain(eHTMLTags aParent,eHTMLTags aChild){
+  PRBool result=PR_FALSE;
+  if((aParent>=eHTMLTag_unknown) & (aParent<=eHTMLTag_userdefined)){
+    result=gHTMLElements[aChild].CanContain(aChild);
+  } 
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanOmitEndTag(eHTMLTags aChild) const{
+  PRBool result=PR_FALSE;
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanOmitStartTag(eHTMLTags aChild) const{
+  PRBool result=PR_FALSE;
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/17/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::HasBits(PRInt32 aBitset) const{
+  PRBool result=(mBits & aBitset);
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsStyleTag(eHTMLTags aChild) {
+  PRBool result=FindTagInSet(aChild,gStyleTags,sizeof(gStyleTags)/sizeof(eHTMLTag_body));
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::IsTextTag(eHTMLTags aChild) {
+  static eHTMLTags gTextTags[]={eHTMLTag_text,eHTMLTag_entity,eHTMLTag_newline, eHTMLTag_whitespace};
+  PRBool result=FindTagInSet(aChild,gTextTags,sizeof(gTextTags)/sizeof(eHTMLTag_body));
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/13/98
+ * @param 
+ * @return
+ */
+PRBool nsHTMLElement::CanContain(eHTMLTags aChild) const{
+
+  if(IsContainer(mTagID)){
+
+    if(mTagID==aChild) {
+      return mSelfContained;  //not many tags can contain themselves...
+    }
+
+    if(nsHTMLElement::IsInlineElement(aChild)){
+      if(nsHTMLElement::IsInlineParent(mTagID)){
+        return PR_TRUE;
+      }
+    }
+
+    if(nsHTMLElement::IsTextTag(aChild)) {
+      if(nsHTMLElement::IsInlineParent(mTagID)){
+        return PR_TRUE;
+      }
+    }
+
+    if(nsHTMLElement::IsBlockElement(aChild)){
+      if(nsHTMLElement::IsBlockParent(mTagID) || IsStyleTag(mTagID)){
+        return PR_TRUE;
+      }
+    }
+
+    if(mSpecialKids) {
+      if(FindTagInSet(aChild,mSpecialKids->mTags,mSpecialKids->mCount)){
+        return PR_TRUE;
+      }
+    }
+
+    if(mTagID!=eHTMLTag_server){
+      int x=5;
+    }
+  }
+  
+  return PR_FALSE;
+}
+
+/**
+ * This method figures out what kind of child tag 
+ * you're looking at. For now, it's kind of an 
+ * expensive lookup. Later, I'll OPT-O-MIZE it.
+ * @update  gess4/6/98
+ * @param   aChildTag is who you're trying to figure out
+ * @return  eHTMLChildType value
+ */
+eHTMLCategory GetParentModelFor(eHTMLTags aChildTag) {
+  eHTMLCategory result=eHTMLCategory_unknown;
+
+  PRBool blockChild=nsHTMLElement::IsBlockElement(aChildTag);
+  PRBool inlineChild=nsHTMLElement::IsInlineElement(aChildTag);
+
+  if(blockChild & inlineChild)
+    return eHTMLCategory_blockAndInline;
+  else if(blockChild)
+    return eHTMLCategory_block;
+  else if(inlineChild)
+    return eHTMLCategory_inline;
+  else if(gHTMLElements[aChildTag].mSpecialParents==&gInHead)
+    return eHTMLCategory_head;
+  else if(gHTMLElements[aChildTag].mSpecialParents==&gInForm)
+    return eHTMLCategory_form;
+  else if(gHTMLElements[aChildTag].mSpecialParents==&gInTable)
+    return eHTMLCategory_table;
+
+  else {
+    switch(aChildTag){
+      case eHTMLTag_li:
+        result=eHTMLCategory_list;
+        break;
+      case eHTMLTag_html:
+        result=eHTMLCategory_unknown;
+        break;
+      case eHTMLTag_head:
+      case eHTMLTag_body:
+      case eHTMLTag_unknown:
+        result=eHTMLCategory_html;
+        break;
+      case eHTMLTag_tbody:
+      case eHTMLTag_thead:
+      case eHTMLTag_tfoot:
+        result=eHTMLCategory_tablepart;
+        break;
+      case eHTMLTag_tr:
+        result=eHTMLCategory_tablerow;
+        break;
+      case eHTMLTag_td:
+      case eHTMLTag_th:
+        result=eHTMLCategory_tabledata;
+        break;
+      case eHTMLTag_option:
+      case eHTMLTag_optgroup:
+        result=eHTMLCategory_options;
+        break;
+      case eHTMLTag_legend:
+        result=eHTMLCategory_text;
+        break;
+      case eHTMLTag_frameset:
+        result=eHTMLCategory_frameset;
+        break;
+      default:
+        NS_ERROR("Oops");
+        break;
+    } //switch
+  } //else
+
+  return result;
+}
+
+/**
+ * This method figures out what kind of parent tag 
+ * you're looking at. For now, it's kind of an 
+ * expensive lookup. Later, I'll OPT-O-MIZE it.
+ * @update  gess4/6/98
+ * @param   aParentTag is who you're trying to figure out
+ * @return  eHTMLChildType value
+ */
+eHTMLCategory GetContentModelFor(eHTMLTags aTag) {
+  eHTMLCategory result=eHTMLCategory_unknown;
+
+  PRBool blockParent=nsHTMLElement::IsBlockParent(aTag);
+  PRBool inlineParent=nsHTMLElement::IsInlineParent(aTag);
+
+  if(blockParent & inlineParent) { 
+    return eHTMLCategory_blockAndInline;
+  }
+  else if(blockParent) {
+    return eHTMLCategory_block;
+  }
+  else if(inlineParent) {
+    return eHTMLCategory_inline;
+  }
+  else if(gHTMLElements[aTag].mSpecialParents==&gInTable) {
+    return eHTMLCategory_table;
+  }
+  else if((aTag==eHTMLTag_ol) || (aTag==eHTMLTag_ol)) {
+    result=eHTMLCategory_list;
+  }
+  else {
+    switch(aTag){
+      case eHTMLTag_li:
+        result=eHTMLCategory_list;
+        break;
+      case eHTMLTag_html:
+      case eHTMLTag_body:
+        result=eHTMLCategory_html;
+        break;
+      case eHTMLTag_head:
+        result=eHTMLCategory_head;
+        break;
+      case eHTMLTag_unknown:
+        result=eHTMLCategory_unknown;
+        break;
+      case eHTMLTag_tbody:
+      case eHTMLTag_thead:
+      case eHTMLTag_tfoot:
+        result=eHTMLCategory_tablepart;
+        break;
+      case eHTMLTag_tr:
+        result=eHTMLCategory_tablerow;
+        break;
+      case eHTMLTag_td:
+      case eHTMLTag_th:
+        result=eHTMLCategory_tabledata;
+        break;
+      case eHTMLTag_table:
+        result=eHTMLCategory_table;
+        break;
+      case eHTMLTag_select:
+        result=eHTMLCategory_options;
+        break;
+      case eHTMLTag_frameset:
+        result=eHTMLCategory_frameset;
+        break;
+      default:
+        if(!(blockParent || inlineParent)) {
+          if(gHTMLElements[aTag].mSpecialKids==&gContainsText)
+            return eHTMLCategory_text;
+        }
+        NS_ERROR("Oops");
+        break;
+    } //switch
+  } //else
+  return result;
+}
diff --git a/parser/htmlparser/src/nsHTMLContentSinkStream.cpp b/parser/htmlparser/src/nsHTMLContentSinkStream.cpp
index 8f9cc6805aa0..dcf4549bd6e6 100644
--- a/parser/htmlparser/src/nsHTMLContentSinkStream.cpp
+++ b/parser/htmlparser/src/nsHTMLContentSinkStream.cpp
@@ -32,7 +32,7 @@
 #include "nsHTMLTokens.h"
 #include <iostream.h>
 #include "nsString.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
 static NS_DEFINE_IID(kIContentSinkIID, NS_ICONTENT_SINK_IID);
diff --git a/parser/htmlparser/src/nsHTMLNullSink.cpp b/parser/htmlparser/src/nsHTMLNullSink.cpp
index 1d9806e62cc4..2a1d3894b188 100644
--- a/parser/htmlparser/src/nsHTMLNullSink.cpp
+++ b/parser/htmlparser/src/nsHTMLNullSink.cpp
@@ -18,7 +18,7 @@
  */
 #include "nsIHTMLContentSink.h"
 #include "nsHTMLTokens.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "prtypes.h" 
 #include <iostream.h>  
 
diff --git a/parser/htmlparser/src/nsHTMLTokenizer.cpp b/parser/htmlparser/src/nsHTMLTokenizer.cpp
new file mode 100644
index 000000000000..f653624323c8
--- /dev/null
+++ b/parser/htmlparser/src/nsHTMLTokenizer.cpp
@@ -0,0 +1,665 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#include "nsHTMLTokenizer.h"
+#include "nsParser.h"
+#include "nsScanner.h"
+#include "nsDTDUtils.h"
+
+/************************************************************************
+  And now for the main class -- nsHTMLTokenizer...
+ ************************************************************************/
+
+static NS_DEFINE_IID(kISupportsIID,   NS_ISUPPORTS_IID);                 
+static NS_DEFINE_IID(kITokenizerIID,  NS_ITOKENIZER_IID);
+static NS_DEFINE_IID(kClassIID,       NS_HTMLTOKENIZER_IID); 
+static CTokenDeallocator gTokenKiller;
+static CTokenRecycler gTokenRecycler;
+static nsAutoString gEmpty;
+
+/**
+ *  This method gets called as part of our COM-like interfaces.
+ *  Its purpose is to create an interface to parser object
+ *  of some type.
+ *  
+ *  @update   gess 4/8/98
+ *  @param    nsIID  id of object to discover
+ *  @param    aInstancePtr ptr to newly discovered interface
+ *  @return   NS_xxx result code
+ */
+nsresult nsHTMLTokenizer::QueryInterface(const nsIID& aIID, void** aInstancePtr)  
+{                                                                        
+  if (NULL == aInstancePtr) {                                            
+    return NS_ERROR_NULL_POINTER;                                        
+  }                                                                      
+
+  if(aIID.Equals(kISupportsIID))    {  //do IUnknown...
+    *aInstancePtr = (nsIDTD*)(this);                                        
+  }
+  else if(aIID.Equals(kITokenizerIID)) {  //do IParser base class...
+    *aInstancePtr = (nsIDTD*)(this);                                        
+  }
+  else if(aIID.Equals(kClassIID)) {  //do this class...
+    *aInstancePtr = (nsHTMLTokenizer*)(this);                                        
+  }                 
+  else {
+    *aInstancePtr=0;
+    return NS_NOINTERFACE;
+  }
+  NS_ADDREF_THIS();
+  return NS_OK;                                                        
+}
+
+
+/**
+ *  This method is defined in nsIParser. It is used to 
+ *  cause the COM-like construction of an nsParser.
+ *  
+ *  @update  gess 4/8/98
+ *  @param   nsIParser** ptr to newly instantiated parser
+ *  @return  NS_xxx error result
+ */
+NS_HTMLPARS nsresult NS_NewHTMLTokenizer(nsIDTD** aInstancePtrResult) {
+  nsHTMLTokenizer* it = new nsHTMLTokenizer();
+
+  if (it == 0) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return it->QueryInterface(kClassIID, (void **) aInstancePtrResult);
+}
+
+
+NS_IMPL_ADDREF(nsHTMLTokenizer)
+NS_IMPL_RELEASE(nsHTMLTokenizer)
+
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsHTMLTokenizer::nsHTMLTokenizer() : nsITokenizer(), mTokenDeque(gTokenKiller) {
+  NS_INIT_REFCNT();
+  mDoXMLEmptyTags=PR_FALSE;
+}
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsHTMLTokenizer::~nsHTMLTokenizer(){
+}
+
+
+/*******************************************************************
+  Here begins the real working methods for the tokenizer.
+ *******************************************************************/
+
+void AddToken(CToken*& aToken,nsresult aResult,nsDeque& aDeque) {
+  if(aToken) {
+    if(NS_SUCCEEDED(aResult)) {
+      aDeque.Push(aToken);
+    }
+    else {
+      delete aToken; 
+      aToken=0;
+    }
+  }
+}
+
+/**
+ * Retrieve a ptr to the global token recycler...
+ * @update	gess8/4/98
+ * @return  ptr to recycler (or null)
+ */
+nsITokenRecycler* nsHTMLTokenizer::GetTokenRecycler(void) {
+  return &gTokenRecycler;
+}
+
+
+/**
+ * This method provides access to the topmost token in the tokenDeque.
+ * The token is not really removed from the list.
+ * @update	gess8/2/98
+ * @return  ptr to token
+ */
+CToken* nsHTMLTokenizer::PeekToken() {
+  return (CToken*)mTokenDeque.Peek();
+}
+
+
+/**
+ * This method provides access to the topmost token in the tokenDeque.
+ * The token is really removed from the list; if the list is empty we return 0.
+ * @update	gess8/2/98
+ * @return  ptr to token or NULL
+ */
+CToken* nsHTMLTokenizer::PopToken() {
+  return (CToken*)mTokenDeque.PopFront();
+}
+
+
+/**
+ * 
+ * @update	gess8/2/98
+ * @param 
+ * @return
+ */
+CToken* nsHTMLTokenizer::PushTokenFront(CToken* theToken) {
+  mTokenDeque.PushFront(theToken);
+	return theToken;
+}
+
+/**
+ * 
+ * @update	gess8/2/98
+ * @param 
+ * @return
+ */
+CToken* nsHTMLTokenizer::PushToken(CToken* theToken) {
+  mTokenDeque.Push(theToken);
+	return theToken;
+}
+
+/**
+ * 
+ * @update	gess12/29/98
+ * @param 
+ * @return
+ */
+PRInt32 nsHTMLTokenizer::GetCount(void) {
+  return mTokenDeque.GetSize();
+}
+
+/**
+ *  This method repeatedly called by the tokenizer. 
+ *  Each time, we determine the kind of token were about to 
+ *  read, and then we call the appropriate method to handle
+ *  that token type.
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeToken(nsScanner& aScanner) {
+
+  nsresult result=NS_OK;
+  if(NS_OK==result){
+    PRUnichar theChar;
+    result=aScanner.GetChar(theChar);
+    CToken* theToken=0;
+    switch(result) {
+      case kEOF:
+          //We convert from eof to complete here, because we never really tried to get data.
+          //All we did was try to see if data was available, which it wasn't.
+          //It's important to return process complete, so that controlling logic can know that
+          //everything went well, but we're done with token processing.
+        break;
+
+      case NS_OK:
+      default:
+        switch(theChar) {
+          case kLessThan:
+            result=ConsumeTag(theChar,theToken,aScanner);
+            break;
+
+          case kAmpersand:
+            result=ConsumeEntity(theChar,theToken,aScanner);
+            break;
+          
+          case kCR: case kLF:
+            result=ConsumeNewline(theChar,theToken,aScanner);
+            break;
+          
+          case kNotFound:
+            break;
+          
+          default:
+            if(!nsString::IsSpace(theChar)) {
+              nsAutoString temp(theChar);
+              result=ConsumeText(temp,theToken,aScanner);
+              break;
+            }
+            result=ConsumeWhitespace(theChar,theToken,aScanner);
+            break;
+        } //switch
+        break; 
+    } //switch
+  } //if
+  return result;
+}
+
+
+/**
+ *  This method is called just after a "<" has been consumed 
+ *  and we know we're at the start of some kind of tagged 
+ *  element. We don't know yet if it's a tag or a comment.
+ *  
+ *  @update  gess 5/12/98
+ *  @param   aChar is the last char read
+ *  @param   aScanner is represents our input source
+ *  @param   aToken is the out arg holding our new token
+ *  @return  error code.
+ */
+nsresult nsHTMLTokenizer::ConsumeTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+
+  nsresult result=aScanner.GetChar(aChar);
+
+  if(NS_OK==result) {
+
+    switch(aChar) {
+      case kForwardSlash:
+        PRUnichar ch; 
+        result=aScanner.Peek(ch);
+        if(NS_OK==result) {
+          if(nsString::IsAlpha(ch)) {
+            result=ConsumeEndTag(aChar,aToken,aScanner);
+          }
+          else result=ConsumeComment(aChar,aToken,aScanner);
+        }//if
+        break;
+
+      case kExclamation:
+        result=ConsumeComment(aChar,aToken,aScanner);
+        break;
+
+      case kQuestionMark: //it must be an XML processing instruction...
+        result=ConsumeProcessingInstruction(aChar,aToken,aScanner);
+        break;
+
+      default:
+        if(nsString::IsAlpha(aChar))
+          result=ConsumeStartTag(aChar,aToken,aScanner);
+        else if(kEOF!=aChar) {
+          nsAutoString temp("<");
+          result=ConsumeText(temp,aToken,aScanner);
+        }
+    } //switch
+
+  } //if
+  return result;
+}
+
+/**
+ *  This method is called just after we've consumed a start
+ *  tag, and we now have to consume its attributes.
+ *  
+ *  @update  gess 3/25/98
+ *  @param   aChar: last char read
+ *  @param   aScanner: see nsScanner.h
+ *  @return  
+ */
+nsresult nsHTMLTokenizer::ConsumeAttributes(PRUnichar aChar,CStartToken* aToken,nsScanner& aScanner) {
+  PRBool done=PR_FALSE;
+  nsresult result=NS_OK;
+  PRInt16 theAttrCount=0;
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+
+  while((!done) && (result==NS_OK)) {
+    CToken* theToken= (CAttributeToken*)theRecycler->CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
+    if(theToken){
+      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+ 
+      //Much as I hate to do this, here's some special case code.
+      //This handles the case of empty-tags in XML. Our last
+      //attribute token will come through with a text value of ""
+      //and a textkey of "/". We should destroy it, and tell the 
+      //start token it was empty.
+      if(NS_SUCCEEDED(result)) {
+        nsString& key=((CAttributeToken*)theToken)->GetKey();
+        nsString& text=theToken->GetStringValueXXX();
+        if((mDoXMLEmptyTags) && (key[0]==kForwardSlash) && (0==text.Length())){
+          //tada! our special case! Treat it like an empty start tag...
+          aToken->SetEmpty(PR_TRUE);
+          theRecycler->RecycleToken(theToken);
+        }
+        else {
+          theAttrCount++;
+          AddToken(theToken,result,mTokenDeque);
+        }
+      }
+    }//if
+    
+    if(NS_SUCCEEDED(result)){
+      result=aScanner.Peek(aChar);
+      if(aChar==kGreaterThan) { //you just ate the '>'
+        aScanner.GetChar(aChar); //skip the '>'
+        done=PR_TRUE;
+      }//if
+    }//if
+  }//while
+
+  aToken->SetAttributeCount(theAttrCount);
+  return result;
+}
+
+/**
+ *  This is a special case method. It's job is to consume 
+ *  all of the given tag up to an including the end tag.
+ *
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null
+ */
+nsresult nsHTMLTokenizer::ConsumeContentToEndTag(PRUnichar aChar,
+                                eHTMLTags aChildTag,
+                                nsScanner& aScanner,
+                                CToken*& aToken){
+  
+  //In the case that we just read the given tag, we should go and
+  //consume all the input until we find a matching end tag.
+
+  nsAutoString endTag("</");
+  endTag.Append(NS_EnumToTag(aChildTag));
+  endTag.Append(">");
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_skippedcontent,aChildTag,endTag);
+  return aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+}
+
+/**
+ *  This method is called just after a "<" has been consumed 
+ *  and we know we're at the start of a tag.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+
+static eHTMLTags gSkippedContentTags[]=
+  { eHTMLTag_noscript,
+    eHTMLTag_plaintext, eHTMLTag_script,   eHTMLTag_style, 
+    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
+
+static eHTMLTags gSkippedContentTargets[]=
+  { eHTMLTag_noscript,
+    eHTMLTag_html,      eHTMLTag_script,   eHTMLTag_style, 
+    eHTMLTag_title,     eHTMLTag_textarea, eHTMLTag_xmp};
+
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsHTMLTokenizer::HandleSkippedContent(nsScanner& aScanner,CToken*& aToken) {
+  nsresult result=NS_OK;
+
+  eHTMLTags theTag=(eHTMLTags)aToken->GetTypeID();
+  PRInt32 theIndex=IndexOfTagInSet(theTag,gSkippedContentTags,sizeof(gSkippedContentTags)/sizeof(eHTMLTag_unknown));
+  if(-1<theIndex) {
+
+      //Do special case handling for <script>, <style>, <title> or <textarea>...
+    CToken*   skippedToken=0;
+    PRUnichar theChar;
+    result=ConsumeContentToEndTag(theChar,gSkippedContentTargets[theIndex],aScanner,skippedToken);
+
+    if((NS_OK==result) && skippedToken){
+      AddToken(skippedToken,result,mTokenDeque);
+
+      //In the case that we just read a given tag, we should go and
+      //consume all the tag content itself (and throw it all away).
+
+      CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+      nsString& theTagStr=skippedToken->GetStringValueXXX();
+      CToken* endtoken=theRecycler->CreateTokenOfType(eToken_end,theTag,theTagStr);
+      if(endtoken){
+        endtoken->Reinitialize(theTag,theTagStr);
+        AddToken(endtoken,result,mTokenDeque);
+      }
+    } //if
+  } //if
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsHTMLTokenizer::ConsumeStartTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+  PRInt32 theDequeSize=mTokenDeque.GetSize(); //remember this for later in case you have to unwind...
+  nsresult result=NS_OK;
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
+  
+  if(aToken) {
+    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+    if(NS_SUCCEEDED(result)) {
+     
+      AddToken(aToken,result,mTokenDeque);
+      eHTMLTags theTag=(eHTMLTags)aToken->GetTypeID();
+      
+      if(((CStartToken*)aToken)->IsAttributed()) {
+        result=ConsumeAttributes(aChar,(CStartToken*)aToken,aScanner);
+      }
+
+      //now that that's over with, we have one more problem to solve.
+      //In the case that we just read a <SCRIPT> or <STYLE> tags, we should go and
+      //consume all the content itself.
+      if(NS_SUCCEEDED(result)) {
+        result=HandleSkippedContent(aScanner,aToken);
+      }
+ 
+      //EEEEECCCCKKKK!!! 
+      //This code is confusing, so pay attention.
+      //If you're here, it's because we were in the midst of consuming a start
+      //tag but ran out of data (not in the stream, but in this *part* of the stream.
+      //For simplicity, we have to unwind our input. Therefore, we pop and discard
+      //any new tokens we've cued this round. Later we can get smarter about this.
+      if(!NS_SUCCEEDED(result)) {
+        while(mTokenDeque.GetSize()>theDequeSize) {
+          theRecycler->RecycleToken((CToken*)mTokenDeque.Pop());
+        }
+      }
+    } //if
+  } //if
+  return result;
+}
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsHTMLTokenizer::ConsumeEndTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
+  nsresult result=NS_OK;
+  
+  if(aToken) {
+    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
+    AddToken(aToken,result,mTokenDeque);
+  } //if
+  return result;
+}
+
+/**
+ *  This method is called just after a "&" has been consumed 
+ *  and we know we're at the start of an entity.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeEntity(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+   PRUnichar  theChar;
+   nsresult result=aScanner.GetChar(theChar);
+
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  if(NS_OK==result) {
+    if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
+       aToken = theRecycler->CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
+       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
+    }
+    else if(kHashsign==theChar) {
+       aToken = theRecycler->CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
+       result=aToken->Consume(0,aScanner);
+    }
+    else {
+       //oops, we're actually looking at plain text...
+       nsAutoString temp("&");
+       aScanner.PutBack(theChar);
+       return ConsumeText(temp,aToken,aScanner);
+    }//if
+    AddToken(aToken,result,mTokenDeque);
+  }//if
+  return result;
+}
+
+
+/**
+ *  This method is called just after whitespace has been 
+ *  consumed and we know we're at the start a whitespace run.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeWhitespace(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner) {
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken = theRecycler->CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+/**
+ *  This method is called just after a "<!" has been consumed 
+ *  and we know we're at the start of a comment.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsHTMLTokenizer::ConsumeComment(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner){
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken = theRecycler->CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+/**
+ *  This method is called just after a known text char has
+ *  been consumed and we should read a text run.
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */ 
+nsresult nsHTMLTokenizer::ConsumeText(const nsString& aString,CToken*& aToken,nsScanner& aScanner){
+  nsresult result=NS_OK;
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
+  if(aToken) {
+    PRUnichar ch=0;
+    result=aToken->Consume(ch,aScanner);
+    if(result) {
+      nsString& temp=aToken->GetStringValueXXX();
+      if(0==temp.Length()){
+        delete aToken;
+        aToken = nsnull;
+      }
+      else result=NS_OK;
+    }
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+/**
+ *  This method is called just after a newline has been consumed. 
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  aToken is the newly created newline token that is parsing
+ *  @return error code
+ */
+nsresult nsHTMLTokenizer::ConsumeNewline(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner){
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
+
+/**
+ *  This method is called just after a ? has been consumed. 
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  aToken is the newly created newline token that is parsing
+ *  @return error code
+ */
+nsresult nsHTMLTokenizer::ConsumeProcessingInstruction(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner){
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+  aToken=theRecycler->CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
+  nsresult result=NS_OK;
+  if(aToken) {
+    result=aToken->Consume(aChar,aScanner);
+    AddToken(aToken,result,mTokenDeque);
+  }
+  return result;
+}
+
diff --git a/parser/htmlparser/src/nsHTMLTokenizer.h b/parser/htmlparser/src/nsHTMLTokenizer.h
new file mode 100644
index 000000000000..a2f1b8427bd1
--- /dev/null
+++ b/parser/htmlparser/src/nsHTMLTokenizer.h
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#ifndef __NSHTMLTOKENIZER
+#define __NSHTMLTOKENIZER
+
+#include "nsISupports.h"
+#include "nsITokenizer.h"
+#include "nsIDTD.h"
+#include "prtypes.h"
+#include "nsDeque.h"
+#include "nsScanner.h"
+#include "nsHTMLTokens.h"
+
+#define NS_HTMLTOKENIZER_IID      \
+  {0xe4238ddd, 0x9eb6, 0x11d2, \
+  {0xba, 0xa5, 0x0,     0x10, 0x4b, 0x98, 0x3f, 0xd4 }}
+
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+#if defined(XP_PC)
+#pragma warning( disable : 4275 )
+#endif
+
+CLASS_EXPORT_HTMLPARS nsHTMLTokenizer : public nsITokenizer {
+public:
+            nsHTMLTokenizer();
+            ~nsHTMLTokenizer();
+
+            NS_DECL_ISUPPORTS
+
+  virtual nsresult          ConsumeToken(nsScanner& aScanner);
+  virtual nsITokenRecycler* GetTokenRecycler(void);
+
+  virtual CToken*           PushTokenFront(CToken* theToken);
+  virtual CToken*           PushToken(CToken* theToken);
+	virtual CToken*           PopToken(void);
+	virtual CToken*           PeekToken(void);
+	virtual PRInt32           GetCount(void);
+
+protected:
+
+  virtual nsresult HandleSkippedContent(nsScanner& aScanner,CToken*& aToken);
+  virtual nsresult ConsumeTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeStartTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeEndTag(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeAttributes(PRUnichar aChar,CStartToken* aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeEntity(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeWhitespace(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeComment(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeNewline(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeText(const nsString& aString,CToken*& aToken,nsScanner& aScanner);
+  virtual nsresult ConsumeContentToEndTag(PRUnichar aChar,eHTMLTags aChildTag,nsScanner& aScanner,CToken*& aToken);
+  virtual nsresult ConsumeProcessingInstruction(PRUnichar aChar,CToken*& aToken,nsScanner& aScanner);
+
+protected:
+  
+  nsDeque mTokenDeque;
+  PRBool  mDoXMLEmptyTags;
+};
+
+extern NS_HTMLPARS nsresult NS_NewHTMLTokenizer(nsIDTD** aInstancePtrResult);
+
+#endif
+
+
diff --git a/parser/htmlparser/src/nsHTMLTokens.cpp b/parser/htmlparser/src/nsHTMLTokens.cpp
index a2c8e0d1383c..2f5be8759c66 100644
--- a/parser/htmlparser/src/nsHTMLTokens.cpp
+++ b/parser/htmlparser/src/nsHTMLTokens.cpp
@@ -23,7 +23,7 @@
 #include "nsScanner.h"
 #include "nsToken.h" 
 #include "nsHTMLTokens.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "prtypes.h"
 #include "nsDebug.h"
 #include "nsHTMLTags.h"
@@ -212,7 +212,7 @@ PRBool CStartToken::IsEmpty(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CStartToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CStartToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
   //if you're here, we've already Consumed the < char, and are
    //ready to Consume the rest of the open tag identifier.
@@ -235,14 +235,14 @@ nsresult CStartToken::Consume(PRUnichar aChar, CScanner& aScanner) {
       if(NS_OK==result) {
         if(kGreaterThan!=aChar) { //look for '>' 
          //push that char back, since we apparently have attributes...
-          aScanner.PutBack(aChar);
+          result=aScanner.PutBack(aChar);
           mAttributed=PR_TRUE;
         } //if
       } //if
     }//if
   }
   return result;
-};
+}
 
 
 /*
@@ -290,7 +290,7 @@ CEndToken::CEndToken(const nsString& aName) : CHTMLToken(aName) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CEndToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CEndToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
   //if you're here, we've already Consumed the <! chars, and are
    //ready to Consume the rest of the open tag identifier.
@@ -300,26 +300,26 @@ nsresult CEndToken::Consume(PRUnichar aChar, CScanner& aScanner) {
   mTextValue="";
   nsresult result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_FALSE);
 
-  char buffer[300];
-  mTextValue.ToCString(buffer,sizeof(buffer)-1);
+  if(NS_OK==result){
+    char buffer[300];
+    mTextValue.ToCString(buffer,sizeof(buffer)-1);
 
-  //This code was added to fix Bug#1125.
-  //The problem occurs in bad tags like this: </font size>.
-  //"font size" was being viewed as the tag, which of course doesn't exist.
-  //Instead, we only look at the first word.
-  int theBufPos=-1;
-  while(buffer[++theBufPos]){
-    if(kSpace==buffer[theBufPos]){ 
-      buffer[theBufPos]=0;
-      break;
+    //This code was added to fix Bug#1125.
+    //The problem occurs in bad tags like this: </font size>.
+    //"font size" was being viewed as the tag, which of course doesn't exist.
+    //Instead, we only look at the first word.
+    int theBufPos=-1;
+    while(buffer[++theBufPos]){
+      if(kSpace==buffer[theBufPos]){ 
+        buffer[theBufPos]=0;
+        break;
+      }
     }
-  }
-  mTypeID= NS_TagToEnum(buffer);
-
-  if(NS_OK==result)
+    mTypeID= NS_TagToEnum(buffer);
     result=aScanner.GetChar(aChar); //eat the closing '>;
+  }
   return result;
-};
+}
 
 
 /*
@@ -437,7 +437,7 @@ PRInt32 CTextToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CTextToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CTextToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   static    nsAutoString terminals("&<\r");
   nsresult  result=NS_OK;
   PRBool    done=PR_FALSE;
@@ -446,22 +446,24 @@ nsresult CTextToken::Consume(PRUnichar aChar, CScanner& aScanner) {
     result=aScanner.ReadUntil(mTextValue,terminals,PR_FALSE,PR_FALSE);
     if(NS_OK==result) {
       result=aScanner.Peek(aChar);
-      if(kCR==aChar) {
+      if((kCR==aChar) && (NS_OK==result)) {
         result=aScanner.GetChar(aChar); //strip off the \r
         result=aScanner.Peek(aChar);    //then see what's next.
-        switch(aChar) {
-          case kCR:
-            result=aScanner.GetChar(aChar); //strip off the \r
-            mTextValue.Append("\n\n");
-            break;
-          case kNewLine:
-             //which means we saw \r\n, which becomes \n
-            result=aScanner.GetChar(aChar); //strip off the \n
-                //now fall through on purpose...
-          default:
-            mTextValue.Append("\n");
-            break;
-        }
+        if(NS_OK==result) {
+          switch(aChar) {
+            case kCR:
+              result=aScanner.GetChar(aChar); //strip off the \r
+              mTextValue.Append("\n\n");
+              break;
+            case kNewLine:
+               //which means we saw \r\n, which becomes \n
+              result=aScanner.GetChar(aChar); //strip off the \n
+                  //now fall through on purpose...
+            default:
+              mTextValue.Append("\n");
+              break;
+          }//switch
+        }//if
       }
       else done=PR_TRUE;
     }
@@ -503,7 +505,6 @@ const char*  CCDATASectionToken::GetClassName(void) {
 }
 
 /*
- *  
  *  
  *  @update  vidur 11/12/98
  *  @param   
@@ -521,7 +522,7 @@ PRInt32 CCDATASectionToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CCDATASectionToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CCDATASectionToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   static    nsAutoString terminals("]\r");
   nsresult  result=NS_OK;
   PRBool    done=PR_FALSE;
@@ -530,37 +531,41 @@ nsresult CCDATASectionToken::Consume(PRUnichar aChar, CScanner& aScanner) {
     result=aScanner.ReadUntil(mTextValue,terminals,PR_FALSE,PR_FALSE);
     if(NS_OK==result) {
       result=aScanner.Peek(aChar);
-      if(kCR==aChar) {
+      if((kCR==aChar) && (NS_OK==result)) {
         result=aScanner.GetChar(aChar); //strip off the \r
         result=aScanner.Peek(aChar);    //then see what's next.
-        switch(aChar) {
-          case kCR:
-            result=aScanner.GetChar(aChar); //strip off the \r
-            mTextValue.Append("\n\n");
-            break;
-          case kNewLine:
-             //which means we saw \r\n, which becomes \n
-            result=aScanner.GetChar(aChar); //strip off the \n
-                //now fall through on purpose...
-          default:
-            mTextValue.Append("\n");
-            break;
-        }
+        if(NS_OK==result) {
+          switch(aChar) {
+            case kCR:
+              result=aScanner.GetChar(aChar); //strip off the \r
+              mTextValue.Append("\n\n");
+              break;
+            case kNewLine:
+               //which means we saw \r\n, which becomes \n
+              result=aScanner.GetChar(aChar); //strip off the \n
+                  //now fall through on purpose...
+            default:
+              mTextValue.Append("\n");
+              break;
+          } //switch
+        } //if
       }
       else if (kRightSquareBracket==aChar) {
         result=aScanner.GetChar(aChar); //strip off the ]
         result=aScanner.Peek(aChar);    //then see what's next.
-        if (kRightSquareBracket==aChar) {
+        if((NS_OK==result) && (kRightSquareBracket==aChar)) {
           result=aScanner.GetChar(aChar);    //strip off the second ]
           result=aScanner.Peek(aChar);    //then see what's next.
-          if (kGreaterThan==aChar) {
-            result=aScanner.GetChar(aChar); //strip off the >
-            done=PR_TRUE;
-          }
-          else {
-            // This isn't the end of the CDATA section so go on
-            mTextValue.Append("]");
-          }
+          if(NS_OK==result) {
+            if (kGreaterThan==aChar) {
+              result=aScanner.GetChar(aChar); //strip off the >
+              done=PR_TRUE;
+            }
+            else {
+              // This isn't the end of the CDATA section so go on
+              mTextValue.Append("]");
+            }
+          }//if
         }
         else {
           // This isn't the end of the CDATA section so go on
@@ -573,6 +578,7 @@ nsresult CCDATASectionToken::Consume(PRUnichar aChar, CScanner& aScanner) {
   return result;
 }
 
+
 /*
  *  default constructor
  *  
@@ -604,29 +610,30 @@ CCommentToken::CCommentToken(const nsString& aName) : CHTMLToken(aName) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CCommentToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CCommentToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
   nsresult  result=NS_OK;
     
-  aScanner.GetChar(aChar);
-  mTextValue="<!";
-  if(kMinus==aChar) {
-    mTextValue+="-";
-    result=aScanner.GetChar(aChar);
-    if(NS_OK==result) {
-      if(kMinus==aChar) {
-           //in this case, we're reading a long-form comment <-- xxx -->
-        mTextValue+="-";
-        PRInt32 findpos=-1;
-        while((findpos==kNotFound) && (NS_OK==result)) {
-          result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_TRUE);
-          findpos=mTextValue.RFind("-->");
+  result=aScanner.GetChar(aChar);
+  if(NS_OK==result) {
+    mTextValue="<!";
+    if(kMinus==aChar) {
+      mTextValue+="-";
+      result=aScanner.GetChar(aChar);
+      if(NS_OK==result) {
+        if(kMinus==aChar) {
+             //in this case, we're reading a long-form comment <-- xxx -->
+          mTextValue+="-";
+          PRInt32 findpos=-1;
+          while((findpos==kNotFound) && (NS_OK==result)) {
+            result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_TRUE);
+            findpos=mTextValue.RFind("-->");
+          }
+          return result;
         }
-        return result;
       }
     }
   }
-
   if(NS_OK==result) {
      //if you're here, we're consuming a "short-form" comment
     mTextValue+=aChar;
@@ -721,7 +728,7 @@ nsString& CNewlineToken::GetStringValueXXX(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CNewlineToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CNewlineToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   mTextValue=aChar;
 
     //we already read the \r or \n, let's see what's next!
@@ -843,18 +850,18 @@ void CAttributeToken::DebugDumpToken(ostream& out) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-PRInt32 ConsumeQuotedString(PRUnichar aChar,nsString& aString,CScanner& aScanner){
-  PRInt32 result=kNotFound;
+nsresult ConsumeQuotedString(PRUnichar aChar,nsString& aString,nsScanner& aScanner){
+  nsresult result=NS_OK;
   switch(aChar) {
     case kQuote:
       result=aScanner.ReadUntil(aString,kQuote,PR_TRUE);
-      if(kNoError==result)
-        aScanner.SkipOver(kQuote);  //this code is here in case someone mistakenly adds multiple quotes...
+      if(NS_OK==result)
+        result=aScanner.SkipOver(kQuote);  //this code is here in case someone mistakenly adds multiple quotes...
       break;
     case kApostrophe:
       result=aScanner.ReadUntil(aString,kApostrophe,PR_TRUE);
-      if(kNoError==result)
-        aScanner.SkipOver(kApostrophe); //this code is here in case someone mistakenly adds multiple apostrophes...
+      if(NS_OK==result)
+        result=aScanner.SkipOver(kApostrophe); //this code is here in case someone mistakenly adds multiple apostrophes...
       break;
     default:
       break;
@@ -874,12 +881,9 @@ PRInt32 ConsumeQuotedString(PRUnichar aChar,nsString& aString,CScanner& aScanner
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-PRInt32 ConsumeAttributeValueText(PRUnichar,nsString& aString,CScanner& aScanner){
-
-  PRInt32 result=kNotFound;
+nsresult ConsumeAttributeValueText(PRUnichar,nsString& aString,nsScanner& aScanner){
   static nsAutoString terminals("\b\t\n\r >");
-
-  result=aScanner.ReadUntil(aString,terminals,PR_FALSE,PR_FALSE);
+  nsresult result=aScanner.ReadUntil(aString,terminals,PR_FALSE,PR_FALSE);
   return result;
 }
 
@@ -892,81 +896,86 @@ PRInt32 ConsumeAttributeValueText(PRUnichar,nsString& aString,CScanner& aScanner
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CAttributeToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CAttributeToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
 
-  aScanner.SkipWhitespace();             //skip leading whitespace                                      
-  nsresult result=aScanner.Peek(aChar);
+  nsresult result=aScanner.SkipWhitespace();             //skip leading whitespace 
   if(NS_OK==result) {
-    if(kQuote==aChar) {               //if you're here, handle quoted key...
-      result=aScanner.GetChar(aChar);        //skip the quote sign...
-      if(NS_OK==result) {
-        mTextKey=aChar;
-        result=ConsumeQuotedString(aChar,mTextKey,aScanner);
-      }
-    }
-    else if(kHashsign==aChar) {
-      result=aScanner.GetChar(aChar);        //skip the hash sign...
-      if(NS_OK==result) {
-        mTextKey=aChar;
-        result=aScanner.ReadWhile(mTextKey,gDigits,PR_TRUE,PR_TRUE);
-      }
-    }
-    else {
-        //If you're here, handle an unquoted key.
-        //Don't forget to reduce entities inline!
-      static nsAutoString terminals("\b\t\n\r \"=>");
-      result=aScanner.ReadUntil(mTextKey,terminals,PR_TRUE,PR_FALSE);
-    }
-
-      //now it's time to Consume the (optional) value...
-    if(NS_OK == (result=aScanner.SkipWhitespace())) { 
-      //Skip ahead until you find an equal sign or a '>'...
-      if(NS_OK == (result=aScanner.Peek(aChar))) {  
-        if(kEqual==aChar){
-          result=aScanner.GetChar(aChar);  //skip the equal sign...
-          if(NS_OK==result) {
-            result=aScanner.SkipWhitespace();     //now skip any intervening whitespace
-            if(NS_OK==result) {
-              result=aScanner.GetChar(aChar);  //and grab the next char.    
-              if(NS_OK==result) {
-                if((kQuote==aChar) || (kApostrophe==aChar)) {
-                  mTextValue=aChar;
-                  result=ConsumeQuotedString(aChar,mTextValue,aScanner);
-                }
-                else if(kGreaterThan==aChar){      
-                  aScanner.PutBack(aChar);
-                }
-                else {
-                  mTextValue=aChar;       //it's an alphanum attribute...
-                  result=ConsumeAttributeValueText(aChar,mTextValue,aScanner);
-                } 
-              }//if
-              if(NS_OK==result)
-                result=aScanner.SkipWhitespace();     
-            }//if
-          }//if
-        }//if
-        else {
-          //This is where we have to handle fairly busted content.
-          //If you're here, it means we saw an attribute name, but couldn't find 
-          //the following equal sign.  <tag NAME=....
-          
-          //Doing this right in all cases is <i>REALLY</i> ugly. 
-          //My best guess is to grab the next non-ws char. We know it's not '=',
-          //so let's see what it is. If it's a '"', then assume we're reading
-          //from the middle of the value. Try stripping the quote and continuing...
-
-          if(kQuote==aChar){
-            result=aScanner.SkipOver(aChar); //strip quote.
-          }
-        }
-      }//if
-    }
+    result=aScanner.Peek(aChar);
     if(NS_OK==result) {
-      result=aScanner.Peek(aChar);
-      mLastAttribute= PRBool((kGreaterThan==aChar) || (kEOF==result));
-    }
-  }
+      if(kQuote==aChar) {               //if you're here, handle quoted key...
+        result=aScanner.GetChar(aChar);        //skip the quote sign...
+        if(NS_OK==result) {
+          mTextKey=aChar;
+          result=ConsumeQuotedString(aChar,mTextKey,aScanner);
+        }
+      }
+      else if(kHashsign==aChar) {
+        result=aScanner.GetChar(aChar);        //skip the hash sign...
+        if(NS_OK==result) {
+          mTextKey=aChar;
+          result=aScanner.ReadWhile(mTextKey,gDigits,PR_TRUE,PR_FALSE);
+        }
+      }
+      else {
+          //If you're here, handle an unquoted key.
+          //Don't forget to reduce entities inline!
+        static nsAutoString terminals("\b\t\n\r \"=>");
+        result=aScanner.ReadUntil(mTextKey,terminals,PR_TRUE,PR_FALSE);
+      }
+
+        //now it's time to Consume the (optional) value...
+      if(NS_OK==result) {
+        result=aScanner.SkipWhitespace();
+        if(NS_OK==result) { 
+          result=aScanner.Peek(aChar);       //Skip ahead until you find an equal sign or a '>'...
+          if(NS_OK==result) {  
+            if(kEqual==aChar){
+              result=aScanner.GetChar(aChar);  //skip the equal sign...
+              if(NS_OK==result) {
+                result=aScanner.SkipWhitespace();     //now skip any intervening whitespace
+                if(NS_OK==result) {
+                  result=aScanner.GetChar(aChar);  //and grab the next char.    
+                  if(NS_OK==result) {
+                    if((kQuote==aChar) || (kApostrophe==aChar)) {
+                      mTextValue=aChar;
+                      result=ConsumeQuotedString(aChar,mTextValue,aScanner);
+                    }
+                    else if(kGreaterThan==aChar){      
+                      result=aScanner.PutBack(aChar);
+                    }
+                    else {
+                      mTextValue=aChar;       //it's an alphanum attribute...
+                      result=ConsumeAttributeValueText(aChar,mTextValue,aScanner);
+                    } 
+                  }//if
+                  if(NS_OK==result)
+                    result=aScanner.SkipWhitespace();     
+                }//if
+              }//if
+            }//if
+            else {
+              //This is where we have to handle fairly busted content.
+              //If you're here, it means we saw an attribute name, but couldn't find 
+              //the following equal sign.  <tag NAME=....
+          
+              //Doing this right in all cases is <i>REALLY</i> ugly. 
+              //My best guess is to grab the next non-ws char. We know it's not '=',
+              //so let's see what it is. If it's a '"', then assume we're reading
+              //from the middle of the value. Try stripping the quote and continuing...
+
+              if(kQuote==aChar){
+                result=aScanner.SkipOver(aChar); //strip quote.
+              }
+            }
+          }//if
+        } //if
+      }//if
+      if(NS_OK==result) {
+        result=aScanner.Peek(aChar);
+        mLastAttribute= PRBool((kGreaterThan==aChar) || (kEOF==result));
+      }
+    } //if
+  }//if
   return result;
 }
 
@@ -1042,7 +1051,7 @@ PRInt32 CWhitespaceToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CWhitespaceToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CWhitespaceToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   
   mTextValue=aChar;
 
@@ -1088,7 +1097,7 @@ CEntityToken::CEntityToken(const nsString& aName) : CHTMLToken(aName) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-nsresult CEntityToken::Consume(PRUnichar aChar, CScanner& aScanner) {
+nsresult CEntityToken::Consume(PRUnichar aChar, nsScanner& aScanner) {
   if(aChar)
     mTextValue=aChar;
   nsresult result=ConsumeEntity(aChar,mTextValue,aScanner);
@@ -1127,17 +1136,17 @@ PRInt32 CEntityToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source
  *  @return  error result
  */
-PRInt32 CEntityToken::ConsumeEntity(PRUnichar aChar,nsString& aString,CScanner& aScanner){
+PRInt32 CEntityToken::ConsumeEntity(PRUnichar aChar,nsString& aString,nsScanner& aScanner){
 
   PRInt32 result=aScanner.Peek(aChar);
-  if(kNoError==result) {
+  if(NS_OK==result) {
     if(kLeftBrace==aChar) {
       //you're consuming a script entity...
       static nsAutoString terminals("}>");
       result=aScanner.ReadUntil(aString,terminals,PR_FALSE,PR_FALSE);
-      if(kNoError==result) {
+      if(NS_OK==result) {
         result=aScanner.Peek(aChar);
-        if(kNoError==result) {
+        if(NS_OK==result) {
           if(kRightBrace==aChar) {
             aString+=kRightBrace;   //append rightbrace, and...
             result=aScanner.GetChar(aChar);//yank the closing right-brace
@@ -1147,9 +1156,9 @@ PRInt32 CEntityToken::ConsumeEntity(PRUnichar aChar,nsString& aString,CScanner&
     } //if
     else {
       result=aScanner.ReadWhile(aString,gIdentChars,PR_TRUE,PR_FALSE);
-      if(kNoError==result) {
+      if(NS_OK==result) {
         result=aScanner.Peek(aChar);
-        if(kNoError==result) {
+        if(NS_OK==result) {
           if (kSemicolon == aChar) {
             // consume semicolon that stopped the scan
             result=aScanner.GetChar(aChar);
@@ -1371,9 +1380,9 @@ PRInt32 CSkippedContentToken::GetTokenType(void) {
  *  @param   aScanner -- controller of underlying input source 
  *  @return  error result 
  */ 
-nsresult CSkippedContentToken::Consume(PRUnichar aChar,CScanner& aScanner) { 
+nsresult CSkippedContentToken::Consume(PRUnichar aChar,nsScanner& aScanner) { 
   PRBool      done=PR_FALSE; 
-  PRInt32     result=kNoError; 
+  nsresult    result=NS_OK; 
   nsString    temp; 
   PRUnichar   theChar;
 
@@ -1382,16 +1391,16 @@ nsresult CSkippedContentToken::Consume(PRUnichar aChar,CScanner& aScanner) {
  //If we find either, just eat them. If we find text or a tag, then go to the 
  //target endtag, or the start of another comment. 
 
-  while((!done) && (kNoError==result)) { 
+  while((!done) && (NS_OK==result)) { 
     result=aScanner.GetChar(aChar); 
-    if((kNoError==result) && (kLessThan==aChar)) { 
+    if((NS_OK==result) && (kLessThan==aChar)) { 
       //we're reading a tag or a comment... 
       result=aScanner.GetChar(theChar); 
-      if((kNoError==result) && (kExclamation==theChar)) { 
+      if((NS_OK==result) && (kExclamation==theChar)) { 
         //read a comment... 
         static CCommentToken theComment; 
         result=theComment.Consume(aChar,aScanner); 
-        if(kNoError==result) { 
+        if(NS_OK==result) { 
           temp.Append(theComment.GetStringValueXXX()); 
         } 
       } else { 
@@ -1404,7 +1413,7 @@ nsresult CSkippedContentToken::Consume(PRUnichar aChar,CScanner& aScanner) {
     else if(0<=gWhitespace.BinarySearch(aChar)) { 
       static CWhitespaceToken theWS; 
       result=theWS.Consume(aChar,aScanner); 
-      if(kNoError==result) { 
+      if(NS_OK==result) { 
         temp.Append(theWS.GetStringValueXXX()); 
       } 
     } 
@@ -1465,7 +1474,7 @@ CInstructionToken::CInstructionToken(const nsString& aString) : CHTMLToken(aStri
  *  @param   
  *  @return  
  */
-nsresult CInstructionToken::Consume(PRUnichar aChar,CScanner& aScanner){
+nsresult CInstructionToken::Consume(PRUnichar aChar,nsScanner& aScanner){
   mTextValue="<?";
   nsresult result=aScanner.ReadUntil(mTextValue,kGreaterThan,PR_TRUE);
   return result;
diff --git a/parser/htmlparser/src/nsHTMLTokens.h b/parser/htmlparser/src/nsHTMLTokens.h
index 34c7105b0c1d..84dbb5cd3fc6 100644
--- a/parser/htmlparser/src/nsHTMLTokens.h
+++ b/parser/htmlparser/src/nsHTMLTokens.h
@@ -43,7 +43,7 @@
 #include "nsHTMLTags.h"
 #include <iostream.h>
 
-class CScanner;
+class nsScanner;
 
   /*******************************************************************
    * This enum defines the set of token types that we currently support.
@@ -58,12 +58,32 @@ enum eHTMLTokenTypes {
   eToken_last //make sure this stays the last token...
 };
 
+enum eHTMLCategory {
+  eHTMLCategory_unknown=0,
+  eHTMLCategory_inline,
+  eHTMLCategory_block,
+  eHTMLCategory_blockAndInline,
+  eHTMLCategory_list,
+  eHTMLCategory_table,
+  eHTMLCategory_tablepart,
+  eHTMLCategory_tablerow,
+  eHTMLCategory_tabledata,
+  eHTMLCategory_head,
+  eHTMLCategory_html,
+  eHTMLCategory_body,
+  eHTMLCategory_form,
+  eHTMLCategory_options,
+  eHTMLCategory_frameset,
+  eHTMLCategory_text
+};
+
+
 #define eHTMLTags nsHTMLTag
 
-PRInt32         ConsumeQuotedString(PRUnichar aChar,nsString& aString,CScanner& aScanner);
-PRInt32         ConsumeAttributeText(PRUnichar aChar,nsString& aString,CScanner& aScanner);
-const char*     GetTagName(PRInt32 aTag);
-//PRInt32         FindEntityIndex(nsString& aString,PRInt32 aCount=-1);
+nsresult      ConsumeQuotedString(PRUnichar aChar,nsString& aString,nsScanner& aScanner);
+nsresult      ConsumeAttributeText(PRUnichar aChar,nsString& aString,nsScanner& aScanner);
+const char*   GetTagName(PRInt32 aTag);
+//PRInt32     FindEntityIndex(nsString& aString,PRInt32 aCount=-1);
 
 
 /**
@@ -90,7 +110,7 @@ class CStartToken: public CHTMLToken {
   public:
                         CStartToken(eHTMLTags aTag);
                         CStartToken(nsString& aName,eHTMLTags aTag=eHTMLTag_unknown);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual PRInt32     GetTypeID(void);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
@@ -119,7 +139,7 @@ class CEndToken: public CHTMLToken {
   public:
                         CEndToken(eHTMLTags aTag);
                         CEndToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual PRInt32     GetTypeID(void);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
@@ -139,7 +159,7 @@ class CCommentToken: public CHTMLToken {
   public:
                         CCommentToken();
                         CCommentToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
             char        mLeadingChar;
@@ -160,8 +180,8 @@ class CEntityToken : public CHTMLToken {
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
             PRInt32     TranslateToUnicodeStr(nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
-    static  PRInt32     ConsumeEntity(PRUnichar aChar,nsString& aString,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
+    static  PRInt32     ConsumeEntity(PRUnichar aChar,nsString& aString,nsScanner& aScanner);
     static  PRInt32     TranslateToUnicodeStr(PRInt32 aValue,nsString& aString);
 //    static  PRInt32     FindEntityIndex(nsString& aString);
 //    static  PRInt32     FindEntityIndexMax(const char* aBuffer,PRInt32 aCount=-1);
@@ -185,7 +205,7 @@ class CWhitespaceToken: public CHTMLToken {
   public:
                         CWhitespaceToken();
                         CWhitespaceToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
 };
@@ -201,7 +221,7 @@ class CTextToken: public CHTMLToken {
   public:
                         CTextToken();
                         CTextToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
 };
@@ -218,12 +238,13 @@ class CCDATASectionToken : public CHTMLToken {
 public:
                         CCDATASectionToken();
                         CCDATASectionToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);  
 };
 
 
+
 /**
  *  Attribute tokens are used to contain attribute key/value
  *  pairs whereever they may occur. Typically, they should
@@ -237,7 +258,7 @@ class CAttributeToken: public CHTMLToken {
                           CAttributeToken();
                           CAttributeToken(const nsString& aString);
                           CAttributeToken(const nsString& aKey, const nsString& aString);
-    virtual nsresult      Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult      Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char*   GetClassName(void);
     virtual PRInt32       GetTokenType(void);
     virtual nsString&     GetKey(void) {return mTextKey;}
@@ -261,7 +282,7 @@ class CNewlineToken: public CHTMLToken {
   public:
                         CNewlineToken();
                         CNewlineToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
     virtual nsString&   GetStringValueXXX(void);
@@ -314,7 +335,7 @@ class CStyleToken: public CHTMLToken {
 class CSkippedContentToken: public CAttributeToken {
   public:
                         CSkippedContentToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
   protected:
@@ -332,7 +353,7 @@ class CInstructionToken: public CHTMLToken {
   public:
                         CInstructionToken();
                         CInstructionToken(const nsString& aString);
-    virtual nsresult    Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult    Consume(PRUnichar aChar,nsScanner& aScanner);
     virtual const char* GetClassName(void);
     virtual PRInt32     GetTokenType(void);
 };
diff --git a/parser/htmlparser/src/nsIDTD.h b/parser/htmlparser/src/nsIDTD.h
index 7a27263754cd..1a81a5c058b3 100644
--- a/parser/htmlparser/src/nsIDTD.h
+++ b/parser/htmlparser/src/nsIDTD.h
@@ -15,6 +15,7 @@
  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  * Reserved.
  */
+
 #ifndef nsIDTD_h___
 #define nsIDTD_h___
 
@@ -33,6 +34,7 @@
 #include "nshtmlpars.h"
 #include "nsISupports.h"
 #include "prtypes.h"
+#include "nsITokenizer.h"
 
 #define NS_IDTD_IID \
  { 0xa6cf9053, 0x15b3, 0x11d2,{0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32}}
@@ -48,11 +50,6 @@ class nsITagHandler;
 enum eAutoDetectResult {eUnknownDetect, eValidDetect, eInvalidDetect};
 
 
-class nsITokenRecycler {
-public:
-    virtual void RecycleToken(CToken* aToken)=0;
-};
-
 
 class nsIDTD : public nsISupports {
   public:
@@ -64,6 +61,7 @@ class nsIDTD : public nsISupports {
      */
     virtual ~nsIDTD() {};
 
+    virtual const nsIID&  GetMostDerivedIID(void) const =0;
 
     /**
      * Call this method if you want the DTD to construct a clone of itself.
@@ -109,16 +107,24 @@ class nsIDTD : public nsISupports {
      * @param	anErrorCode - contains error code resulting from parse process
      * @return
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser)=0;
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser)=0;
+
+    /**
+     * Called by the parser after the parsing process has concluded
+     * @update	gess5/18/98
+     * @param	anErrorCode - contains error code resulting from parse process
+     * @return
+     */
+    NS_IMETHOD BuildModel(nsIParser* aParser)=0;
     
     /**
      *	Called during model building phase of parse process. Each token created during
-	 *  the parse phase is stored in a deque (in the parser) and are passed to this method
-	 *  so that the DTD can process the token. Ultimately, the DTD will transform given
-	 *  token into calls onto a contentsink.
+	   *  the parse phase is stored in a deque (in the parser) and are passed to this method
+	   *  so that the DTD can process the token. Ultimately, the DTD will transform given
+	   *  token into calls onto a contentsink.
      *  @update  gess 3/25/98
      *  @param   aToken -- token object to be put into content model
-	 *  @return	 error code (usually 0)
+	   *  @return	 error code (usually 0)
      */
     NS_IMETHOD HandleToken(CToken* aToken,nsIParser* aParser)=0;
 
@@ -130,7 +136,9 @@ class nsIDTD : public nsISupports {
   	 *  @param   aToken -- will contain newly created and consumed token
 	   *  @return	 error code (usually 0)
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser)=0;
+    virtual nsITokenizer* GetTokenizer(void)=0;
+
+    virtual  nsITokenRecycler* GetTokenRecycler(void)=0;
 
     /**
      *  This method causes all tokens to be dispatched to the given tag handler.
@@ -195,14 +203,6 @@ class nsIDTD : public nsISupports {
      * @return
      */
     virtual PRBool Verify(nsString& aURLRef,nsIParser* aParser)=0;
-
-    /**
-     * Retrieve a ptr to the global token recycler...
-     * @update	gess8/4/98
-     * @return  ptr to recycler (or null)
-     */
-    virtual nsITokenRecycler* GetTokenRecycler(void)=0;
-
 };
 
 
diff --git a/parser/htmlparser/src/nsIParser.h b/parser/htmlparser/src/nsIParser.h
index f4818057577f..5a387ac140df 100644
--- a/parser/htmlparser/src/nsIParser.h
+++ b/parser/htmlparser/src/nsIParser.h
@@ -34,24 +34,14 @@
 #include "nsIStreamListener.h"
 #include "nsIDTD.h"
 #include "nsIInputStream.h"
-#include "nsError.h"
 #include <fstream.h>
 
+
 #define NS_IPARSER_IID      \
   {0x355cbba0, 0xbf7d,  0x11d1,  \
   {0xaa, 0xd9, 0x00,    0x80, 0x5f, 0x8a, 0x3e, 0x14}}
 
-/**
- * Return codes for parsing routines.
- * @update vidur 12/11/98
- *
- * NS_ERROR_HTMLPARSER_BLOCK indicates that the parser should
- * block further parsing until it gets a Unblock() method call.
- * NS_ERROR_HTMLPARSER_CONTINUE indicates that the parser should
- * continue parsing
- */
-#define NS_ERROR_HTMLPARSER_BLOCK       NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_HTMLPARSER,1)
-#define NS_ERROR_HTMLPARSER_CONTINUE    NS_OK
+
 
 class nsIContentSink;
 class nsIStreamObserver;
@@ -133,10 +123,10 @@ class nsIParser : public nsISupports {
      *  until you wind up being emitted to the given contentsink (which may or may not
 	   *  be a proxy for the NGLayout content model).
      ******************************************************************************************/
-    virtual PRBool  EnableParser(PRBool aState) = 0;
-    virtual PRInt32 Parse(nsIURL* aURL,nsIStreamObserver* aListener = nsnull,PRBool aEnableVerify=PR_FALSE) = 0;
-    virtual PRInt32 Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE) = 0;
-    virtual PRInt32 Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE) = 0;
+    virtual PRBool    EnableParser(PRBool aState) = 0;
+    virtual nsresult  Parse(nsIURL* aURL,nsIStreamObserver* aListener = nsnull,PRBool aEnableVerify=PR_FALSE) = 0;
+    virtual nsresult  Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE) = 0;
+    virtual nsresult  Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE) = 0;
 
     /**
      * This method gets called when the tokens have been consumed, and it's time
@@ -144,7 +134,7 @@ class nsIParser : public nsISupports {
      * @update	gess5/11/98
      * @return  error code -- 0 if model building went well .
      */
-    virtual PRInt32 BuildModel(void)=0;
+    virtual nsresult  BuildModel(void)=0;
 
 
     /**
@@ -158,4 +148,73 @@ class nsIParser : public nsISupports {
 
 };
 
+/* ===========================================================*
+  Some useful constants...
+ * ===========================================================*/
+
+#include "prtypes.h"
+#include "nsError.h"
+
+#define NS_ERROR_HTMLPARSER_EOF                   NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1000)
+#define NS_ERROR_HTMLPARSER_UNKNOWN               NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1001)
+#define NS_ERROR_HTMLPARSER_CANTPROPAGATE         NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1002)
+#define NS_ERROR_HTMLPARSER_CONTEXTMISMATCH       NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1003)
+#define NS_ERROR_HTMLPARSER_BADFILENAME           NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1004)
+#define NS_ERROR_HTMLPARSER_BADURL                NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1005)
+#define NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1006)
+#define NS_ERROR_HTMLPARSER_INTERRUPTED           NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1007)
+
+/**
+ * Return codes for parsing routines.
+ * @update vidur 12/11/98
+ *
+ * NS_ERROR_HTMLPARSER_BLOCK indicates that the parser should
+ * block further parsing until it gets a Unblock() method call.
+ * NS_ERROR_HTMLPARSER_CONTINUE indicates that the parser should
+ * continue parsing
+ */
+#define NS_ERROR_HTMLPARSER_BLOCK       NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_HTMLPARSER,1008)
+#define NS_ERROR_HTMLPARSER_CONTINUE    NS_OK
+
+
+const PRInt32   kEOF              = NS_ERROR_HTMLPARSER_EOF;
+const PRInt32   kUnknownError     = NS_ERROR_HTMLPARSER_UNKNOWN;
+const PRInt32   kCantPropagate    = NS_ERROR_HTMLPARSER_CANTPROPAGATE;
+const PRInt32   kContextMismatch  = NS_ERROR_HTMLPARSER_CONTEXTMISMATCH;
+const PRInt32   kBadFilename      = NS_ERROR_HTMLPARSER_BADFILENAME;
+const PRInt32   kBadURL           = NS_ERROR_HTMLPARSER_BADURL;
+const PRInt32   kInvalidParserContext = NS_ERROR_HTMLPARSER_INVALIDPARSERCONTEXT;
+const PRInt32   kNotFound         = -1;
+const PRInt32   kBlock            = NS_ERROR_HTMLPARSER_BLOCK;
+
+const PRUint32  kNewLine          = '\n';
+const PRUint32  kCR               = '\r';
+const PRUint32  kLF               = '\n';
+const PRUint32  kTab              = '\t';
+const PRUint32  kSpace            = ' ';
+const PRUint32  kQuote            = '"';
+const PRUint32  kApostrophe       = '\'';
+const PRUint32  kLessThan         = '<';
+const PRUint32  kGreaterThan      = '>';
+const PRUint32  kAmpersand        = '&';
+const PRUint32  kForwardSlash     = '/';
+const PRUint32  kBackSlash        = '\\';
+const PRUint32  kEqual            = '=';
+const PRUint32  kMinus            = '-';
+const PRUint32  kPlus             = '+';
+const PRUint32  kExclamation      = '!';
+const PRUint32  kSemicolon        = ';';
+const PRUint32  kHashsign         = '#';
+const PRUint32  kAsterisk         = '*';
+const PRUint32  kUnderbar         = '_';
+const PRUint32  kComma            = ',';
+const PRUint32  kLeftParen        = '(';
+const PRUint32  kRightParen       = ')';
+const PRUint32  kLeftBrace        = '{';
+const PRUint32  kRightBrace       = '}';
+const PRUint32  kQuestionMark     = '?';
+const PRUint32  kLeftSquareBracket  = '[';
+const PRUint32  kRightSquareBracket = ']';
+const PRUnichar kNullCh           = '\0';
+
 #endif 
diff --git a/parser/htmlparser/src/nsITokenHandler.h b/parser/htmlparser/src/nsITokenHandler.h
index 7e71caf2b888..4abbefd505a7 100644
--- a/parser/htmlparser/src/nsITokenHandler.h
+++ b/parser/htmlparser/src/nsITokenHandler.h
@@ -27,6 +27,7 @@
 #define ITOKENHANDLER__
 
 #include "prtypes.h"
+#include "nsError.h"
 
 class CToken;
 class nsIDTD;
@@ -34,7 +35,7 @@ class nsIDTD;
 class CITokenHandler {
 public:
                           
-  virtual PRInt32 operator()(CToken* aToken,nsIDTD* aDTD)=0;
+  virtual nsresult operator()(CToken* aToken,nsIDTD* aDTD)=0;
   virtual PRInt32 GetTokenType(void)=0;
 
 };
diff --git a/parser/htmlparser/src/nsITokenizer.h b/parser/htmlparser/src/nsITokenizer.h
new file mode 100644
index 000000000000..6e49e1a21b97
--- /dev/null
+++ b/parser/htmlparser/src/nsITokenizer.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL")=0; you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#ifndef __NSITOKENIZER__
+#define __NSITOKENIZER__
+
+#include "nsISupports.h"
+#include "prtypes.h"
+#include "nshtmlpars.h"
+
+class CToken;
+class nsScanner;
+
+#define NS_ITOKENIZER_IID      \
+  {0xe4238ddc, 0x9eb6,  0x11d2, {0xba, 0xa5, 0x0,     0x10, 0x4b, 0x98, 0x3f, 0xd4 }}
+
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+class  nsITokenRecycler {
+public:
+    virtual void RecycleToken(CToken* aToken)=0;
+};
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+class nsITokenizer : public nsISupports {
+public:
+    
+  virtual nsresult          ConsumeToken(nsScanner& aScanner)=0;
+  virtual nsITokenRecycler* GetTokenRecycler(void)=0;
+
+  virtual CToken*           PushTokenFront(CToken* theToken)=0;
+  virtual CToken*           PushToken(CToken* theToken)=0;
+	virtual CToken*           PopToken(void)=0;
+	virtual CToken*           PeekToken(void)=0;
+	virtual PRInt32           GetCount(void)=0;
+  
+};
+
+
+#endif
+
diff --git a/parser/htmlparser/src/nsParser.cpp b/parser/htmlparser/src/nsParser.cpp
index 5c974b9973bb..a39ece85ac51 100644
--- a/parser/htmlparser/src/nsParser.cpp
+++ b/parser/htmlparser/src/nsParser.cpp
@@ -81,7 +81,10 @@ public:
     NS_IF_RELEASE(mTargetDTD);
   }
   virtual void* operator()(void* anObject) {
-    return (anObject==(void*)mTargetDTD) ? anObject : 0;
+    nsIDTD* theDTD=(nsIDTD*)anObject;
+    if(theDTD->GetMostDerivedIID().Equals(mTargetDTD->GetMostDerivedIID()))
+      return anObject;
+    return 0;
   }
   nsIDTD* mTargetDTD;
 };
@@ -90,12 +93,14 @@ class CSharedParserObjects {
 public:
 
   CSharedParserObjects() : mDeallocator(), mDTDDeque(mDeallocator) {
-    nsIDTD* theDTD;
-    NS_NewWellFormed_DTD(&theDTD);
-    RegisterDTD(theDTD);
+    /*
+      nsIDTD* theDTD;
+      NS_NewWellFormed_DTD(&theDTD);
+      RegisterDTD(theDTD);
 
-    NS_NewViewSourceHTML(&theDTD);
-    RegisterDTD(theDTD);
+      NS_NewViewSourceHTML(&theDTD);
+      RegisterDTD(theDTD);
+    */
   }
 
   ~CSharedParserObjects() {
@@ -119,66 +124,6 @@ CSharedParserObjects gSharedParserObjects;
 
 //----------------------------------------
 
-#define NOT_USED 0xfffd
-
-static PRUint16 PA_HackTable[] = {
-	NOT_USED,
-	NOT_USED,
-	0x201a,  /* SINGLE LOW-9 QUOTATION MARK */
-	0x0192,  /* LATIN SMALL LETTER F WITH HOOK */
-	0x201e,  /* DOUBLE LOW-9 QUOTATION MARK */
-	0x2026,  /* HORIZONTAL ELLIPSIS */
-	0x2020,  /* DAGGER */
-	0x2021,  /* DOUBLE DAGGER */
-	0x02c6,  /* MODIFIER LETTER CIRCUMFLEX ACCENT */
-	0x2030,  /* PER MILLE SIGN */
-	0x0160,  /* LATIN CAPITAL LETTER S WITH CARON */
-	0x2039,  /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
-	0x0152,  /* LATIN CAPITAL LIGATURE OE */
-	NOT_USED,
-	NOT_USED,
-	NOT_USED,
-
-	NOT_USED,
-	0x2018,  /* LEFT SINGLE QUOTATION MARK */
-	0x2019,  /* RIGHT SINGLE QUOTATION MARK */
-	0x201c,  /* LEFT DOUBLE QUOTATION MARK */
-	0x201d,  /* RIGHT DOUBLE QUOTATION MARK */
-	0x2022,  /* BULLET */
-	0x2013,  /* EN DASH */
-	0x2014,  /* EM DASH */
-	0x02dc,  /* SMALL TILDE */
-	0x2122,  /* TRADE MARK SIGN */
-	0x0161,  /* LATIN SMALL LETTER S WITH CARON */
-	0x203a,  /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
-	0x0153,  /* LATIN SMALL LIGATURE OE */
-	NOT_USED,
-	NOT_USED,
-	0x0178   /* LATIN CAPITAL LETTER Y WITH DIAERESIS */
-};
-
-static PRUnichar gToUCS2[256];
-
-static void
-MakeConversionTable()
-{
-  static PRBool firstTime = PR_TRUE;
-  if (firstTime) {
-    firstTime = PR_FALSE;
-    PRUnichar* cp = gToUCS2;
-    PRInt32 i;
-    for (i = 0; i < 256; i++) {
-      *cp++ = PRUnichar(i);
-    }
-    cp = gToUCS2;
-    for (i = 0; i < 32; i++) {
-      cp[0x80 + i] = PA_HackTable[i];
-    }
-  }
-}
-
-//----------------------------------------
-
 /**
  *  default constructor
  *  
@@ -195,7 +140,6 @@ nsParser::nsParser() : mCommand("") {
   mParserContext=0;
   mDTDVerification=PR_FALSE;
   mParserEnabled=PR_TRUE;
-  MakeConversionTable();
 }
 
 
@@ -219,7 +163,7 @@ nsParser::~nsParser() {
 
 NS_IMPL_ADDREF(nsParser)
 NS_IMPL_RELEASE(nsParser)
-//NS_IMPL_ISUPPORTS(nsParser,NS_IHTML_PARSER_IID)
+//NS_IMPL_ISUPPORTS(nsParser,NS_IHTML_HTMLPARSER_IID)
 
 
 /**
@@ -348,7 +292,7 @@ void nsParser::RegisterDTD(nsIDTD* aDTD){
  *  @update  gess 6/9/98
  *  @return  ptr to internal scanner
  */
-CScanner* nsParser::GetScanner(void){
+nsScanner* nsParser::GetScanner(void){
   if(mParserContext)
     return mParserContext->mScanner;
   return 0;
@@ -442,7 +386,7 @@ eAutoDetectResult nsParser::AutoDetectContentType(nsString& aBuffer,nsString& aT
 
 
 /**
- *  This is called (by willBuildModel) when it's time to find out 
+ *  This is called when it's time to find out 
  *  what mode the parser/DTD should run for this document.
  *  (Each parsercontext can have it's own mode).
  *  
@@ -453,7 +397,7 @@ eParseMode DetermineParseMode(nsParser& aParser) {
   const char* theModeStr= PR_GetEnv("PARSE_MODE");
   const char* other="other";
   
-  CScanner* theScanner=aParser.GetScanner();
+  nsScanner* theScanner=aParser.GetScanner();
   if(theScanner){
     nsString& theBuffer=theScanner->GetBuffer();
     PRInt32 theIndex=theBuffer.Find("HTML 4.0");
@@ -488,20 +432,28 @@ eParseMode DetermineParseMode(nsParser& aParser) {
  * @param 
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::WillBuildModel(nsString& aFilename,nsIDTD* aDefaultDTD){
+nsresult nsParser::WillBuildModel(nsString& aFilename,nsIDTD* aDefaultDTD){
 
-  mMajorIteration=-1; 
-  mMinorIteration=-1; 
-  PRInt32 result=kNoError;
-  if(mParserContext){
-    mParserContext->mParseMode=DetermineParseMode(*this);  
-    mParserContext->mDTD=aDefaultDTD;
-    if(PR_TRUE==FindSuitableDTD(*mParserContext,mCommand)) {
-      //mParserContext->mDTD->SetContentSink(mSink);
-      mParserContext->mDTD->WillBuildModel(aFilename,PRBool(0==mParserContext->mPrevContext),this);
+  nsresult result=NS_OK;
+
+  if(eOnStart==mStreamListenerState) {  
+    mMajorIteration=-1; 
+    mMinorIteration=-1; 
+    if(eUnknownDetect==mParserContext->mAutoDetectStatus) {
+      if(eValidDetect==AutoDetectContentType(mParserContext->mScanner->GetBuffer(),mParserContext->mSourceType)) {
+        if(mParserContext){
+          mParserContext->mParseMode=DetermineParseMode(*this);  
+          mParserContext->mDTD=aDefaultDTD;
+          if(PR_TRUE==FindSuitableDTD(*mParserContext,mCommand)) {
+            //mParserContext->mDTD->SetContentSink(mSink);
+            mStreamListenerState=eOnDataAvail;
+            mParserContext->mDTD->WillBuildModel(aFilename,PRBool(0==mParserContext->mPrevContext),this);
+          }
+        }
+        else result=kInvalidParserContext;    
+      } //if
     }
   }
-  else result=kInvalidParserContext;
   return result;
 }
 
@@ -513,25 +465,15 @@ PRInt32 nsParser::WillBuildModel(nsString& aFilename,nsIDTD* aDefaultDTD){
  * @param 
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::DidBuildModel(PRInt32 anErrorCode) {
+nsresult nsParser::DidBuildModel(nsresult anErrorCode) {
   //One last thing...close any open containers.
-  PRInt32 result=anErrorCode;
+  nsresult result=anErrorCode;
 
-  if((!mParserContext->mPrevContext) && (mParserContext->mDTD)) {
-    result=mParserContext->mDTD->DidBuildModel(anErrorCode,PRBool(0==mParserContext->mPrevContext),this);
-
-    //Now recycle any tokens that are still hanging around.
-    //Come to think of it, there really shouldn't be any.
-    nsDeque&  theDeque=mParserContext->mTokenDeque;
-    nsITokenRecycler* theRecycler=mParserContext->mDTD->GetTokenRecycler();
-    if(theRecycler) {
-      CToken* theToken=(CToken*)theDeque.Pop();
-      while(theToken) {
-        theRecycler->RecycleToken(theToken);
-        theToken=(CToken*)theDeque.Pop();
-      }
+  if(mParserEnabled) {
+    if((!mParserContext->mPrevContext) && (mParserContext->mDTD)) {
+      result=mParserContext->mDTD->DidBuildModel(anErrorCode,PRBool(0==mParserContext->mPrevContext),this);
     }
-  }
+  }//if
 
   return result;
 }
@@ -589,13 +531,6 @@ PRBool nsParser::EnableParser(PRBool aState){
   if ((PR_FALSE == mParserEnabled) && aState) {
     mParserEnabled = PR_TRUE;
     ResumeParse();
-    // If the stream has already closed, finish out the parsing
-    // process. Note if the parser was disabled when we resumed
-    // parsing, then we have to wait till its reenabled before
-    // finishing.
-    if ((eOnStop == mStreamListenerState) && mParserEnabled) {
-      DidBuildModel(mStreamStatus);
-    }
   }
   else {
     mParserEnabled=aState;
@@ -619,22 +554,23 @@ PRBool nsParser::EnableParser(PRBool aState){
  *  @param   aFilename -- const char* containing file to be parsed.
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aVerifyEnabled) {
+nsresult nsParser::Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aVerifyEnabled) {
   NS_PRECONDITION(0!=aURL,kNullURL);
 
-  PRInt32 status=kBadURL;
+  nsresult result=kBadURL;
   mDTDVerification=aVerifyEnabled;
- 
+  mStreamListenerState=eNone;  
+  mIncremental=PR_TRUE; 
   if(aURL) {
     const char* spec;
     nsresult rv = aURL->GetSpec(&spec);
     if (rv != NS_OK) return rv;
     nsAutoString theName(spec);
-    CParserContext* cp=new CParserContext(new CScanner(theName,PR_FALSE),aURL,aListener);
+    CParserContext* cp=new CParserContext(new nsScanner(theName,PR_FALSE),aURL,aListener);
     PushContext(*cp);
-    status=NS_OK;
+    result=NS_OK;
   }
-  return status;
+  return result;
 }
 
 
@@ -644,27 +580,22 @@ PRInt32 nsParser::Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aVerify
  * @param   aStream is the i/o source
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Parse(fstream& aStream,PRBool aVerifyEnabled){
+nsresult nsParser::Parse(fstream& aStream,PRBool aVerifyEnabled){
 
-  PRInt32 status=kNoError;
   mDTDVerification=aVerifyEnabled;
+  mStreamListenerState=eOnStart;  
   
   //ok, time to create our tokenizer and begin the process
-  CParserContext* pc=new CParserContext(new CScanner(kUnknownFilename,aStream,PR_FALSE),&aStream,0);
+  CParserContext* pc=new CParserContext(new nsScanner(kUnknownFilename,aStream,PR_FALSE),&aStream,0);
   PushContext(*pc);
   pc->mSourceType="text/html";
   mParserContext->mScanner->Eof();
-  if(eValidDetect==AutoDetectContentType(mParserContext->mScanner->GetBuffer(),
-                                         mParserContext->mSourceType)) {
-    WillBuildModel(mParserContext->mScanner->GetFilename(),0);
-    status=ResumeParse();
-    DidBuildModel(status);
-  } //if
-
+  mIncremental=PR_FALSE;
+  nsresult result=ResumeParse();
   pc=PopContext();
   delete pc;
 
-  return status;
+  return result;
 }
 
 
@@ -678,23 +609,21 @@ PRInt32 nsParser::Parse(fstream& aStream,PRBool aVerifyEnabled){
  * @param   anHTMLString tells us whether we should assume the content is HTML (usually true)
  * @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVerifyEnabled){
-  PRInt32 result=kNoError;
+nsresult nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVerifyEnabled){
   mDTDVerification=aVerifyEnabled;
+  mStreamListenerState=eOnStart;  
 
+  nsresult result=NS_OK;
   if(0<aSourceBuffer.Length()){
-    CParserContext* pc=new CParserContext(new CScanner(aSourceBuffer),&aSourceBuffer,0);
+    CParserContext* pc=new CParserContext(new nsScanner(aSourceBuffer),&aSourceBuffer,0);
 
     nsIDTD* thePrevDTD=(mParserContext) ? mParserContext->mDTD: 0;
       
     PushContext(*pc);
     if(PR_TRUE==anHTMLString)
       pc->mSourceType="text/html";
-    if(eValidDetect==AutoDetectContentType(aSourceBuffer,mParserContext->mSourceType)) {
-      WillBuildModel(mParserContext->mScanner->GetFilename(),thePrevDTD);
-      result=ResumeParse();
-      DidBuildModel(result);
-    }
+    mIncremental=PR_FALSE;
+    result=ResumeParse();
     mParserContext->mDTD=0; 
     pc=PopContext();
     delete pc;
@@ -702,7 +631,7 @@ PRInt32 nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVeri
   return result;
 }
 
-
+ 
 /**
  *  This routine is called to cause the parser to continue
  *  parsing it's underlying stream. This call allows the
@@ -713,22 +642,28 @@ PRInt32 nsParser::Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aVeri
  *  @param   
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::ResumeParse() {
-  PRInt32 result=kNoError;
-  PRInt32 buildResult=kNoError;
-
+nsresult nsParser::ResumeParse(nsIDTD* aDefaultDTD) {
+  
+  nsresult result=WillBuildModel(mParserContext->mScanner->GetFilename(),aDefaultDTD);
   mParserContext->mDTD->WillResumeParse();
-  if(kNoError==result) {
+  if(NS_OK==result) {
+     
     result=Tokenize();
-    buildResult=BuildModel();
-    if(kInterrupted==result)
+    result=BuildModel();
+
+    if((!mIncremental) || (eOnStop==mStreamListenerState)){
+      DidBuildModel(mStreamStatus);
+    }
+    else {
       mParserContext->mDTD->WillInterruptParse();
     // If we're told to block the parser, we disable
     // all further parsing (and cache any data coming
     // in) until the parser is enabled.
-    if(NS_ERROR_HTMLPARSER_BLOCK==buildResult) {
-      EnableParser(PR_FALSE);
-    }
+      PRUint32 b1=NS_ERROR_HTMLPARSER_BLOCK;
+      if(NS_ERROR_HTMLPARSER_BLOCK==result) {
+        EnableParser(PR_FALSE);
+      }
+    }//if
   }
   return result;
 }
@@ -741,23 +676,27 @@ PRInt32 nsParser::ResumeParse() {
  *  @param   
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::BuildModel() {
+nsresult nsParser::BuildModel() {
   
-  nsDequeIterator e=mParserContext->mTokenDeque.End(); 
-  nsDequeIterator theMarkPos(e);
+  //nsDequeIterator e=mParserContext->mTokenDeque.End(); 
 
-  if(!mParserContext->mCurrentPos)
-    mParserContext->mCurrentPos=new nsDequeIterator(mParserContext->mTokenDeque.Begin());
+//  if(!mParserContext->mCurrentPos)
+//    mParserContext->mCurrentPos=new nsDequeIterator(mParserContext->mTokenDeque.Begin());
 
     //Get the root DTD for use in model building...
   CParserContext* theRootContext=mParserContext;
-  while(theRootContext->mPrevContext)
+  while(theRootContext->mPrevContext) {
     theRootContext=theRootContext->mPrevContext;
+  }
 
   nsIDTD* theRootDTD=theRootContext->mDTD;
-  
-  PRInt32 result=kNoError;
-  while((kNoError==result) && ((*mParserContext->mCurrentPos<e))){
+  nsresult result=NS_OK;
+  if(theRootDTD) {
+    result=theRootDTD->BuildModel(this);
+  }
+
+/*  
+  while((NS_OK==result) && ((*mParserContext->mCurrentPos<e))){
     mMinorIteration++;
     CToken* theToken=(CToken*)mParserContext->mCurrentPos->GetCurrent();
     theMarkPos=*mParserContext->mCurrentPos;
@@ -771,6 +710,7 @@ PRInt32 nsParser::BuildModel() {
     //The current context has a deque full of them,
     //and the ones that preceed currentpos are no
     //longer needed. Let's recycle them.
+  
   nsITokenRecycler* theRecycler=theRootDTD->GetTokenRecycler();
   if(theRecycler) {
     nsDeque&  theDeque=mParserContext->mTokenDeque;
@@ -785,54 +725,12 @@ PRInt32 nsParser::BuildModel() {
     }
     mParserContext->mCurrentPos->First();
   }
+  */
 
   return result;
 }
 
 
-/**
- * This method provides access to the topmost token in the tokenDeque.
- * The token is not really removed from the list.
- * @update	gess8/2/98
- * @return  ptr to token
- */
-CToken* nsParser::PeekToken() {
-  CToken* theToken=0;
-  if(mParserContext)
-    if(mParserContext->mCurrentPos)
-      theToken=(CToken*)mParserContext->mCurrentPos->GetCurrent();
-  return theToken;
-}
-
-
-/**
- * This method provides access to the topmost token in the tokenDeque.
- * The token is really removed from the list; if the list is empty we return 0.
- * @update	gess8/2/98
- * @return  ptr to token or NULL
- */
-CToken* nsParser::PopToken() {
-  CToken* theToken=0;
-  if(mParserContext)
-    if(mParserContext->mCurrentPos) {
-      theToken=(CToken*)mParserContext->mCurrentPos->GetCurrent();
-      ++(*mParserContext->mCurrentPos);
-    }
-  return theToken;
-}
-
-
-/**
- * 
- * @update	gess8/2/98
- * @param 
- * @return
- */
-CToken* nsParser::PushToken(CToken* theToken) {
-  mParserContext->mTokenDeque.Push(theToken);
-	return theToken;
-}
-
 /*******************************************************************
   These methods are used to talk to the netlib system...
  *******************************************************************/
@@ -883,6 +781,11 @@ nsParser::OnStatus(nsIURL* aURL, const PRUnichar* aMsg)
   return result;
 }
 
+#undef _DEBUGDUMPFILE 
+#ifdef _DEBUGDUMPFILE
+  fstream* gDumpFile;
+#endif
+
 /**
  *  
  *  
@@ -900,72 +803,77 @@ nsresult nsParser::OnStartBinding(nsIURL* aURL, const char *aSourceType){
   mParserContext->mAutoDetectStatus=eUnknownDetect;
   mParserContext->mDTD=0;
   mParserContext->mSourceType=aSourceType;
-  return kNoError;
+
+#ifdef _DEBUGDUMPFILE
+  gDumpFile = new fstream("c:/temp/out.file",ios::trunc);
+#endif
+
+  return NS_OK;
 }
 
 /**
  *  
  *  
- *  @update  vidur 12/11/98
+ *  @update  gess 1/4/99
  *  @param   pIStream contains the input chars
  *  @param   length is the number of bytes waiting input
  *  @return  error code (usually 0)
  */
-nsresult nsParser::OnDataAvailable(nsIURL* aURL, nsIInputStream *pIStream, PRUint32 length){
+nsresult nsParser::OnDataAvailable(nsIURL* aURL, nsIInputStream *pIStream, PRUint32 aLength){
 /*  if (nsnull != mListener) {
       //Rick potts removed this.
       //Does it need to be here?
-    mListener->OnDataAvailable(pIStream, length);
+    mListener->OnDataAvailable(pIStream, aLength);
   }
 */
   NS_PRECONDITION(((eOnStart==mStreamListenerState)||(eOnDataAvail==mStreamListenerState)),kOnStartNotCalled);
 
-  mStreamListenerState=eOnDataAvail;  
   if(eInvalidDetect==mParserContext->mAutoDetectStatus) {
     if(mParserContext->mScanner) {
       mParserContext->mScanner->GetBuffer().Truncate();
     }
   }
 
-  PRUint32 len=1; //init to a non-zero value
-
-  if(!mParserContext->mTransferBuffer)
-    mParserContext->mTransferBuffer = new char[CParserContext::eTransferBufferSize+1];
-
-  while (len > 0) {
-    nsresult rv = pIStream->Read(mParserContext->mTransferBuffer, 0,
-                                 mParserContext->eTransferBufferSize, &len);
-    if((rv == NS_OK) && (len>0)) {
-      if(mParserFilter)
-         mParserFilter->RawBuffer(mParserContext->mTransferBuffer, &len);
-
-      // XXX kipp was here: this is a temporary piece of code that
-      // fixes up the data in the transfer buffer so that the 8 bit
-      // ascii is mapped to ucs2 properly. The problem is that for the
-      // default character set, some web pages use illegal codes (0x80
-      // to 0x9f, inclusive); we already have code to map entities
-      // properly in this range. This code maps raw stream data the
-      // same way.
-      PRUnichar buf[CParserContext::eTransferBufferSize];
-      PRUnichar* dst = buf;
-      const PRUnichar* table = gToUCS2;
-      const char* src = mParserContext->mTransferBuffer;
-      const char* end = src + len;
-      while (src < end) {
-        unsigned char ch = *(unsigned char*)src;
-        *dst++ = table[ch];
-        src++;
-      }
-
-      mParserContext->mScanner->Append(buf, len);
-
-      if(eUnknownDetect==mParserContext->mAutoDetectStatus) {
-        if(eValidDetect==AutoDetectContentType(mParserContext->mScanner->GetBuffer(),mParserContext->mSourceType)) {
-          WillBuildModel(mParserContext->mScanner->GetFilename(),0);
-        } //if
-      }
-    } //if
+  PRInt32 newLength=(aLength>mParserContext->mTransferBufferSize) ? aLength : mParserContext->mTransferBufferSize;
+  if(!mParserContext->mTransferBuffer) {
+    mParserContext->mTransferBufferSize=newLength;
+    mParserContext->mTransferBuffer=new char[newLength+20];
   }
+  else if(aLength>mParserContext->mTransferBufferSize){
+    delete [] mParserContext->mTransferBuffer;
+    mParserContext->mTransferBufferSize=newLength;
+    mParserContext->mTransferBuffer=new char[newLength+20];
+  }
+
+  PRUint32  theTotalRead=0; 
+  PRUint32  theNumRead=1;   //init to a non-zero value
+  int       theStartPos=0;
+  nsresult result=NS_OK;
+
+  while ((theNumRead>0) && (aLength>theTotalRead) && (NS_OK==result)) {
+    result = pIStream->Read(mParserContext->mTransferBuffer, 0, aLength, &theNumRead);
+    if((result == NS_OK) && (theNumRead>0)) {
+      theTotalRead+=theNumRead;
+      if(mParserFilter)
+         mParserFilter->RawBuffer(mParserContext->mTransferBuffer, &theNumRead);
+
+#ifdef  NS_DEBUG
+      int index=0;
+      for(index=0;index<10;index++)
+        mParserContext->mTransferBuffer[theNumRead+index]=0;
+#endif
+
+      mParserContext->mScanner->Append(mParserContext->mTransferBuffer,theNumRead);
+      nsString& theBuffer=mParserContext->mScanner->GetBuffer();
+      theBuffer.ToUCS2(theStartPos);
+
+#ifdef _DEBUGDUMPFILE
+      (*gDumpFile) << mParserContext->mTransferBuffer;
+#endif
+
+    } //if
+    theStartPos+=theNumRead;
+  }//while
 
   if (mParserEnabled) {
     return ResumeParse();
@@ -976,7 +884,8 @@ nsresult nsParser::OnDataAvailable(nsIURL* aURL, nsIInputStream *pIStream, PRUin
 }
 
 /**
- *  
+ *  This is called by the networking library once the last block of data
+ *  has been collected from the net.
  *  
  *  @update  vidur 12/11/98
  *  @param   
@@ -988,14 +897,27 @@ nsresult nsParser::OnStopBinding(nsIURL* aURL, nsresult status, const PRUnichar*
   nsresult result;
   // If the parser isn't enabled, we don't finish parsing till
   // it is reenabled.
+
   if (mParserEnabled) {
-    result=DidBuildModel(status);
+    return ResumeParse();
   }
+  else {
+    return NS_OK;
+  }
+
   // XXX Should we wait to notify our observers as well if the
   // parser isn't yet enabled?
   if (nsnull != mObserver) {
     mObserver->OnStopBinding(aURL, status, aMsg);
   }
+
+#ifdef _DEBUGDUMPFILE
+  if(gDumpFile){
+    gDumpFile->close();
+    delete gDumpFile;
+  }
+#endif
+
   return result;
 }
 
@@ -1028,34 +950,21 @@ PRBool nsParser::WillTokenize(){
  *  @update  gess 3/25/98
  *  @return  error code -- 0 if ok, non-zero if error.
  */
-PRInt32 nsParser::Tokenize(){
-  CToken* theToken=0;
-  PRInt32 result=kNoError;
+nsresult nsParser::Tokenize(){
+
+  nsresult result=NS_OK;
 
   ++mMajorIteration;
 
   WillTokenize();
-  while(kNoError==result) {
+  nsITokenizer* theTokenizer=mParserContext->mDTD->GetTokenizer();
+  while(NS_SUCCEEDED(result)) {
     mParserContext->mScanner->Mark();
-    result=mParserContext->mDTD->ConsumeToken(theToken,this);
-    if(kNoError==result) {
-      if(theToken) {
-
-  #ifdef VERBOSE_DEBUG
-          theToken->DebugDumpToken(cout);
-  #endif
-        mParserContext->mTokenDeque.Push(theToken);
-      }
-
-    }
-    else {
-      if(theToken)
-        delete theToken;
+    result=theTokenizer->ConsumeToken(*mParserContext->mScanner);
+    if(!NS_SUCCEEDED(result)) {
       mParserContext->mScanner->RewindToMark();
     }
   } 
-  if(kProcessComplete==result)
-    result=NS_OK;
   DidTokenize();
   return result;
 }
@@ -1084,6 +993,7 @@ PRBool nsParser::DidTokenize(){
  *  @return  
  */
 void nsParser::DebugDumpTokens(ostream& out) {
+/*
   nsDequeIterator b=mParserContext->mTokenDeque.Begin();
   nsDequeIterator e=mParserContext->mTokenDeque.End();
 
@@ -1092,6 +1002,7 @@ void nsParser::DebugDumpTokens(ostream& out) {
     theToken=(CToken*)(b++);
     theToken->DebugDumpToken(out);
   }
+*/
 }
 
 
@@ -1105,6 +1016,7 @@ void nsParser::DebugDumpTokens(ostream& out) {
  *  @return  
  */
 void nsParser::DebugDumpSource(ostream& out) {
+/*
   nsDequeIterator b=mParserContext->mTokenDeque.Begin();
   nsDequeIterator e=mParserContext->mTokenDeque.End();
 
@@ -1113,7 +1025,7 @@ void nsParser::DebugDumpSource(ostream& out) {
     theToken=(CToken*)(b++);
     theToken->DebugDumpSource(out);
   }
-
+*/
 }
 
 
diff --git a/parser/htmlparser/src/nsParser.h b/parser/htmlparser/src/nsParser.h
index 7aa215aff6b0..d71507924328 100644
--- a/parser/htmlparser/src/nsParser.h
+++ b/parser/htmlparser/src/nsParser.h
@@ -58,7 +58,6 @@
 #include "nsIParser.h"
 #include "nsDeque.h"
 #include "nsParserNode.h"
-#include "nsParserTypes.h"
 #include "nsIURL.h"
 #include "CParserContext.h"
 #include "nsParserCIID.h"
@@ -66,7 +65,7 @@
 class IContentSink;
 class nsIHTMLContentSink;
 class nsIDTD;
-class CScanner;
+class nsScanner;
 class nsIParserFilter;
 #include <fstream.h>
 
@@ -136,7 +135,7 @@ friend class CTokenHandler;
      *  @update  gess 6/9/98
      *  @return  ptr to scanner
      */
-    virtual CScanner* GetScanner(void);
+    virtual nsScanner* GetScanner(void);
 
     /**
      * Cause parser to parse input from given URL 
@@ -145,7 +144,7 @@ friend class CTokenHandler;
      * @param   aListener is a listener to forward notifications to
      * @return  TRUE if all went well -- FALSE otherwise
      */
-    virtual PRInt32 Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aEnableVerify=PR_FALSE);
+    virtual nsresult Parse(nsIURL* aURL,nsIStreamObserver* aListener,PRBool aEnableVerify=PR_FALSE);
 
     /**
      * Cause parser to parse input from given stream 
@@ -153,7 +152,7 @@ friend class CTokenHandler;
      * @param   aStream is the i/o source
      * @return  TRUE if all went well -- FALSE otherwise
      */
-    virtual PRInt32 Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE);
+    virtual nsresult Parse(fstream& aStream,PRBool aEnableVerify=PR_FALSE);
 
     /**
      * @update	gess5/11/98
@@ -161,7 +160,7 @@ friend class CTokenHandler;
      * @param   appendTokens tells us whether we should insert tokens inline, or append them.
      * @return  TRUE if all went well -- FALSE otherwise
      */
-    virtual PRInt32 Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE);
+    virtual nsresult Parse(nsString& aSourceBuffer,PRBool anHTMLString,PRBool aEnableVerify=PR_FALSE);
 
 
     /**
@@ -180,11 +179,7 @@ friend class CTokenHandler;
      * @update	gess5/11/98
      * @return  TRUE if all went well, otherwise FALSE
      */
-    virtual PRInt32 ResumeParse();
-
-		virtual CToken* PushToken(CToken* theToken);
-		virtual CToken* PopToken();
-		virtual CToken* PeekToken();
+    virtual nsresult ResumeParse(nsIDTD* mDefaultDTD=0);
 
     /**
      *  This debug routine is used to cause the tokenizer to
@@ -217,7 +212,7 @@ protected:
      * @param 
      * @return
      */
-    PRInt32 WillBuildModel(nsString& aFilename,nsIDTD* mDefaultDTD=0);
+    nsresult WillBuildModel(nsString& aFilename,nsIDTD* mDefaultDTD=0);
 
     /**
      * 
@@ -225,7 +220,7 @@ protected:
      * @param 
      * @return
      */
-    PRInt32 DidBuildModel(PRInt32 anErrorCode);
+    nsresult DidBuildModel(nsresult anErrorCode);
 
     /**
      * This method gets called when the tokens have been consumed, and it's time
@@ -233,7 +228,7 @@ protected:
      * @update	gess5/11/98
      * @return  YES if model building went well -- NO otherwise.
      */
-    virtual PRInt32 BuildModel(void);
+    virtual nsresult BuildModel(void);
     
 private:
 
@@ -261,7 +256,7 @@ private:
      *  @update  gess 3/25/98
      *  @return  error code 
      */
-    PRInt32 Tokenize();
+    nsresult Tokenize();
 
     /**
      *  This is the tail-end of the code sandwich for the
@@ -320,6 +315,7 @@ protected:
     nsString            mCommand;
     eStreamState        mStreamListenerState; //this is really only here for debug purposes.
     PRInt32             mStreamStatus;
+    PRBool              mIncremental;
 };
 
 
diff --git a/parser/htmlparser/src/nsParserNode.cpp b/parser/htmlparser/src/nsParserNode.cpp
index d4bbcc4069ec..36bfb4891b36 100644
--- a/parser/htmlparser/src/nsParserNode.cpp
+++ b/parser/htmlparser/src/nsParserNode.cpp
@@ -21,6 +21,7 @@
 #include "string.h"
 #include "nsHTMLTokens.h"
 #include "nshtmlpars.h"
+#include "nsITokenizer.h"
 
 const nsAutoString nsCParserNode::mEmptyString("");
 
@@ -35,24 +36,34 @@ static NS_DEFINE_IID(kIParserNodeIID, NS_IPARSER_NODE_IID);
  *  @param   aToken -- token to init internal token
  *  @return  
  */
-nsCParserNode::nsCParserNode(CToken* aToken,PRInt32 aLineNumber): nsIParserNode() {
+nsCParserNode::nsCParserNode(CToken* aToken,PRInt32 aLineNumber,nsITokenRecycler* aRecycler): nsIParserNode() {
   NS_INIT_REFCNT();
   mAttributeCount=0;
   mLineNumber=aLineNumber;
   mToken=aToken;
   memset(mAttributes,0,sizeof(mAttributes));
-  mSkippedContent=nsnull;
+  mSkippedContent=0;
+  mRecycler=aRecycler;
 }
 
 
 /**
  *  default destructor
- *  
+ *  NOTE: We intentionally DONT recycle mToken here.
+ *        It may get cached for use elsewhere
  *  @update  gess 3/25/98
  *  @param   
  *  @return  
  */
 nsCParserNode::~nsCParserNode() {
+  if(mRecycler) {
+    int index=0;
+    for(index=0;index<mAttributeCount;index++){
+      mRecycler->RecycleToken(mAttributes[index]);
+    }
+    if(mSkippedContent)
+      mRecycler->RecycleToken(mSkippedContent);
+  }
 }
 
 NS_IMPL_ADDREF(nsCParserNode)
diff --git a/parser/htmlparser/src/nsParserNode.h b/parser/htmlparser/src/nsParserNode.h
index 5da39d67a3eb..d7ef81d4f4ba 100644
--- a/parser/htmlparser/src/nsParserNode.h
+++ b/parser/htmlparser/src/nsParserNode.h
@@ -41,6 +41,7 @@
 #include "nsString.h"
 #include "nsParserCIID.h"
 
+class nsITokenRecycler;
 
 class nsCParserNode :  public nsIParserNode {
   enum {eMaxAttr=20};
@@ -54,7 +55,7 @@ class nsCParserNode :  public nsIParserNode {
      * @update	gess5/11/98
      * @param   aToken is the token this node "refers" to
      */
-    nsCParserNode(CToken* aToken=nsnull,PRInt32 aLineNumber=1);
+    nsCParserNode(CToken* aToken=nsnull,PRInt32 aLineNumber=1,nsITokenRecycler* aRecycler=0);
 
     /**
      * Destructor
@@ -169,6 +170,8 @@ class nsCParserNode :  public nsIParserNode {
     CToken*   mToken;
     CToken*   mAttributes[eMaxAttr]; // XXX Ack! This needs to be dynamic! 
     CToken*   mSkippedContent;
+    nsITokenRecycler* mRecycler;
+    
     // nsAutoString  mName;
 
     static const nsAutoString  mEmptyString;
diff --git a/parser/htmlparser/src/nsParserTypes.h b/parser/htmlparser/src/nsParserTypes.h
index 090aa7268ac4..9825affaf724 100644
--- a/parser/htmlparser/src/nsParserTypes.h
+++ b/parser/htmlparser/src/nsParserTypes.h
@@ -27,54 +27,6 @@
 #ifndef PARSER_TYPES__
 #define PARSER_TYPES__
 
-/* ===========================================================*
-  Some useful constants...
- * ===========================================================*/
-
-#include "prtypes.h"
-#include "nsError.h"
-
-
-const PRInt32   kEOF              = 10000;
-const PRInt32   kUnknownError     = 10001;
-const PRInt32   kCantPropagate    = 10002;
-const PRInt32   kContextMismatch  = 10003;
-const PRInt32   kBadFilename      = 10004;
-const PRInt32   kBadURL           = 10005;
-const PRInt32   kInterrupted      = 10006;
-const PRInt32   kProcessComplete  = 10007;
-const PRInt32   kInvalidParserContext = 10008;
-const PRInt32   kNotFound         = -1;
-const PRInt32   kNoError          = NS_OK;
-
-const PRUint32  kNewLine          = '\n';
-const PRUint32  kCR               = '\r';
-const PRUint32  kLF               = '\n';
-const PRUint32  kTab              = '\t';
-const PRUint32  kSpace            = ' ';
-const PRUint32  kQuote            = '"';
-const PRUint32  kApostrophe       = '\'';
-const PRUint32  kLessThan         = '<';
-const PRUint32  kGreaterThan      = '>';
-const PRUint32  kAmpersand        = '&';
-const PRUint32  kForwardSlash     = '/';
-const PRUint32  kBackSlash        = '\\';
-const PRUint32  kEqual            = '=';
-const PRUint32  kMinus            = '-';
-const PRUint32  kPlus             = '+';
-const PRUint32  kExclamation      = '!';
-const PRUint32  kSemicolon        = ';';
-const PRUint32  kHashsign         = '#';
-const PRUint32  kAsterisk         = '*';
-const PRUint32  kUnderbar         = '_';
-const PRUint32  kComma            = ',';
-const PRUint32  kLeftParen        = '(';
-const PRUint32  kRightParen       = ')';
-const PRUint32  kLeftBrace        = '{';
-const PRUint32  kRightBrace       = '}';
-const PRUint32  kQuestionMark     = '?';
-const PRUint32  kLeftSquareBracket  = '[';
-const PRUint32  kRightSquareBracket = ']';
 
 #endif
 
diff --git a/parser/htmlparser/src/nsScanner.cpp b/parser/htmlparser/src/nsScanner.cpp
index 5c1c6c8363c8..49f6df5269e3 100644
--- a/parser/htmlparser/src/nsScanner.cpp
+++ b/parser/htmlparser/src/nsScanner.cpp
@@ -40,11 +40,11 @@ const int   kBufsize=64;
  *  @param   aMode represents the parser mode (nav, other)
  *  @return  
  */
-CScanner::CScanner(nsString& anHTMLString) : 
+nsScanner::nsScanner(nsString& anHTMLString) : 
   mBuffer(anHTMLString), mFilename("") 
 {
   mTotalRead=mBuffer.Length();
-  mIncremental=PR_FALSE;
+  mIncremental=PR_TRUE;
   mOwnsStream=PR_FALSE;
   mOffset=0;
   mMarkPos=-1;
@@ -60,7 +60,7 @@ CScanner::CScanner(nsString& anHTMLString) :
  *  @param   aFilename --
  *  @return  
  */
-CScanner::CScanner(nsString& aFilename,PRBool aCreateStream) : 
+nsScanner::nsScanner(nsString& aFilename,PRBool aCreateStream) : 
     mBuffer(""), mFilename(aFilename) 
 {
   mIncremental=PR_TRUE;
@@ -92,7 +92,7 @@ CScanner::CScanner(nsString& aFilename,PRBool aCreateStream) :
  *  @param   aFilename --
  *  @return  
  */
-CScanner::CScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership) :
+nsScanner::nsScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership) :
     mBuffer(""), mFilename(aFilename)
 {    
   mIncremental=PR_TRUE;
@@ -111,7 +111,7 @@ CScanner::CScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership)
  *  @param   
  *  @return  
  */
-CScanner::~CScanner() {
+nsScanner::~nsScanner() {
   if(mFileStream) {
     mFileStream->close();
     if(mOwnsStream)
@@ -130,7 +130,7 @@ CScanner::~CScanner() {
  *  @param   
  *  @return  
  */
-PRUint32 CScanner::RewindToMark(void){
+PRUint32 nsScanner::RewindToMark(void){
   mOffset=mMarkPos;
   return mOffset;
 }
@@ -145,7 +145,7 @@ PRUint32 CScanner::RewindToMark(void){
  *  @param   
  *  @return  
  */
-PRUint32 CScanner::Mark(void){
+PRUint32 nsScanner::Mark(void){
   if((mOffset>0) && (mOffset>eBufferSizeThreshold)) {
     mBuffer.Cut(0,mOffset);   //delete chars up to mark position
     mOffset=0;
@@ -162,7 +162,7 @@ PRUint32 CScanner::Mark(void){
  * @update  gess4/3/98
  * @return  error code 
  */
-PRBool CScanner::Append(nsString& aBuffer) {
+PRBool nsScanner::Append(nsString& aBuffer) {
   mBuffer.Append(aBuffer);
   mTotalRead+=aBuffer.Length();
   return PR_TRUE;
@@ -175,13 +175,13 @@ PRBool CScanner::Append(nsString& aBuffer) {
  *  @param   
  *  @return  
  */
-PRBool CScanner::Append(const char* aBuffer, PRUint32 aLen){
+PRBool nsScanner::Append(const char* aBuffer, PRUint32 aLen){
   mBuffer.Append(aBuffer,aLen);
   mTotalRead+=aLen;
   return PR_TRUE;
 }
 
-PRBool CScanner::Append(const PRUnichar* aBuffer, PRInt32 aLen){
+PRBool nsScanner::Append(const PRUnichar* aBuffer, PRUint32 aLen){
   mBuffer.Append(aBuffer,aLen);
   mTotalRead+=aLen;
   return PR_TRUE;
@@ -193,8 +193,8 @@ PRBool CScanner::Append(const PRUnichar* aBuffer, PRInt32 aLen){
  * @update  gess4/3/98
  * @return  error code
  */
-nsresult CScanner::FillBuffer(void) {
-  nsresult anError=NS_OK;
+nsresult nsScanner::FillBuffer(void) {
+  nsresult result=NS_OK;
 
   if(!mFileStream) {
     //This is DEBUG code!!!!!!  XXX DEBUG XXX
@@ -205,7 +205,7 @@ nsresult CScanner::FillBuffer(void) {
       mBuffer.Append((const char*)kBadHTMLText);
       mBuffer.Append(mFilename);
     }
-    else anError=(mIncremental) ? kInterrupted : kEOF;
+    else result=kEOF;
   }
   else {
     PRInt32 numread=0;
@@ -220,12 +220,12 @@ nsresult CScanner::FillBuffer(void) {
       }
     }
     mOffset=mBuffer.Length();
-    if((0<numread) && (0==anError))
+    if((0<numread) && (0==result))
       mBuffer.Append((const char*)buf,numread);
     mTotalRead+=mBuffer.Length();
   }
 
-  return anError;
+  return result;
 }
 
 /**
@@ -233,9 +233,9 @@ nsresult CScanner::FillBuffer(void) {
  *  
  *  @update  gess 5/12/98
  *  @param   
- *  @return  0=!eof 1=eof kInterrupted=interrupted
+ *  @return  0=!eof 1=eof 
  */
-nsresult CScanner::Eof() {
+nsresult nsScanner::Eof() {
   nsresult theError=NS_OK;
 
   if(mOffset>=(PRUint32)mBuffer.Length()) {
@@ -243,7 +243,7 @@ nsresult CScanner::Eof() {
   }
   
   if(NS_OK==theError) {
-    if (0==mBuffer.Length()) {
+    if (0==(PRUint32)mBuffer.Length()) {
       return kEOF;
     }
   }
@@ -258,9 +258,10 @@ nsresult CScanner::Eof() {
  *  @param   
  *  @return  error code reflecting read status
  */
-nsresult CScanner::GetChar(PRUnichar& aChar) {
+nsresult nsScanner::GetChar(PRUnichar& aChar) {
   nsresult result=NS_OK;
   
+  aChar=0;
   if(mOffset>=(PRUint32)mBuffer.Length()) 
     result=Eof();
 
@@ -279,9 +280,9 @@ nsresult CScanner::GetChar(PRUnichar& aChar) {
  *  @param   
  *  @return  
  */
-nsresult CScanner::Peek(PRUnichar& aChar) {
+nsresult nsScanner::Peek(PRUnichar& aChar) {
   nsresult result=NS_OK;
-  
+  aChar=0;  
   if(mOffset>=(PRUint32)mBuffer.Length()) 
     result=Eof();
 
@@ -299,7 +300,7 @@ nsresult CScanner::Peek(PRUnichar& aChar) {
  *  @param   
  *  @return  error code
  */
-nsresult CScanner::PutBack(PRUnichar aChar) {
+nsresult nsScanner::PutBack(PRUnichar aChar) {
   if(mOffset>0)
     mOffset--;
   else mBuffer.Insert(aChar,0);
@@ -314,7 +315,7 @@ nsresult CScanner::PutBack(PRUnichar aChar) {
  *  @param   
  *  @return  error status
  */
-nsresult CScanner::SkipWhitespace(void) {
+nsresult nsScanner::SkipWhitespace(void) {
   static nsAutoString chars(" \n\r\t");
   return SkipOver(chars);
 }
@@ -326,7 +327,7 @@ nsresult CScanner::SkipWhitespace(void) {
  *  @param   
  *  @return  error code
  */
-nsresult CScanner::SkipOver(PRUnichar aSkipChar){
+nsresult nsScanner::SkipOver(PRUnichar aSkipChar){
   PRUnichar ch=0;
   nsresult   result=NS_OK;
 
@@ -350,16 +351,16 @@ nsresult CScanner::SkipOver(PRUnichar aSkipChar){
  *  @param   aSkipSet is an ordered string.
  *  @return  error code
  */
-nsresult CScanner::SkipOver(nsString& aSkipSet){
-  PRUnichar ch=0;
-  nsresult   result=NS_OK;
+nsresult nsScanner::SkipOver(nsString& aSkipSet){
+  PRUnichar theChar=0;
+  nsresult  result=NS_OK;
 
   while(NS_OK==result) {
-    result=GetChar(ch);
+    result=GetChar(theChar);
     if(NS_OK == result) {
-      PRInt32 pos=aSkipSet.Find(ch);
+      PRInt32 pos=aSkipSet.Find(theChar);
       if(kNotFound==pos) {
-        PutBack(ch);
+        PutBack(theChar);
         break;
       }
     } 
@@ -377,7 +378,7 @@ nsresult CScanner::SkipOver(nsString& aSkipSet){
  *           contains chars you're looking for
  *  @return  error code
  */
-nsresult CScanner::SkipTo(nsString& aValidSet){
+nsresult nsScanner::SkipTo(nsString& aValidSet){
   PRUnichar ch=0;
   nsresult  result=NS_OK;
 
@@ -405,7 +406,7 @@ nsresult CScanner::SkipTo(nsString& aValidSet){
  *           characters you want to skip
  *  @return  error code
  */
-nsresult CScanner::SkipPast(nsString& aValidSet){
+nsresult nsScanner::SkipPast(nsString& aValidSet){
   NS_NOTYETIMPLEMENTED("Error: SkipPast not yet implemented.");
   return NS_OK;
 }
@@ -420,7 +421,7 @@ nsresult CScanner::SkipPast(nsString& aValidSet){
  *           valid characters
  *  @return  error code
  */
-nsresult CScanner::ReadWhile(nsString& aString,
+nsresult nsScanner::ReadWhile(nsString& aString,
                              nsString& aValidSet,
                              PRBool anOrderedSet,
                              PRBool addTerminal){
@@ -456,7 +457,7 @@ nsresult CScanner::ReadWhile(nsString& aString,
  *           the set of INVALID characters
  *  @return  error code
  */
-nsresult CScanner::ReadUntil(nsString& aString,
+nsresult nsScanner::ReadUntil(nsString& aString,
                              nsString& aTerminalSet,
                              PRBool anOrderedSet,
                              PRBool addTerminal){
@@ -490,21 +491,21 @@ nsresult CScanner::ReadUntil(nsString& aString,
  *  @param   
  *  @return  error code
  */
-nsresult CScanner::ReadUntil(nsString& aString,
+nsresult nsScanner::ReadUntil(nsString& aString,
                              PRUnichar aTerminalChar,
                              PRBool addTerminal){
-  PRUnichar ch=0;
-  nsresult   result=NS_OK;
+  PRUnichar theChar=0;
+  nsresult  result=NS_OK;
 
   while(NS_OK==result) {
-    result=GetChar(ch);
-    if(ch==aTerminalChar) {
+    result=GetChar(theChar);
+    if(theChar==aTerminalChar) {
       if(addTerminal)
-        aString+=ch;
-      else PutBack(ch);
+        aString+=theChar;
+      else PutBack(theChar);
       break;
     }
-    else aString+=ch;
+    else aString+=theChar;
   }
   return result;
 }
@@ -515,7 +516,7 @@ nsresult CScanner::ReadUntil(nsString& aString,
  *  @param   
  *  @return  
  */
-nsString& CScanner::GetBuffer(void) {
+nsString& nsScanner::GetBuffer(void) {
   return mBuffer;
 }
 
@@ -527,7 +528,7 @@ nsString& CScanner::GetBuffer(void) {
  *  @update  gess 5/12/98
  *  @return  
  */
-nsString& CScanner::GetFilename(void) {
+nsString& nsScanner::GetFilename(void) {
   return mFilename;
 }
 
@@ -540,7 +541,7 @@ nsString& CScanner::GetFilename(void) {
  *  @return  
  */
 
-void CScanner::SelfTest(void) {
+void nsScanner::SelfTest(void) {
 #ifdef _DEBUG
 #endif
 }
diff --git a/parser/htmlparser/src/nsScanner.h b/parser/htmlparser/src/nsScanner.h
index d9e577c05ee6..39a8c046a913 100644
--- a/parser/htmlparser/src/nsScanner.h
+++ b/parser/htmlparser/src/nsScanner.h
@@ -33,12 +33,12 @@
 #define SCANNER
 
 #include "nsString.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "prtypes.h"
 #include <fstream.h>
 
 
-class CScanner {
+class nsScanner {
   public:
 
       /**
@@ -50,7 +50,7 @@ class CScanner {
        *  @param   aMode represents the parser mode (nav, other)
        *  @return  
        */
-      CScanner(nsString& anHTMLString);
+      nsScanner(nsString& anHTMLString);
 
       /**
        *  Use this constructor if you want i/o to be based on 
@@ -60,7 +60,7 @@ class CScanner {
        *  @param   aMode represents the parser mode (nav, other)
        *  @return  
        */
-      CScanner(nsString& aFilename,PRBool aCreateStream);
+      nsScanner(nsString& aFilename,PRBool aCreateStream);
 
       /**
        *  Use this constructor if you want i/o to be stream based.
@@ -69,10 +69,10 @@ class CScanner {
        *  @param   aMode represents the parser mode (nav, other)
        *  @return  
        */
-      CScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership=PR_TRUE);
+      nsScanner(nsString& aFilename,fstream& aStream,PRBool assumeOwnership=PR_TRUE);
 
 
-      ~CScanner();
+      ~nsScanner();
 
       /**
        *  retrieve next char from internal input stream
@@ -232,7 +232,7 @@ class CScanner {
        */
       PRBool Append(const char* aBuffer, PRUint32 aLen);
 
-      PRBool Append(const PRUnichar* aBuffer, PRInt32 aLen);
+      PRBool Append(const PRUnichar* aBuffer, PRUint32 aLen);
 
       /**
        *  
diff --git a/parser/htmlparser/src/nsToken.cpp b/parser/htmlparser/src/nsToken.cpp
index 18612f774c22..b8c082ba4bc5 100644
--- a/parser/htmlparser/src/nsToken.cpp
+++ b/parser/htmlparser/src/nsToken.cpp
@@ -100,7 +100,7 @@ void CToken::Reinitialize(PRInt32 aTag, const nsString& aString){
  *  @param  aScanner -- object to retrieve data from
  *  @return int error code
  */
-nsresult CToken::Consume(PRUnichar aChar,CScanner& aScanner) {
+nsresult CToken::Consume(PRUnichar aChar,nsScanner& aScanner) {
   nsresult result=NS_OK;
   return result;
 }
diff --git a/parser/htmlparser/src/nsToken.h b/parser/htmlparser/src/nsToken.h
index 399624f8554c..35afff804092 100644
--- a/parser/htmlparser/src/nsToken.h
+++ b/parser/htmlparser/src/nsToken.h
@@ -39,7 +39,7 @@
 #include "nsString.h"
 #include <iostream.h>
 
-class CScanner;
+class nsScanner;
 
 
 /**
@@ -147,7 +147,7 @@ class CToken {
      * @param   aScanner -- input source where token should get data
      * @return  error code (0 means ok)
      */
-    virtual nsresult Consume(PRUnichar aChar,CScanner& aScanner);
+    virtual nsresult Consume(PRUnichar aChar,nsScanner& aScanner);
 
     /**
      * Causes token to dump itself in debug form to given output stream
diff --git a/parser/htmlparser/src/nsTokenHandler.cpp b/parser/htmlparser/src/nsTokenHandler.cpp
index 361961db8b7a..12b5e380ca01 100644
--- a/parser/htmlparser/src/nsTokenHandler.cpp
+++ b/parser/htmlparser/src/nsTokenHandler.cpp
@@ -28,7 +28,7 @@
 #include "nsDebug.h"
 #include "nsIDTD.h"
 #include "nsToken.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 
 
 /**
@@ -74,8 +74,8 @@ PRInt32 CTokenHandler::GetTokenType(void){
  *  @param   
  *  @return  
  */
-PRInt32 CTokenHandler::operator()(CToken* aToken,nsIDTD* aDTD){
-  PRInt32 result=kNoError;
+nsresult CTokenHandler::operator()(CToken* aToken,nsIDTD* aDTD){
+  nsresult result=NS_OK;
   if((0!=aDTD) && (0!=mFP)) {
      result=(*mFP)(aToken,aDTD);
   }
diff --git a/parser/htmlparser/src/nsTokenHandler.h b/parser/htmlparser/src/nsTokenHandler.h
index e846f075774b..00e981b491a0 100644
--- a/parser/htmlparser/src/nsTokenHandler.h
+++ b/parser/htmlparser/src/nsTokenHandler.h
@@ -39,7 +39,7 @@ public:
   virtual               ~CTokenHandler();
                           
   virtual   PRInt32     GetTokenType(void);
-  virtual   PRInt32     operator()(CToken* aToken,nsIDTD* aDTD);
+  virtual   nsresult    operator()(CToken* aToken,nsIDTD* aDTD);
 
 protected:
             PRInt32     mType;
diff --git a/parser/htmlparser/src/nsValidDTD.cpp b/parser/htmlparser/src/nsValidDTD.cpp
index 1e4a8bf02c9d..24b56182ac52 100644
--- a/parser/htmlparser/src/nsValidDTD.cpp
+++ b/parser/htmlparser/src/nsValidDTD.cpp
@@ -36,7 +36,7 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
 
 #include "prenv.h"  //this is here for debug reasons...
@@ -133,6 +133,7 @@ CValidDTD::CValidDTD() : nsIDTD() {
   NS_INIT_REFCNT();
   mParser=0;
   mFilename=0;
+  mTokenizer=0;
 }
 
 /**
@@ -145,6 +146,17 @@ CValidDTD::CValidDTD() : nsIDTD() {
 CValidDTD::~CValidDTD(){
 }
 
+
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CValidDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -206,13 +218,26 @@ NS_IMETHODIMP CValidDTD::WillBuildModel(nsString& aFilename,PRBool aNotifySink,n
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CValidDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CValidDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+NS_IMETHODIMP CValidDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result=NS_OK;
 
   return result;
@@ -226,45 +251,13 @@ NS_IMETHODIMP CValidDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,ns
  *******************************************************************/
 
 /**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
  */
-NS_IMETHODIMP CValidDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser){
-
-  mParser=(nsParser*)aParser;
-  CScanner* theScanner=mParser->GetScanner();
-
-  PRUnichar aChar;
-  nsresult   result=theScanner->GetChar(aChar);
-
-  switch(result) {
-    case kEOF:
-      break;
-
-    case kInterrupted:
-      theScanner->RewindToMark();
-      break; 
-
-    case NS_OK:
-    default:
-      switch(aChar) {
-        case kLessThan:
-        default:
-          break;
-      } //switch
-      break; 
-  } //switch
-  if(NS_OK==result)
-    result=theScanner->Eof();
-  return result;
+nsITokenizer* CValidDTD::GetTokenizer(void){
+  return 0;
 }
 
 /**
diff --git a/parser/htmlparser/src/nsValidDTD.h b/parser/htmlparser/src/nsValidDTD.h
index de2da6d5be46..7d71bdcb65ff 100644
--- a/parser/htmlparser/src/nsValidDTD.h
+++ b/parser/htmlparser/src/nsValidDTD.h
@@ -44,7 +44,7 @@ class nsIDTDDebug;
 class nsIParserNode;
 class CITokenHandler;
 class nsParser;
-
+class nsITokenizer;
 
 
 class CValidDTD : public nsIDTD {
@@ -72,6 +72,8 @@ class CValidDTD : public nsIDTD {
      */
     virtual ~CValidDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      * Call this method if you want the DTD to construct a clone of itself.
      * @update	gess7/23/98
@@ -121,6 +123,16 @@ class CValidDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -129,7 +141,7 @@ class CValidDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -159,15 +171,12 @@ class CValidDTD : public nsIDTD {
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
+    nsITokenizer* GetTokenizer(void);
 
     /**
      * 
@@ -238,6 +247,7 @@ protected:
     nsParser*           mParser;
     nsIHTMLContentSink* mSink;
     char*               mFilename;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewValid_DTD(nsIDTD** aInstancePtrResult);
diff --git a/parser/htmlparser/src/nsViewSourceHTML.cpp b/parser/htmlparser/src/nsViewSourceHTML.cpp
index 010884c2ba07..cf1289f4b7b9 100644
--- a/parser/htmlparser/src/nsViewSourceHTML.cpp
+++ b/parser/htmlparser/src/nsViewSourceHTML.cpp
@@ -29,11 +29,12 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
 #include "nsDTDUtils.h"
 #include "nsIContentSink.h"
 #include "nsIHTMLContentSink.h"
+#include "nsHTMLTokenizer.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"  //this is here for debug reasons...
@@ -183,6 +184,7 @@ CViewSourceHTML::CViewSourceHTML() : nsIDTD(), mTokenDeque(gTokenKiller) {
   mSink=0;
   mFilename;
   mLineNumber=0;
+  mTokenizer=0;
   mIsHTML=PR_FALSE;
 }
 
@@ -197,6 +199,16 @@ CViewSourceHTML::~CViewSourceHTML(){
   mParser=0; //just to prove we destructed...
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CViewSourceHTML::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -286,13 +298,45 @@ NS_IMETHODIMP CViewSourceHTML::WillBuildModel(nsString& aFilename,PRBool aNotify
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CViewSourceHTML::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+
+  nsHTMLTokenizer*  theTokenizer=(nsHTMLTokenizer*)GetTokenizer();
+  nsITokenRecycler* theRecycler=GetTokenRecycler();
+  if(theTokenizer) {
+    while(NS_OK==result){
+      CToken* theToken=theTokenizer->PopToken();
+      if(theToken) {
+        result=HandleToken(theToken,aParser);
+        if(NS_SUCCEEDED(result)) {
+          theRecycler->RecycleToken(theToken);
+        }
+        else if(NS_ERROR_HTMLPARSER_BLOCK!=result){
+          theTokenizer->PushTokenFront(theToken);
+        }
+        // theRootDTD->Verify(kEmptyString,aParser);
+      }
+      else break;
+    }
+  }
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CViewSourceHTML::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+NS_IMETHODIMP CViewSourceHTML::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result= NS_OK;
 
   //ADD CODE HERE TO CLOSE OPEN CONTAINERS...
@@ -319,344 +363,27 @@ NS_IMETHODIMP CViewSourceHTML::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifyS
   return result;
 }
 
-
-static eHTMLTags gSkippedContentTags[]={ eHTMLTag_script, eHTMLTag_style,  eHTMLTag_title,  eHTMLTag_textarea};
-
-
 /**
  * 
- * @update	gess11/9/98
+ * @update	gess8/4/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CViewSourceHTML::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
-  
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(NS_OK==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-
-      //EEEEECCCCKKKK!!! 
-      //This code is confusing, so pay attention.
-      //If you're here, it's because we were in the midst of consuming a start
-      //tag but ran out of data (not in the stream, but in this *part* of the stream.
-      //For simplicity, we have to unwind our input. Therefore, we pop and discard
-      //any new tokens we've cued this round. Later we can get smarter about this.
-      if(NS_OK!=result) {
-        while(mTokenDeque.GetSize()>theDequeSize) {
-          delete (CToken*)mTokenDeque.PopBack();
-        }
-      }
-
-
-    } //if
-  } //if
-  return result;
+nsITokenRecycler* CViewSourceHTML::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
+ * Retrieve the preferred tokenizer for use by this DTD.
+ * @update	gess12/28/98
+ * @param   none
+ * @return  ptr to tokenizer
  */
-NS_IMETHODIMP CViewSourceHTML::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
-  if(aToken) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-    if(result) {
-      nsString& temp=aToken->GetStringValueXXX();
-      if(0==temp.Length()){
-        delete aToken;
-        aToken = nsnull;
-      }
-      else result=kNoError;
-    }
-  }
-  return result;
-}
-
-/**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  nsresult result=NS_OK;
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==NS_OK)) {
-    CAttributeToken* theToken= (CAttributeToken*)gTokenRecycler.CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
- 
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else if(NS_OK==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(NS_OK==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  theChar;
-   nsresult result=aScanner.GetChar(theChar);
-
-   if(NS_OK==result) {
-     if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==theChar) {
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       aScanner.PutBack(theChar);
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
-  nsresult result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created newline token that is parsing
- *  @return error code
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gess 5/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsresult result=aScanner.GetChar(aChar);
-
-  if(NS_OK==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(NS_OK==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=gTokenRecycler.CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
-          else aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_unknown,gEmpty);
-        }//if
-        break;
-
-      case kExclamation:
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-        break;
-
-      case kQuestionMark: //it must be an XML processing instruction...
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
-        break;
-
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (NS_OK==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
-}
-
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CViewSourceHTML::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return NS_OK;
-  }
-
-  mParser=(nsParser*)aParser;
-
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    PRUnichar theChar;
-    result=theScanner->GetChar(theChar);
-    switch(result) {
-      case kEOF:
-          //We convert from eof to complete here, because we never really tried to get data.
-          //All we did was try to see if data was available, which it wasn't.
-          //It's important to return process complete, so that controlling logic can know that
-          //everything went well, but we're done with token processing.
-        result=kProcessComplete;
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(theChar) {
-          case kLessThan:
-            result=ConsumeTag(theChar,*theScanner,aToken);
-            break;
-
-          case kAmpersand:
-            result=ConsumeEntity(theChar,*theScanner,aToken);
-            break;
-          
-          case kCR: case kLF:
-            result=ConsumeNewline(theChar,*theScanner,aToken);
-            break;
-          
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(theChar)) {
-              nsAutoString temp(theChar);
-              result=ConsumeText(temp,*theScanner,aToken);
-              break;
-            }
-            result=ConsumeWhitespace(theChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-//    if(NS_OK==result)
-//      result=theScanner->Eof(); 
-  } //if
-  return result;
+nsITokenizer* CViewSourceHTML::GetTokenizer(void) {
+  if(!mTokenizer)
+    mTokenizer=new nsHTMLTokenizer();
+  return mTokenizer;
 }
 
 /**
@@ -872,20 +599,16 @@ PRBool WriteTag(nsCParserNode& aNode,nsIContentSink& aSink,PRBool anEndToken,PRB
         SetStyle(eHTMLTag_b,PR_FALSE,aSink);
       }
 
-      { //next write the equal sign...
-        theString="=";
-        CTextToken theToken(theString);  
-        nsCParserNode theNode(&theToken,aNode.GetSourceLineNumber());
-        aSink.AddLeaf(theNode);
-      }
-
        //begin by writing the value...
       {
         SetColor("blue",PR_TRUE,aSink);
         theString=aNode.GetValueAt(theIndex);
-        CTextToken theToken(theString);  
-        nsCParserNode theNode(&theToken,aNode.GetSourceLineNumber());
-        aSink.AddLeaf(theNode);
+        if(0<theString.Length()){
+          theString.Insert('=',0);
+          CTextToken theToken(theString);  
+          nsCParserNode theNode(&theToken,aNode.GetSourceLineNumber());
+          aSink.AddLeaf(theNode);
+        }
         SetStyle(eHTMLTag_font,PR_FALSE,aSink);
       }
     }
@@ -975,15 +698,15 @@ NS_IMETHODIMP CViewSourceHTML::HandleToken(CToken* aToken,nsIParser* aParser) {
         if(0<attrCount){ //go collect the attributes...
           int attr=0;
           for(attr=0;attr<attrCount;attr++){
-            CToken* theToken=mParser->PeekToken();
+            CToken* theToken=mTokenizer->PeekToken();
             if(theToken)  {
               eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
               if(eToken_attribute==theType){
-                mParser->PopToken(); //pop it for real...
+                mTokenizer->PopToken(); //pop it for real...
                 theNode.AddAttribute(theToken);
               } 
             }
-            else return kInterrupted;
+            else return kEOF;
           }
         }
       }
@@ -1024,13 +747,3 @@ nsresult CViewSourceHTML::ReleaseTokenPump(nsITagHandler* aHandler){
   nsresult result=NS_OK;
   return result;
 }
-
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* CViewSourceHTML::GetTokenRecycler(void){
-  return &gTokenRecycler;
-}
diff --git a/parser/htmlparser/src/nsViewSourceHTML.h b/parser/htmlparser/src/nsViewSourceHTML.h
index 85cdecd0cabb..df401fb2f01e 100644
--- a/parser/htmlparser/src/nsViewSourceHTML.h
+++ b/parser/htmlparser/src/nsViewSourceHTML.h
@@ -44,7 +44,7 @@ class nsIDTDDebug;
 class nsIParserNode;
 class CITokenHandler;
 class nsParser;
-
+class nsITokenizer;
 
 
 class CViewSourceHTML: public nsIDTD {
@@ -63,6 +63,8 @@ class CViewSourceHTML: public nsIDTD {
      */
     CViewSourceHTML();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      *  
      *  
@@ -111,6 +113,16 @@ class CViewSourceHTML: public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -119,7 +131,7 @@ class CViewSourceHTML: public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -130,14 +142,21 @@ class CViewSourceHTML: public nsIDTD {
     NS_IMETHOD HandleToken(CToken* aToken,nsIParser* aParser);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
+    nsITokenizer* GetTokenizer(void);
+
+    
+    /**
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
+     */
+    virtual  nsITokenRecycler* GetTokenRecycler(void);
 
     /**
      *  This method causes all tokens to be dispatched to the given tag handler.
@@ -213,32 +232,18 @@ class CViewSourceHTML: public nsIDTD {
      */
     virtual PRBool IsContainer(PRInt32 aTag) const;
 
-    /**
-     * Retrieve a ptr to the global token recycler...
-     * @update	gess8/4/98
-     * @return  ptr to recycler (or null)
-     */
-    virtual nsITokenRecycler* GetTokenRecycler(void);
 
     static nsresult WriteText(nsString& aTextString,nsIContentSink& aSink,PRBool aPreserveText);
     
 protected:
 
-    NS_IMETHODIMP ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-
     nsParser*           mParser;
     nsIHTMLContentSink* mSink;
     nsString            mFilename;
     PRInt32             mLineNumber;
     nsDeque             mTokenDeque;
     PRBool              mIsHTML;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewViewSourceHTML(nsIDTD** aInstancePtrResult);
diff --git a/parser/htmlparser/src/nsWellFormedDTD.cpp b/parser/htmlparser/src/nsWellFormedDTD.cpp
index 9bd96e08e2a4..b58b92d966ca 100644
--- a/parser/htmlparser/src/nsWellFormedDTD.cpp
+++ b/parser/htmlparser/src/nsWellFormedDTD.cpp
@@ -29,11 +29,12 @@
 #include "nsCRT.h"
 #include "nsParser.h"
 #include "nsScanner.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsTokenHandler.h"
 #include "nsDTDUtils.h"
 #include "nsIContentSink.h"
 #include "nsIHTMLContentSink.h"
+#include "nsXMLTokenizer.h"
 
 #include "prenv.h"  //this is here for debug reasons...
 #include "prtypes.h"  //this is here for debug reasons...
@@ -136,6 +137,7 @@ CWellFormedDTD::CWellFormedDTD() : nsIDTD(), mTokenDeque(gTokenKiller) {
   mSink=0;
   mFilename;
   mLineNumber=0;
+  mTokenizer=0;
 }
 
 /**
@@ -149,6 +151,16 @@ CWellFormedDTD::~CWellFormedDTD(){
   mParser=0; //just to prove we destructed...
 }
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& CWellFormedDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -231,13 +243,45 @@ NS_IMETHODIMP CWellFormedDTD::WillBuildModel(nsString& aFilename,PRBool aNotifyS
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess  1/4/99
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP CWellFormedDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+
+  nsHTMLTokenizer*  theTokenizer=(nsHTMLTokenizer*)GetTokenizer();
+  nsITokenRecycler* theRecycler=GetTokenRecycler();
+  if(theTokenizer) {
+    while(NS_OK==result){
+      CToken* theToken=theTokenizer->PopToken();
+      if(theToken) {
+        result=HandleToken(theToken,aParser);
+        if(NS_SUCCEEDED(result)) {
+          theRecycler->RecycleToken(theToken);
+        }
+        else {
+          theTokenizer->PushTokenFront(theToken);
+        }
+        // theRootDTD->Verify(kEmptyString,aParser);
+      }
+      else break;
+    }
+  }
+  return result;
+}
+
 /**
  * 
  * @update	gess5/18/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CWellFormedDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+NS_IMETHODIMP CWellFormedDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result= NS_OK;
 
   //ADD CODE HERE TO CLOSE OPEN CONTAINERS...
@@ -270,411 +314,27 @@ NS_IMETHODIMP CWellFormedDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySi
   return result;
 }
 
-static eHTMLTags gSkippedContentTags[]={ eHTMLTag_script, eHTMLTag_style,  eHTMLTag_title,  eHTMLTag_textarea};
-
-
 /**
  * 
- * @update	gess11/9/98
+ * @update	gess8/4/98
  * @param 
  * @return
  */
-NS_IMETHODIMP CWellFormedDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_start,eHTMLTag_unknown,gEmpty);
-  
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(NS_OK==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-
-      //EEEEECCCCKKKK!!! 
-      //This code is confusing, so pay attention.
-      //If you're here, it's because we were in the midst of consuming a start
-      //tag but ran out of data (not in the stream, but in this *part* of the stream.
-      //For simplicity, we have to unwind our input. Therefore, we pop and discard
-      //any new tokens we've cued this round. Later we can get smarter about this.
-      if(NS_OK!=result) {
-        while(mTokenDeque.GetSize()>theDequeSize) {
-          delete (CToken*)mTokenDeque.PopBack();
-        }
-      }
-
-
-    } //if
-  } //if
-  return result;
+nsITokenRecycler* CWellFormedDTD::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
+ * Retrieve the preferred tokenizer for use by this DTD.
+ * @update	gess12/28/98
+ * @param   none
+ * @return  ptr to tokenizer
  */
-NS_IMETHODIMP CWellFormedDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_text,eHTMLTag_text,aString);
-  if(aToken) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-    if(result) {
-      nsString& temp=aToken->GetStringValueXXX();
-      if(0==temp.Length()){
-        delete aToken;
-        aToken = nsnull;
-      }
-      else result=kNoError;
-    }
-  }
-  return result;
-}
-
-/**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gess 3/25/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  nsresult result=NS_OK;
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==NS_OK)) {
-    CAttributeToken* theToken= (CAttributeToken*)gTokenRecycler.CreateTokenOfType(eToken_attribute,eHTMLTag_unknown,gEmpty);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
- 
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else if(NS_OK==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(NS_OK==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  theChar;
-   nsresult result=aScanner.GetChar(theChar);
-
-   if(NS_OK==result) {
-     if(nsString::IsAlpha(theChar)) { //handle common enity references &xxx; or &#000.
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result = aToken->Consume(theChar,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==theChar) {
-       aToken = gTokenRecycler.CreateTokenOfType(eToken_entity,eHTMLTag_entity,gEmpty);
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       aScanner.PutBack(theChar);
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_whitespace,eHTMLTag_whitespace,gEmpty);
-  nsresult result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/*
- * Consume characters as long as they match the string passed in.
- * If they don't match, put them all back. 
- * XXX The scanner should be able to do this.
- *
- *  @update vidur 11/12/98
- */
-static nsresult
-ConsumeConditional(CScanner& aScanner, 
-                   const nsString& aMatchString,
-                   PRBool& aMatch)
-{
-  nsresult result=NS_OK;
-  PRUnichar matchChar;
-
-  PRInt32 i, count = aMatchString.Length();
-  for (i=0; i < count; i++) {
-    result = aScanner.GetChar(matchChar);
-    if ((NS_OK != result) || (aMatchString.CharAt(i) != matchChar)) {
-      break;
-    }
-  }
-
-  if (NS_OK == result) {
-    if (i != count) {
-      for (; i >= 0; i--) {
-        aScanner.PutBack(aMatchString.CharAt(i));
-      }
-      aMatch = PR_FALSE;
-    }
-    else {
-      aMatch = PR_TRUE;
-    }
-  }
-
-  return result;
-}
-
-/**
- *  This method is called when we see a "<!" sequence. The result
- *  could be a comment or a CDATASection.
- *  XXX "Escaped Content" is not the right term, but I couldn't think
- *  of a good one.
- *  
- *  @update vidur 11/12/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created token (comment or cdatasection)
- *  @return error code
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeEscapedContent(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  nsresult result=NS_OK;
-  nsAutoString CDATAString("[CDATA[");
-  PRBool isCDATA = PR_FALSE;
-
-  result = ConsumeConditional(aScanner, CDATAString, isCDATA);
-  if (NS_OK == result) {
-    if (isCDATA) {
-      aToken=gTokenRecycler.CreateTokenOfType(eToken_cdatasection,eHTMLTag_unknown,gEmpty);
-    }
-    else {
-      aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
-    }
-  }
-
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  aToken is the newly created newline token that is parsing
- *  @return error code
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=gTokenRecycler.CreateTokenOfType(eToken_newline,eHTMLTag_newline,gEmpty);
-  nsresult result=NS_OK;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return kNoError;
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  vidur 11/12/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsresult result=aScanner.GetChar(aChar);
-
-  if(NS_OK==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(NS_OK==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=gTokenRecycler.CreateTokenOfType(eToken_end,eHTMLTag_unknown,gEmpty);
-          else aToken=gTokenRecycler.CreateTokenOfType(eToken_comment,eHTMLTag_unknown,gEmpty);
-        }//if
-        break;
-
-      case kExclamation:
-        result = ConsumeEscapedContent(aChar, aScanner, aToken);
-        break;
-
-      case kQuestionMark: //it must be an XML processing instruction...
-        aToken=gTokenRecycler.CreateTokenOfType(eToken_instruction,eHTMLTag_unknown,gEmpty);
-        break;
-
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (NS_OK==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
-}
-
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gess 3/25/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-NS_IMETHODIMP CWellFormedDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return NS_OK;
-  }
-
-  mParser=(nsParser*)aParser;
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    PRUnichar theChar;
-    result=theScanner->GetChar(theChar);
-    switch(result) {
-      case kEOF:
-          //We convert from eof to complete here, because we never really tried to get data.
-          //All we did was try to see if data was available, which it wasn't.
-          //It's important to return process complete, so that controlling logic can know that
-          //everything went well, but we're done with token processing.
-        result=kProcessComplete;
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(theChar) {
-          case kLessThan:
-            result=ConsumeTag(theChar,*theScanner,aToken);
-            break;
-
-          case kAmpersand:
-            result=ConsumeEntity(theChar,*theScanner,aToken);
-            break;
-          
-          case kCR: case kLF:
-            result=ConsumeNewline(theChar,*theScanner,aToken);
-            break;
-            
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(theChar)) {
-              nsAutoString temp(theChar);
-              result=ConsumeText(temp,*theScanner,aToken);
-              break;
-            }
-            result=ConsumeWhitespace(theChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-//    if(NS_OK==result)
-//      result=theScanner->Eof(); 
-  } //if
-  return result;
+nsITokenizer* CWellFormedDTD::GetTokenizer(void) {
+  if(!mTokenizer)
+    mTokenizer=new nsXMLTokenizer();
+  return mTokenizer;
 }
 
 /**
@@ -796,15 +456,15 @@ NS_IMETHODIMP CWellFormedDTD::HandleToken(CToken* aToken,nsIParser* aParser) {
         if(0<attrCount){ //go collect the attributes...
           int attr=0;
           for(attr=0;attr<attrCount;attr++){
-            CToken* theToken=mParser->PeekToken();
+            CToken* theToken=mTokenizer->PeekToken();
             if(theToken)  {
               eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
               if(eToken_attribute==theType){
-                mParser->PopToken(); //pop it for real...
+                mTokenizer->PopToken(); //pop it for real...
                 theNode.AddAttribute(theToken);
               } 
             }
-            else return kInterrupted;
+            else return kEOF;
           }
         }
         if(NS_OK==result){
@@ -852,13 +512,3 @@ nsresult CWellFormedDTD::ReleaseTokenPump(nsITagHandler* aHandler){
   nsresult result=NS_OK;
   return result;
 }
-
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* CWellFormedDTD::GetTokenRecycler(void){
-  return &gTokenRecycler;
-}
diff --git a/parser/htmlparser/src/nsWellFormedDTD.h b/parser/htmlparser/src/nsWellFormedDTD.h
index 171d3b99fe6d..2d1a8dca56e3 100644
--- a/parser/htmlparser/src/nsWellFormedDTD.h
+++ b/parser/htmlparser/src/nsWellFormedDTD.h
@@ -72,6 +72,7 @@ class CWellFormedDTD : public nsIDTD {
      */
     virtual ~CWellFormedDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
 
     /**
      * Call this method if you want the DTD to construct a clone of itself.
@@ -110,6 +111,16 @@ class CWellFormedDTD : public nsIDTD {
       */
     NS_IMETHOD WillBuildModel(nsString& aFilename,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
    /**
      * The parser uses a code sandwich to wrap the parsing process. Before
      * the process begins, WillBuildModel() is called. Afterwards the parser
@@ -118,7 +129,7 @@ class CWellFormedDTD : public nsIDTD {
      * @param	anErrorCode contans the last error that occured
      * @return	error code
      */
-    NS_IMETHOD DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -147,15 +158,12 @@ class CWellFormedDTD : public nsIDTD {
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
     /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gess 3/25/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
+    nsITokenizer* GetTokenizer(void);
 
     /**
      * 
@@ -220,22 +228,23 @@ class CWellFormedDTD : public nsIDTD {
     virtual nsITokenRecycler* GetTokenRecycler(void);
     
 protected:
-
-    NS_IMETHODIMP ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeEscapedContent(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    NS_IMETHODIMP ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-
+/*
+    NS_IMETHODIMP ConsumeTag(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeStartTag(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeText(const nsString& aString,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeNewline(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeWhitespace(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeEscapedContent(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeComment(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeEntity(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+    NS_IMETHODIMP ConsumeAttributes(PRUnichar aChar,nsScanner& aScanner,CStartToken* aToken);
+*/
     nsParser*           mParser;
     nsIContentSink*     mSink;
     nsString            mFilename;
     PRInt32             mLineNumber;
     nsDeque             mTokenDeque;
+    nsITokenizer*       mTokenizer;
 };
 
 extern NS_HTMLPARS nsresult NS_NewWellFormed_DTD(nsIDTD** aInstancePtrResult);
diff --git a/parser/htmlparser/src/nsXIFDTD.cpp b/parser/htmlparser/src/nsXIFDTD.cpp
index 2c80cfbb40db..153786a12b7c 100644
--- a/parser/htmlparser/src/nsXIFDTD.cpp
+++ b/parser/htmlparser/src/nsXIFDTD.cpp
@@ -26,7 +26,7 @@
 #include "nsXIFDTD.h" 
 #include "nsHTMLTokens.h"
 #include "nsCRT.h"
-#include "nsParserTypes.h"
+#include "nsIParser.h"
 #include "nsParser.h"
 #include "nsScanner.h"
 #include "nsTokenHandler.h"
@@ -34,7 +34,7 @@
 #include "nsIHTMLContentSink.h"
 #include "nsHTMLContentSinkStream.h"
 #include "prmem.h"
-
+#include "nsXMLTokenizer.h"
 
 static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);                 
 static NS_DEFINE_IID(kIDTDIID,      NS_IDTD_IID);
@@ -321,6 +321,7 @@ static nsXIfTokenDeallocator gTokenKiller;
  */
 nsXIFDTD::nsXIFDTD() : nsIDTD(), mTokenDeque(gTokenKiller)  {
   mParser=0;
+  mTokenizer=0;
   nsCRT::zero(mContextStack,sizeof(mContextStack));
   nsCRT::zero(mTokenHandlers,sizeof(mTokenHandlers));
   
@@ -354,6 +355,17 @@ nsXIFDTD::~nsXIFDTD(){
 }
 
 
+/**
+ * 
+ * @update	gess1/8/99
+ * @param 
+ * @return
+ */
+const nsIID& nsXIFDTD::GetMostDerivedIID(void) const{
+  return kClassIID;
+}
+
+
 /**
  * Call this method if you want the DTD to construct a fresh 
  * instance of itself. 
@@ -419,13 +431,26 @@ nsresult nsXIFDTD::WillBuildModel(nsString& aFileName,PRBool aNotifySink,nsIPars
   return result;
 }
 
+/**
+  * The parser uses a code sandwich to wrap the parsing process. Before
+  * the process begins, WillBuildModel() is called. Afterwards the parser
+  * calls DidBuildModel(). 
+  * @update	gess5/18/98
+  * @param	aFilename is the name of the file being parsed.
+  * @return	error code (almost always 0)
+  */
+NS_IMETHODIMP nsXIFDTD::BuildModel(nsIParser* aParser) {
+  nsresult result=NS_OK;
+  return result;
+}
+
 /**
  * 
  * @update	gess 7/24/98
  * @param 
  * @return
  */
-nsresult nsXIFDTD::DidBuildModel(PRInt32 anErrorCode,PRBool aNotifySink,nsIParser* aParser){
+nsresult nsXIFDTD::DidBuildModel(nsresult anErrorCode,PRBool aNotifySink,nsIParser* aParser){
   nsresult result=NS_OK;
 
   if(aParser){
@@ -503,7 +528,7 @@ nsresult nsXIFDTD::ReleaseTokenPump(nsITagHandler* aHandler){
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CStartToken*  st    = (CStartToken*)(aToken);
@@ -512,9 +537,9 @@ PRInt32 nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
   //Begin by gathering up attributes...
   nsCParserNode node((CHTMLToken*)aToken);
   PRInt16       attrCount=aToken->GetAttributeCount();
-  PRInt32       result=(0==attrCount) ? kNoError : CollectAttributes(node,attrCount);
+  nsresult      result=(0==attrCount) ? NS_OK : CollectAttributes(node,attrCount);
 
-  if(kNoError==result)
+  if(NS_OK==result)
   {
     if (mInContent == PR_TRUE)
       mSink->AddLeaf(node);
@@ -532,14 +557,14 @@ PRInt32 nsXIFDTD::HandleWhiteSpaceToken(CToken* aToken) {
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleTextToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleTextToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CStartToken*    st    = (CStartToken*)(aToken);
   eXIFTags        type  =(eXIFTags)st->GetTypeID();
   nsCParserNode   node((CHTMLToken*)aToken);
 
-  PRInt32 result = kNoError;
+  nsresult result = NS_OK;
 
   if (type == eXIFTag_text)
   {
@@ -555,8 +580,7 @@ PRInt32 nsXIFDTD::HandleTextToken(CToken* aToken) {
 }
 
 
-void nsXIFDTD::AddAttribute(nsIParserNode& aNode)
-{
+void nsXIFDTD::AddAttribute(nsIParserNode& aNode) {
   nsString key;
   nsString value;
   PRBool   hasValue;
@@ -572,12 +596,12 @@ void nsXIFDTD::AddAttribute(nsIParserNode& aNode)
  *  This method gets called when a start token has been 
  *  encountered in the parse process. 
  *  
- *  @update  gpk 06/18/98
+ *  @update  gess 12/28/98
  *  @param   aToken -- next (start) token to be handled
  *  @param   aNode -- CParserNode representing this start token
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleStartToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleStartToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CStartToken*  st    = (CStartToken*)(aToken);
@@ -586,10 +610,9 @@ PRInt32 nsXIFDTD::HandleStartToken(CToken* aToken) {
   //Begin by gathering up attributes...
   nsCParserNode   node = ((CHTMLToken*)aToken);
   PRInt16         attrCount=aToken->GetAttributeCount();
-  PRInt32         result=(0==attrCount) ? kNoError : CollectAttributes(node,attrCount);
+  nsresult        result=(0==attrCount) ? NS_OK : CollectAttributes(node,attrCount);
 
-  if(kNoError==result)
-  {
+  if(NS_OK==result)   {
     switch (type)
     {
       case eXIFTag_container:
@@ -647,10 +670,10 @@ PRInt32 nsXIFDTD::HandleStartToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleEndToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleEndToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
-  PRInt32         result        = kNoError;
+  nsresult        result        = NS_OK;
   CEndToken*      et            = (CEndToken*)(aToken);
   eXIFTags        tokenTagType  = (eXIFTags)et->GetTypeID();
   nsCParserNode   node          = ((CHTMLToken*)aToken);
@@ -694,11 +717,11 @@ PRInt32 nsXIFDTD::HandleEndToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleEntityToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleEntityToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
 
   CEntityToken* et = (CEntityToken*)(aToken);
-  PRInt32       result=kNoError;
+  nsresult      result=NS_OK;
   eXIFTags      tokenTagType=(eXIFTags)et->GetTypeID();
 
   if(PR_FALSE==CanOmit(GetTopNode(),tokenTagType)) {
@@ -718,9 +741,9 @@ PRInt32 nsXIFDTD::HandleEntityToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleCommentToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleCommentToken(CToken* aToken) {
   NS_PRECONDITION(0!=aToken,kNullToken);
-  return kNoError;
+  return NS_OK;
 }
 
 /**
@@ -733,12 +756,12 @@ PRInt32 nsXIFDTD::HandleCommentToken(CToken* aToken) {
  *  @param   aToken -- next (start) token to be handled
  *  @return  PR_TRUE if all went well; PR_FALSE if error occured
  */
-PRInt32 nsXIFDTD::HandleAttributeToken(CToken* aToken) {
+nsresult nsXIFDTD::HandleAttributeToken(CToken* aToken) {
   CAttributeToken*  at = (CAttributeToken*)(aToken);
   NS_PRECONDITION(0!=aToken,kNullToken);
   NS_ERROR("attribute encountered -- this shouldn't happen!");
 
-  PRInt32 result=kNoError;
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -836,21 +859,6 @@ PRBool nsXIFDTD::CanContain(PRInt32 aParent,PRInt32 aChild) const {
   return result;
 }
 
-
-/**
- *  This method is called to determine whether or not a tag
- *  of one type can contain a tag of another type.
- *  
- *  @update  gpk 06/18/98
- *  @param   aParent -- tag enum of parent container
- *  @param   aChild -- tag enum of child container
- *  @return  PR_TRUE if parent can contain child
- */
-PRBool nsXIFDTD::CanContainIndirect(eXIFTags aParent,eXIFTags aChild) const {
-  PRBool result=PR_FALSE;
-  return result;
-}
-
 /**
  *  This method gets called to determine whether a given 
  *  tag can contain newlines. Most do not.
@@ -975,8 +983,8 @@ eXIFTags nsXIFDTD::GetDefaultParentTagFor(eXIFTags aTag) const{
  * @param   aTag is the id of the html container being opened
  * @return  0 if all is well.
  */
-PRInt32 nsXIFDTD::DidOpenContainer(eXIFTags aTag,PRBool /*anExplicitOpen*/){
-  PRInt32   result=0;
+nsresult nsXIFDTD::DidOpenContainer(eXIFTags aTag,PRBool /*anExplicitOpen*/){
+  nsresult   result=NS_OK;
   return result;
 }
 
@@ -986,8 +994,8 @@ PRInt32 nsXIFDTD::DidOpenContainer(eXIFTags aTag,PRBool /*anExplicitOpen*/){
  * @param 
  * @return
  */
-PRInt32 nsXIFDTD::DidCloseContainer(eXIFTags aTag,PRBool/*anExplicitClosure*/){
-  PRInt32 result=0;
+nsresult nsXIFDTD::DidCloseContainer(eXIFTags aTag,PRBool/*anExplicitClosure*/){
+  nsresult result=NS_OK;
   return result;
 }
 
@@ -1046,14 +1054,6 @@ PRInt32 nsXIFDTD::GetTopmostIndexOf(eXIFTags aTag) const {
   *
   */
 
-
-
-
-
-
-
-
-
 PRBool nsXIFDTD::GetAttribute(const nsIParserNode& aNode, const nsString& aKey, nsString& aValue)
 {
   PRInt32   i;
@@ -1073,6 +1073,13 @@ PRBool nsXIFDTD::GetAttribute(const nsIParserNode& aNode, const nsString& aKey,
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 PRBool nsXIFDTD::GetAttributePair(nsIParserNode& aNode, nsString& aKey, nsString& aValue)
 {
  
@@ -1105,6 +1112,13 @@ PRBool nsXIFDTD::GetAttributePair(nsIParserNode& aNode, nsString& aKey, nsString
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 eHTMLTags nsXIFDTD::GetHTMLTag(const nsString& aName)
 {
   eHTMLTags  tag = eHTMLTag_unknown;
@@ -1123,6 +1137,13 @@ eHTMLTags nsXIFDTD::GetHTMLTag(const nsString& aName)
 
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 eHTMLTags nsXIFDTD::GetStartTag(const nsIParserNode& aNode, nsString& aName)
 {
   eXIFTags  type = (eXIFTags)aNode.GetNodeType();  
@@ -1145,6 +1166,13 @@ eHTMLTags nsXIFDTD::GetStartTag(const nsIParserNode& aNode, nsString& aName)
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PushHTMLTag(const eHTMLTags aTag, const nsString& aName)
 {
 
@@ -1153,6 +1181,13 @@ void nsXIFDTD::PushHTMLTag(const eHTMLTags aTag, const nsString& aName)
   mHTMLTagStack[++mHTMLStackPos]=eHTMLTag_unknown;
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PopHTMLTag(eHTMLTags& aTag, nsString*& aName)
 {
   NS_ASSERTION(mHTMLStackPos > 0,"The stack must not be empty");
@@ -1167,6 +1202,13 @@ void nsXIFDTD::PopHTMLTag(eHTMLTags& aTag, nsString*& aName)
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PushNodeAndToken(nsString& aName)
 {
   CToken*         token = new CStartToken(aName);
@@ -1176,6 +1218,13 @@ void nsXIFDTD::PushNodeAndToken(nsString& aName)
   mNodeStack.AppendElement((void*)node);  
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 nsIParserNode* nsXIFDTD::PeekNode()
 {
   PRInt32 count = mNodeStack.Count()-1;
@@ -1185,6 +1234,13 @@ nsIParserNode* nsXIFDTD::PeekNode()
   return nsnull;
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 CToken* nsXIFDTD::PeekToken()
 {
   PRInt32 count = mTokenStack.Count()-1; 
@@ -1193,6 +1249,13 @@ CToken* nsXIFDTD::PeekToken()
   return nsnull;
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::PopAndDelete()
 {
   nsIParserNode* node = PeekNode();
@@ -1208,6 +1271,13 @@ void nsXIFDTD::PopAndDelete()
   }
 }
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 PRBool nsXIFDTD::StartTopOfStack()
 {
   // If something is already on the stack, then
@@ -1232,6 +1302,13 @@ PRBool nsXIFDTD::StartTopOfStack()
 }
 
 
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
 void nsXIFDTD::BeginStartTag(const nsIParserNode& aNode)
 {
   eXIFTags  type = (eXIFTags)aNode.GetNodeType();
@@ -1283,10 +1360,10 @@ void nsXIFDTD::AddEndTag(const nsIParserNode& aNode)
  * @param   aNode -- next node to be added to model
  * @return  TRUE if ok, FALSE if error
  */
-PRInt32 nsXIFDTD::OpenContainer(const nsIParserNode& aNode){
+nsresult nsXIFDTD::OpenContainer(const nsIParserNode& aNode){
   NS_PRECONDITION(mContextStackPos > 0, kInvalidTagStackPos);
   
-  PRInt32   result=kNoError; 
+  nsresult  result=NS_OK; 
   eXIFTags  type =(eXIFTags)aNode.GetNodeType();
 
   switch (type)
@@ -1309,10 +1386,10 @@ PRInt32 nsXIFDTD::OpenContainer(const nsIParserNode& aNode){
  * @param   aNode -- next node to be removed from our model
  * @return  TRUE if ok, FALSE if error
  */
-PRInt32 nsXIFDTD::CloseContainer(const nsIParserNode& aNode)
+nsresult nsXIFDTD::CloseContainer(const nsIParserNode& aNode)
 {
   NS_PRECONDITION(mContextStackPos > 0, kInvalidTagStackPos);
-  PRInt32   result=kNoError; //was false
+  nsresult   result=NS_OK; //was false
   eXIFTags type=(eXIFTags)aNode.GetNodeType();
   
   if (type == eXIFTag_container)
@@ -1333,10 +1410,10 @@ PRInt32 nsXIFDTD::CloseContainer(const nsIParserNode& aNode)
  * @param   aNode -- next node to be added to model
  * @return  TRUE if ok, FALSE if error
  */
-PRInt32 nsXIFDTD::AddLeaf(const nsIParserNode& aNode)
+nsresult nsXIFDTD::AddLeaf(const nsIParserNode& aNode)
 {
   eXIFTags  type = (eXIFTags)aNode.GetNodeType();    
-  PRInt32 result=mSink->AddLeaf(aNode); 
+  nsresult result=mSink->AddLeaf(aNode); 
   return result;
 }
 
@@ -1351,345 +1428,34 @@ PRInt32 nsXIFDTD::AddLeaf(const nsIParserNode& aNode)
  *           create a new context vector
  *  @return  true if we succeeded, otherwise false
  */
-PRInt32 nsXIFDTD::CreateContextStackFor(eXIFTags aChildTag)
+nsresult nsXIFDTD::CreateContextStackFor(eXIFTags aChildTag)
 {
   mContextStack[++mContextStackPos] = aChildTag;
-  return kNoError;
+  return NS_OK;
 }
 
 
-
-
-/*******************************************************************
-  These methods used to be hidden in the tokenizer-delegate. 
-  That file merged with the DTD, since the separation wasn't really
-  buying us anything.
- *******************************************************************/
-
 /**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of some kind of tagged 
- *  element. We don't know yet if it's a tag or a comment.
- *  
- *  @update  gpk 06/18/98
- *  @param   aChar is the last char read
- *  @param   aScanner is represents our input source
- *  @param   aToken is the out arg holding our new token
- *  @return  error code (may return kInterrupted).
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
  */
-PRInt32 nsXIFDTD::ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-
-  nsAutoString empty("");
-  PRInt32 result=aScanner.GetChar(aChar);
-
-  if(kNoError==result) {
-
-    switch(aChar) {
-      case kForwardSlash:
-        PRUnichar ch; 
-        result=aScanner.Peek(ch);
-        if(kNoError==result) {
-          if(nsString::IsAlpha(ch))
-            aToken=new CEndToken(empty);
-          else aToken=new CCommentToken(empty); //Special case: </ ...> is treated as a comment
-        }//if
-        break;
-      case kExclamation:
-        aToken=new CCommentToken(empty);
-        break;
-      default:
-        if(nsString::IsAlpha(aChar))
-          return ConsumeStartTag(aChar,aScanner,aToken);
-        else if(kEOF!=aChar) {
-          nsAutoString temp("<");
-          return ConsumeText(temp,aScanner,aToken);
-        }
-    } //switch
-
-    if((0!=aToken) && (kNoError==result)) {
-      result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-      if(result) {
-        delete aToken;
-        aToken=0;
-      }
-    } //if
-  } //if
-  return result;
+nsITokenizer* nsXIFDTD::GetTokenizer(void){
+  if(!mTokenizer)
+    mTokenizer=new nsXMLTokenizer();
+  return mTokenizer;
 }
 
 /**
- *  This method is called just after we've consumed a start
- *  tag, and we now have to consume its attributes.
- *  
- *  @update  gpk 06/18/98
- *  @param   aChar: last char read
- *  @param   aScanner: see nsScanner.h
- *  @return  
+ * 
+ * @update	gess8/4/98
+ * @param 
+ * @return
  */
-PRInt32 nsXIFDTD::ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken) {
-  PRBool done=PR_FALSE;
-  PRInt32 result=kNoError;
-  nsAutoString as("");
-  PRInt16 theAttrCount=0;
-
-  while((!done) && (result==kNoError)) {
-    CAttributeToken* theToken= new CAttributeToken(as);
-    if(theToken){
-      result=theToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-
-      //Much as I hate to do this, here's some special case code.
-      //This handles the case of empty-tags in XML. Our last
-      //attribute token will come through with a text value of ""
-      //and a textkey of "/". We should destroy it, and tell the 
-      //start token it was empty.
-      nsString& key=theToken->GetKey();
-      nsString& text=theToken->GetStringValueXXX();
-      if((key[0]==kForwardSlash) && (0==text.Length())){
-        //tada! our special case! Treat it like an empty start tag...
-        aToken->SetEmpty(PR_TRUE);
-        delete theToken;
-      }
-      else  if(kNoError==result){
-        theAttrCount++;
-        mTokenDeque.Push(theToken);
-      }//if
-      else delete theToken; //we can't keep it...
-    }//if
-    
-    if(kNoError==result){
-      result=aScanner.Peek(aChar);
-      if(aChar==kGreaterThan) { //you just ate the '>'
-        aScanner.GetChar(aChar); //skip the '>'
-        done=PR_TRUE;
-      }//if
-    }//if
-  }//while
-
-  aToken->SetAttributeCount(theAttrCount);
-  return result;
-}
-
-/**
- *  This is a special case method. It's job is to consume 
- *  all of the given tag up to an including the end tag.
- *
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null
- */
-PRInt32 nsXIFDTD::ConsumeContentToEndTag(const nsString& aString,PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  
-  //In the case that we just read the given tag, we should go and
-  //consume all the input until we find a matching end tag.
-
-  nsAutoString endTag("</");
-  endTag.Append(aString);
-  endTag.Append(">");
-  aToken=new CSkippedContentToken(endTag);
-  return aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-}
-
-/**
- *  This method is called just after a "<" has been consumed 
- *  and we know we're at the start of a tag.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  PRInt32 theDequeSize=mTokenDeque.GetSize();
-  PRInt32 result=kNoError;
-
-  aToken=new CStartToken(eHTMLTag_unknown);
-
-  if(aToken) {
-    result= aToken->Consume(aChar,aScanner);  //tell new token to finish consuming text...    
-    if(kNoError==result) {
-      if(((CStartToken*)aToken)->IsAttributed()) {
-        result=ConsumeAttributes(aChar,aScanner,(CStartToken*)aToken);
-      }
-    } //if
-  } //if
-  return result;
-}
-
-/**
- *  This method is called just after a "&" has been consumed 
- *  and we know we're at the start of an entity.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-   PRUnichar  ch;
-   PRInt32 result=aScanner.GetChar(ch);
-
-   if(kNoError==result) {
-     if(nsString::IsAlpha(ch)) { //handle common enity references &xxx; or &#000.
-       aToken = new CEntityToken(nsAutoString(""));
-       result = aToken->Consume(ch,aScanner);  //tell new token to finish consuming text...    
-     }
-     else if(kHashsign==ch) {
-       aToken = new CEntityToken(nsAutoString(""));
-       result=aToken->Consume(0,aScanner);
-     }
-     else {
-       //oops, we're actually looking at plain text...
-       nsAutoString temp("&");
-       result=ConsumeText(temp,aScanner,aToken);
-     }
-   }//if
-   return result;
-}
-
-/**
- *  This method is called just after whitespace has been 
- *  consumed and we know we're at the start a whitespace run.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken) {
-  aToken = new CWhitespaceToken(nsAutoString(""));
-  PRInt32 result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a "<!" has been consumed 
- *  and we know we're at the start of a comment.  
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken = new CCommentToken(nsAutoString(""));
-  PRInt32 result=kNoError;
-  if(aToken) {
-     result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a known text char has
- *  been consumed and we should read a text run.
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken){
-
-  PRInt32 result=kNoError;
-  if(aToken=new CTextToken(aString)) {
-    PRUnichar ch=0;
-    result=aToken->Consume(ch,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method is called just after a newline has been consumed. 
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-PRInt32 nsXIFDTD::ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken){
-  aToken=new CNewlineToken(nsAutoString(""));
-  PRInt32 result=kNoError;
-  if(aToken) {
-    result=aToken->Consume(aChar,aScanner);
-  }
-  return result;
-}
-
-/**
- *  This method repeatedly called by the tokenizer. 
- *  Each time, we determine the kind of token were about to 
- *  read, and then we call the appropriate method to handle
- *  that token type.
- *  
- *  @update gpk 06/18/98
- *  @param  aChar: last char read
- *  @param  aScanner: see nsScanner.h
- *  @param  anErrorCode: arg that will hold error condition
- *  @return new token or null 
- */
-nsresult nsXIFDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
-  
-  aToken=0;
-  if(mTokenDeque.GetSize()>0) {
-    aToken=(CToken*)mTokenDeque.Pop();
-    return kNoError;
-  }
-
-  mParser=(nsParser*)aParser;
-
-  nsresult   result=NS_OK;
-  CScanner* theScanner=mParser->GetScanner();
-  if(NS_OK==result){
-    
-    PRUnichar aChar;
-    result=theScanner->GetChar(aChar);
-    switch(result) {
-      case kEOF:
-        break;
-
-      case kInterrupted:
-        theScanner->RewindToMark();
-        break; 
-
-      case NS_OK:
-      default:
-        switch(aChar) {
-          case kLessThan:
-            return ConsumeTag(aChar,*theScanner,aToken);
-
-          case kAmpersand:
-            return ConsumeEntity(aChar,*theScanner,aToken);
-          
-          case kCR: case kLF:
-            return ConsumeNewline(aChar,*theScanner,aToken);
-          
-          case kNotFound:
-            break;
-          
-          default:
-            if(!nsString::IsSpace(aChar)) {
-              nsAutoString temp(aChar);
-              return ConsumeText(temp,*theScanner,aToken);
-            }
-            else return ConsumeWhitespace(aChar,*theScanner,aToken);
-            break;
-        } //switch
-        break; 
-    } //switch
-    if(NS_OK==result)
-      result=theScanner->Eof();
-  } //while
-  return result;
+nsITokenRecycler* nsXIFDTD::GetTokenRecycler(void){
+  nsITokenizer* theTokenizer=GetTokenizer();
+  return theTokenizer->GetTokenRecycler();
 }
 
 /**
@@ -1701,38 +1467,20 @@ nsresult nsXIFDTD::ConsumeToken(CToken*& aToken,nsIParser* aParser) {
  * @param   aCount is the # of attributes you're expecting
  * @return error code (should be 0)
  */
-PRInt32 nsXIFDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
-/*
-  nsDequeIterator end=mParserContext->mTokenDeque.End();
-
-  int attr=0;
-  for(attr=0;attr<aCount;attr++) {
-    if(*mParserContext->mCurrentPos<end) {
-      CToken* tkn=(CToken*)(++(*mParserContext->mCurrentPos));
-      if(tkn){
-        if(eToken_attribute==eHTMLTokenTypes(tkn->GetTokenType())){
-          aNode.AddAttribute(tkn);
-        } 
-        else (*mParserContext->mCurrentPos)--;
-      }
-      else return kInterrupted;
-    }
-    else return kInterrupted;
-  }
-*/
+nsresult nsXIFDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
   int attr=0;
   for(attr=0;attr<aCount;attr++){
-    CToken* theToken=mParser->PeekToken();
+    CToken* theToken=mTokenizer->PeekToken();
     if(theToken)  {
       eHTMLTokenTypes theType=eHTMLTokenTypes(theToken->GetTokenType());
       if(eToken_attribute==theType){
-        mParser->PopToken(); //pop it for real...
+        mTokenizer->PopToken(); //pop it for real...
         aNode.AddAttribute(theToken);
       } 
     }
-    else return kInterrupted;
+    else return kEOF;
   }
-  return kNoError;
+  return NS_OK;
 }
 
 
@@ -1744,23 +1492,8 @@ PRInt32 nsXIFDTD::CollectAttributes(nsCParserNode& aNode,PRInt32 aCount){
  * @param   holds the number of skipped content elements encountered
  * @return  Error condition.
  */
-PRInt32 nsXIFDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
-  PRInt32           result=kNoError;
-/*
-  eHTMLTokenTypes   subtype=eToken_attribute;
-  nsDequeIterator   end=mParserContext->mTokenDeque.End();
-
-  aCount=0;
-  while((*mParserContext->mCurrentPos!=end) && (eToken_attribute==subtype)) {
-    CToken* tkn=(CToken*)(++(*mParserContext->mCurrentPos));
-    subtype=eHTMLTokenTypes(tkn->GetTokenType());
-    if(eToken_skippedcontent==subtype) {
-      aNode.SetSkippedContent(tkn);
-      aCount++;
-    } 
-    else (*mParserContext->mCurrentPos)--;
-  }
-*/
+nsresult nsXIFDTD::CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount) {
+  nsresult           result=NS_OK;
   return result;
 }
 
@@ -2004,13 +1737,4 @@ void nsXIFDTD::AddCSSDeclaration(const nsIParserNode& aNode)
 }
 
 
-/**
- * 
- * @update	gess8/4/98
- * @param 
- * @return
- */
-nsITokenRecycler* nsXIFDTD::GetTokenRecycler(void){
-  return 0;
-}
-
+ 
\ No newline at end of file
diff --git a/parser/htmlparser/src/nsXIFDTD.h b/parser/htmlparser/src/nsXIFDTD.h
index 949150d75f7f..1bc9eb20b002 100644
--- a/parser/htmlparser/src/nsXIFDTD.h
+++ b/parser/htmlparser/src/nsXIFDTD.h
@@ -49,6 +49,7 @@ class nsCParserNode;
 class CTokenHandler;
 class nsIDTDDebug;
 class nsIHTMLContentSink;
+class nsITokenizer;
 
 //*** This enum is used to define the known universe of XIF tags.
 //*** The use of this table doesn't preclude of from using non-standard
@@ -117,6 +118,8 @@ class nsXIFDTD : public nsIDTD {
      */
     nsXIFDTD();
 
+    virtual const nsIID&  GetMostDerivedIID(void) const;
+
     /**
      *  
      *  
@@ -163,13 +166,23 @@ class nsXIFDTD : public nsIDTD {
      */
     NS_IMETHOD WillBuildModel(nsString& aFileName,PRBool aNotifySink,nsIParser* aParser);
 
+    /**
+      * The parser uses a code sandwich to wrap the parsing process. Before
+      * the process begins, WillBuildModel() is called. Afterwards the parser
+      * calls DidBuildModel(). 
+      * @update	gess5/18/98
+      * @param	aFilename is the name of the file being parsed.
+      * @return	error code (almost always 0)
+      */
+    NS_IMETHOD BuildModel(nsIParser* aParser);
+
     /**
      *  
      * @update	gess 7/24/98
      * @param 
      * @return
      */
-    NS_IMETHOD DidBuildModel(PRInt32 aQualityLevel,PRBool aNotifySink,nsIParser* aParser);
+    NS_IMETHOD DidBuildModel(nsresult aQualityLevel,PRBool aNotifySink,nsIParser* aParser);
 
     /**
      *  
@@ -197,16 +210,6 @@ class nsXIFDTD : public nsIDTD {
      */
     NS_IMETHOD ReleaseTokenPump(nsITagHandler* aHandler);
 
-    /**
-     *  Cause the tokenizer to consume the next token, and 
-     *  return an error result.
-     *  
-     *  @update  gpk 06/18/98
-     *  @param   anError -- ref to error code
-     *  @return  new token or null
-     */
-    NS_IMETHOD ConsumeToken(CToken*& aToken,nsIParser* aParser);
-
 
     /**
      * 
@@ -269,18 +272,6 @@ class nsXIFDTD : public nsIDTD {
      */
     virtual void SetVerification(PRBool aEnable);
 
-
-    /**
-     *  This method is called to determine whether or not a tag
-     *  of one type can contain a tag of another type.
-     *  
-     *  @update  gpk 06/18/98
-     *  @param   aParent -- tag enum of parent container
-     *  @param   aChild -- tag enum of child container
-     *  @return  PR_TRUE if parent can contain child
-     */
-    virtual PRBool CanContainIndirect(eXIFTags aParent,eXIFTags aChild) const;
-
     /**
      *  This method gets called to determine whether a given 
      *  tag can contain newlines. Most do not.
@@ -343,7 +334,7 @@ class nsXIFDTD : public nsIDTD {
      * @param 
      * @return
      */
-    virtual PRInt32 DidOpenContainer(eXIFTags aTag,PRBool anExplicitOpen);    
+    virtual nsresult DidOpenContainer(eXIFTags aTag,PRBool anExplicitOpen);    
 
     /**
      * Ask parser if a given container is open ANYWHERE on stack
@@ -375,7 +366,7 @@ class nsXIFDTD : public nsIDTD {
      * @param 
      * @return
      */
-    virtual PRInt32 DidCloseContainer(eXIFTags aTag,PRBool anExplicitClosure);
+    virtual nsresult DidCloseContainer(eXIFTags aTag,PRBool anExplicitClosure);
 
     /**
      * This method gets called when a start token has been consumed and needs 
@@ -384,7 +375,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the start token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleStartToken(CToken* aToken);
+    nsresult HandleStartToken(CToken* aToken);
 
     /**
      * This method gets called when an end token has been consumed and needs 
@@ -393,7 +384,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the end token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleEndToken(CToken* aToken);
+    nsresult HandleEndToken(CToken* aToken);
 
     /**
      * This method gets called when an entity token has been consumed and needs 
@@ -402,7 +393,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the entity token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleEntityToken(CToken* aToken);
+    nsresult HandleEntityToken(CToken* aToken);
 
     /**
      * This method gets called when a comment token has been consumed and needs 
@@ -411,7 +402,7 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the comment token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleCommentToken(CToken* aToken);
+    nsresult HandleCommentToken(CToken* aToken);
 
     /**
      * This method gets called when an attribute token has been consumed and needs 
@@ -420,11 +411,11 @@ class nsXIFDTD : public nsIDTD {
      * @param   aToken is the attribute token to be handled
      * @return  TRUE if the token was handled.
      */
-    PRInt32 HandleAttributeToken(CToken* aToken);
+    nsresult HandleAttributeToken(CToken* aToken);
 
 
-    PRInt32 HandleWhiteSpaceToken(CToken* aToken);
-    PRInt32 HandleTextToken(CToken* aToken);
+    nsresult HandleWhiteSpaceToken(CToken* aToken);
+    nsresult HandleTextToken(CToken* aToken);
 
 
 private:
@@ -455,9 +446,6 @@ private:
      */
     void DeleteTokenHandlers(void);
 
-
-
-
     /**
      * This cover method opens the given node as a generic container in 
      * content sink.
@@ -465,7 +453,7 @@ private:
      * @param   generic container (node) to be opened in content sink.
      * @return  TRUE if all went well.
      */
-    PRInt32 OpenContainer(const nsIParserNode& aNode);
+    nsresult OpenContainer(const nsIParserNode& aNode);
 
     /**
      * This cover method causes a generic containre in the content-sink to be closed
@@ -473,7 +461,7 @@ private:
      * @param   aNode is the node to be closed in sink (usually ignored)
      * @return  TRUE if all went well.
      */
-    PRInt32 CloseContainer(const nsIParserNode& aNode);
+    nsresult CloseContainer(const nsIParserNode& aNode);
 
     /**
      * Causes leaf to be added to sink at current vector pos.
@@ -481,7 +469,7 @@ private:
      * @param   aNode is leaf node to be added.
      * @return  TRUE if all went well -- FALSE otherwise.
      */
-    PRInt32 AddLeaf(const nsIParserNode& aNode);
+    nsresult AddLeaf(const nsIParserNode& aNode);
 
      /**
      * Attempt forward and/or backward propagation for the given
@@ -490,103 +478,22 @@ private:
      * @param   type of child to be propagated.
      * @return  TRUE if succeeds, otherwise FALSE
      */
-    PRInt32 CreateContextStackFor(eXIFTags aChildTag);
-
-
-    /****************************************************
-        These methods interface with the parser to do
-        the tokenization phase.
-     ****************************************************/
-
+    nsresult CreateContextStackFor(eXIFTags aChildTag);
 
     /**
-     * Retrieve the next TAG from the given scanner.
-     * @update	gpk 06/18/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
+     * 
+     * @update	gess12/28/98
+     * @param 
+     * @return
      */
-    PRInt32     ConsumeTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve next START tag from given scanner.
-     * @update	gpk 06/18/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeStartTag(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve collection of HTML/XML attributes from given scanner
-     * @update	gpk 06/18/98
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeAttributes(PRUnichar aChar,CScanner& aScanner,CStartToken* aToken);
-    
-    /**
-     * Retrieve a sequence of text from given scanner.
-     * @update	gpk 06/18/98
-     * @param   aString will contain retrieved text.
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeText(const nsString& aString,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve an entity from given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeEntity(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a whitespace sequence from the given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeWhitespace(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-    
-    /**
-     * Retrieve a comment from the given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    PRInt32     ConsumeComment(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
+    nsITokenizer* GetTokenizer(void);
 
     /**
-     * Retrieve newlines from given scanner
-     * @update	gpk 06/18/98
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
+     * Retrieve a ptr to the global token recycler...
+     * @update	gess8/4/98
+     * @return  ptr to recycler (or null)
      */
-    PRInt32     ConsumeNewline(PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
-    /**
-     * Causes content to be skipped up to sequence contained in aString.
-     * @update	gpk 06/18/98
-     * @param   aString ????
-     * @param   aChar last char read from scanner
-     * @param   aScanner is the input source
-     * @param   aToken is the next token (or null)
-     * @return  error code
-     */
-    virtual PRInt32 ConsumeContentToEndTag(const nsString& aString,PRUnichar aChar,CScanner& aScanner,CToken*& aToken);
-
+    virtual nsITokenRecycler* GetTokenRecycler(void);
 
 private:
     void BeginCSSStyleSheet(const nsIParserNode& aNode);
@@ -619,18 +526,11 @@ private:
     void            PopAndDelete();
 
 
-    /**
-     * Retrieve a ptr to the global token recycler...
-     * @update	gess8/4/98
-     * @return  ptr to recycler (or null)
-     */
-    virtual nsITokenRecycler* GetTokenRecycler(void);
-
 protected:
 
     PRBool			CanContainFormElement(eXIFTags aParent,eXIFTags aChild) const;
-		PRInt32			CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
-		PRInt32			CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
+		nsresult		CollectAttributes(nsCParserNode& aNode,PRInt32 aCount);
+		nsresult		CollectSkippedContent(nsCParserNode& aNode,PRInt32& aCount);
     
     nsParser*             mParser;
     nsIHTMLContentSink*   mSink;
@@ -661,6 +561,7 @@ protected:
     PRInt32               mCSSSelectorCount;
     PRBool                mLowerCaseTags;
     PRBool                mLowerCaseAttributes;
+    nsITokenizer*         mTokenizer;
 };
 
 
diff --git a/parser/htmlparser/src/nsXMLTokenizer.cpp b/parser/htmlparser/src/nsXMLTokenizer.cpp
new file mode 100644
index 000000000000..de1f6dfb3112
--- /dev/null
+++ b/parser/htmlparser/src/nsXMLTokenizer.cpp
@@ -0,0 +1,225 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#include "nsXMLTokenizer.h"
+#include "nsParser.h"
+#include "nsScanner.h"
+#include "nsDTDUtils.h"
+#include "nsParser.h"
+
+/************************************************************************
+  And now for the main class -- nsXMLTokenizer...
+ ************************************************************************/
+
+static NS_DEFINE_IID(kISupportsIID,     NS_ISUPPORTS_IID);                 
+static NS_DEFINE_IID(kITokenizerIID,    NS_ITOKENIZER_IID);
+static NS_DEFINE_IID(kHTMLTokenizerIID, NS_HTMLTOKENIZER_IID);
+static NS_DEFINE_IID(kClassIID,         NS_XMLTOKENIZER_IID); 
+static nsAutoString gEmpty;
+
+/**
+ *  This method gets called as part of our COM-like interfaces.
+ *  Its purpose is to create an interface to parser object
+ *  of some type.
+ *  
+ *  @update   gess 4/8/98
+ *  @param    nsIID  id of object to discover
+ *  @param    aInstancePtr ptr to newly discovered interface
+ *  @return   NS_xxx result code
+ */
+nsresult nsXMLTokenizer::QueryInterface(const nsIID& aIID, void** aInstancePtr)  
+{                                                                        
+  if (NULL == aInstancePtr) {                                            
+    return NS_ERROR_NULL_POINTER;                                        
+  }                                                                      
+
+  if(aIID.Equals(kISupportsIID))    {  //do IUnknown...
+    *aInstancePtr = (nsXMLTokenizer*)(this);                                        
+  }
+  else if(aIID.Equals(kITokenizerIID)) {  //do ITOkenizer base class...
+    *aInstancePtr = (nsITokenizer*)(this);                                        
+  }
+  else if(aIID.Equals(kHTMLTokenizerIID)) {  //do nsHTMLTokenizer base class...
+    *aInstancePtr = (nsHTMLTokenizer*)(this);                                        
+  }
+  else if(aIID.Equals(kClassIID)) {  //do this class...
+    *aInstancePtr = (nsXMLTokenizer*)(this);                                        
+  }                 
+  else {
+    *aInstancePtr=0;
+    return NS_NOINTERFACE;
+  }
+  NS_ADDREF_THIS();
+  return NS_OK;                                                        
+}
+
+
+/**
+ *  This method is defined in nsIParser. It is used to 
+ *  cause the COM-like construction of an nsParser.
+ *  
+ *  @update  gess 4/8/98
+ *  @param   nsIParser** ptr to newly instantiated parser
+ *  @return  NS_xxx error result
+ */
+NS_HTMLPARS nsresult NS_NewXMLTokenizer(nsIDTD** aInstancePtrResult) {
+  nsXMLTokenizer* it = new nsXMLTokenizer();
+
+  if (it == 0) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return it->QueryInterface(kClassIID, (void **) aInstancePtrResult);
+}
+
+
+NS_IMPL_ADDREF(nsXMLTokenizer)
+NS_IMPL_RELEASE(nsXMLTokenizer)
+
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsXMLTokenizer::nsXMLTokenizer() : nsHTMLTokenizer() {
+  NS_INIT_REFCNT();
+  mDoXMLEmptyTags=PR_TRUE;
+}
+
+/**
+ *  Default constructor
+ *   
+ *  @update  gess 4/9/98
+ *  @param   
+ *  @return  
+ */
+nsXMLTokenizer::~nsXMLTokenizer(){
+}
+
+
+/*******************************************************************
+  Here begins the real working methods for the tokenizer.
+ *******************************************************************/
+
+/**
+ *  This method repeatedly called by the tokenizer. 
+ *  Each time, we determine the kind of token were about to 
+ *  read, and then we call the appropriate method to handle
+ *  that token type.
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsXMLTokenizer::ConsumeToken(nsScanner& aScanner) {
+  return nsHTMLTokenizer::ConsumeToken(aScanner);
+}
+
+
+nsITokenRecycler* nsXMLTokenizer::GetTokenRecycler(void) {
+  return nsHTMLTokenizer::GetTokenRecycler();
+}
+
+/*
+ * Consume characters as long as they match the string passed in.
+ * If they don't match, put them all back. 
+ * XXX The scanner should be able to do this.
+ *
+ *  @update vidur 11/12/98
+ */
+nsresult ConsumeConditional(nsScanner& aScanner,const nsString& aMatchString,PRBool& aMatch) {
+  nsresult result=NS_OK;
+  PRUnichar matchChar;
+
+  PRInt32 i, count = aMatchString.Length();
+  for (i=0; i < count; i++) {
+    result = aScanner.GetChar(matchChar);
+    if ((NS_OK != result) || (aMatchString.CharAt(i) != matchChar)) {
+      break;
+    }
+  }
+
+  if (NS_OK == result) {
+    if (i != count) {
+      for (; i >= 0; i--) {
+        aScanner.PutBack(aMatchString.CharAt(i));
+      }
+      aMatch = PR_FALSE;
+    }
+    else {
+      aMatch = PR_TRUE;
+    }
+  }
+
+  return result;
+}
+
+/**
+ *  This method is called just after a "<!" has been consumed 
+ *  and we know we're at the start of a comment.  
+ *  
+ *  @update gess 3/25/98
+ *  @param  aChar: last char read
+ *  @param  aScanner: see nsScanner.h
+ *  @param  anErrorCode: arg that will hold error condition
+ *  @return new token or null 
+ */
+nsresult nsXMLTokenizer::ConsumeComment(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken){
+  nsresult result=NS_OK;
+  nsAutoString CDATAString("[CDATA[");
+  PRBool isCDATA = PR_FALSE;
+
+  result = ConsumeConditional(aScanner, CDATAString, isCDATA);
+  CTokenRecycler* theRecycler=(CTokenRecycler*)GetTokenRecycler();
+
+  if (NS_OK == result) {
+    if (isCDATA) {
+      aToken=theRecycler->CreateTokenOfType(eToken_cdatasection,eHTMLTag_unknown,gEmpty);
+    }
+    else {
+      aToken=theRecycler->CreateTokenOfType(eToken_comment,eHTMLTag_comment,gEmpty);
+    }
+  }
+
+  return result;
+}
+
+
+
+/**
+ * 
+ * @update	gess12/28/98
+ * @param 
+ * @return
+ */
+nsresult nsXMLTokenizer::HandleSkippedContent(nsScanner& aScanner,CToken*& aToken) {
+  nsresult result=NS_OK;
+  return result;
+}
diff --git a/parser/htmlparser/src/nsXMLTokenizer.h b/parser/htmlparser/src/nsXMLTokenizer.h
new file mode 100644
index 000000000000..75bd893e7930
--- /dev/null
+++ b/parser/htmlparser/src/nsXMLTokenizer.h
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+/**
+ * MODULE NOTES:
+ * @update  gess 4/1/98
+ * 
+ */
+
+#ifndef __NSXMLTOKENIZER
+#define __NSXMLTOKENIZER
+
+#include "nsISupports.h"
+#include "nsHTMLTokenizer.h"
+#include "nsIParser.h"
+#include "nsIDTD.h"
+#include "prtypes.h"
+#include "nsDeque.h"
+#include "nsScanner.h"
+#include "nsHTMLTokens.h"
+
+#define NS_XMLTOKENIZER_IID      \
+  {0xcf22e1fa, 0x9ed2, 0x11d2, { 0xba, 0xa5, 0x0, 0x10, 0x4b, 0x98, 0x3f, 0xd4 }}
+
+
+
+/***************************************************************
+  Notes: 
+ ***************************************************************/
+
+#if defined(XP_PC)
+#pragma warning( disable : 4275 )
+#endif
+
+CLASS_EXPORT_HTMLPARS nsXMLTokenizer : public nsHTMLTokenizer {
+public:
+            nsXMLTokenizer();
+            ~nsXMLTokenizer();
+
+            NS_DECL_ISUPPORTS
+
+  virtual nsresult          ConsumeToken(nsScanner& aScanner);
+  virtual nsITokenRecycler* GetTokenRecycler(void);
+
+protected:
+
+  virtual nsresult HandleSkippedContent(nsScanner& aScanner,CToken*& aToken);
+  virtual nsresult ConsumeComment(PRUnichar aChar,nsScanner& aScanner,CToken*& aToken);
+
+};
+
+extern NS_HTMLPARS nsresult NS_NewXMLTokenizer(nsIDTD** aInstancePtrResult);
+
+#endif
+
+