convert HTML_TOKEN_IDS to scoped enum

Change-Id: I525506e0103e4f17e5b8b95f15c1285d65b93de9
Reviewed-on: https://gerrit.libreoffice.org/37220
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

4 files changed, 444 insertions, 392 deletions

diff --git a/svtools/source/svhtml/htmlkywd.cxx b/svtools/source/svhtml/htmlkywd.cxx
index 599a3c205586..339cb36c0737 100644
--- a/svtools/source/svhtml/htmlkywd.cxx
+++ b/svtools/source/svhtml/htmlkywd.cxx
@@ -34,128 +34,128 @@ struct HTML_TokenEntry
         const sal_Char *sToken;
         const OUString *pUToken;
     };
-    int nToken;
+    HtmlTokenId nToken;
 };
 
 // Flag: RTF token table has already been sorted
 static bool bSortKeyWords = false;
 
 static HTML_TokenEntry aHTMLTokenTab[] = {
-    {{OOO_STRING_SVTOOLS_HTML_area},            HTML_AREA}, // Netscape 2.0
-    {{OOO_STRING_SVTOOLS_HTML_base},            HTML_BASE}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_comment},     HTML_COMMENT},
-    {{OOO_STRING_SVTOOLS_HTML_doctype},      HTML_DOCTYPE},
-    {{OOO_STRING_SVTOOLS_HTML_embed},       HTML_EMBED},    // Netscape 2.0
-    {{OOO_STRING_SVTOOLS_HTML_horzrule},        HTML_HORZRULE},
-    {{OOO_STRING_SVTOOLS_HTML_image},          HTML_IMAGE},
-    {{OOO_STRING_SVTOOLS_HTML_input},          HTML_INPUT},
-    {{OOO_STRING_SVTOOLS_HTML_linebreak},      HTML_LINEBREAK},
-    {{OOO_STRING_SVTOOLS_HTML_link},            HTML_LINK}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_meta},            HTML_META}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_option},        HTML_OPTION},
-    {{OOO_STRING_SVTOOLS_HTML_param},       HTML_PARAM},    // HotJava
-    {{OOO_STRING_SVTOOLS_HTML_spacer},      HTML_SPACER},   // Netscape 3.0b5
-
-    {{OOO_STRING_SVTOOLS_HTML_abbreviation},    HTML_ABBREVIATION_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_acronym},     HTML_ACRONYM_ON},   // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_address},      HTML_ADDRESS_ON},
-    {{OOO_STRING_SVTOOLS_HTML_anchor},        HTML_ANCHOR_ON},
-    {{OOO_STRING_SVTOOLS_HTML_applet},      HTML_APPLET_ON},    // HotJava
-    {{OOO_STRING_SVTOOLS_HTML_author},      HTML_AUTHOR_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_banner},      HTML_BANNER_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_basefont},        HTML_BASEFONT_ON},  // Netscape
-    {{OOO_STRING_SVTOOLS_HTML_bigprint},        HTML_BIGPRINT_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_blink},       HTML_BLINK_ON}, // Netscape
-    {{OOO_STRING_SVTOOLS_HTML_blockquote},    HTML_BLOCKQUOTE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_blockquote30},    HTML_BLOCKQUOTE30_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_body},            HTML_BODY_ON},
-    {{OOO_STRING_SVTOOLS_HTML_bold},            HTML_BOLD_ON},
-    {{OOO_STRING_SVTOOLS_HTML_caption},     HTML_CAPTION_ON},   // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_center},      HTML_CENTER_ON},    // Netscape
-    {{OOO_STRING_SVTOOLS_HTML_citiation},      HTML_CITIATION_ON},
-    {{OOO_STRING_SVTOOLS_HTML_col},             HTML_COL_ON}, // HTML 3 Table Model Draft
-    {{OOO_STRING_SVTOOLS_HTML_colgroup},        HTML_COLGROUP_ON}, // HTML 3 Table Model Draft
-    {{OOO_STRING_SVTOOLS_HTML_code},            HTML_CODE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_credit},      HTML_CREDIT_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_dd},            HTML_DD_ON},
-    {{OOO_STRING_SVTOOLS_HTML_deflist},      HTML_DEFLIST_ON},
-    {{OOO_STRING_SVTOOLS_HTML_deletedtext}, HTML_DELETEDTEXT_ON},   // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_dirlist},      HTML_DIRLIST_ON},
-    {{OOO_STRING_SVTOOLS_HTML_division},        HTML_DIVISION_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_dt},            HTML_DT_ON},
-    {{OOO_STRING_SVTOOLS_HTML_emphasis},        HTML_EMPHASIS_ON},
-    {{OOO_STRING_SVTOOLS_HTML_figure},      HTML_FIGURE_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_font},            HTML_FONT_ON}, // Netscape
-    {{OOO_STRING_SVTOOLS_HTML_footnote},        HTML_FOOTNOTE_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_form},            HTML_FORM_ON},
-    {{OOO_STRING_SVTOOLS_HTML_frame},       HTML_FRAME_ON}, // Netscape 2.0
-    {{OOO_STRING_SVTOOLS_HTML_frameset},        HTML_FRAMESET_ON},  // Netscape 2.0
-    {{OOO_STRING_SVTOOLS_HTML_head},            HTML_HEAD_ON},
-    {{OOO_STRING_SVTOOLS_HTML_head1},          HTML_HEAD1_ON},
-    {{OOO_STRING_SVTOOLS_HTML_head2},          HTML_HEAD2_ON},
-    {{OOO_STRING_SVTOOLS_HTML_head3},          HTML_HEAD3_ON},
-    {{OOO_STRING_SVTOOLS_HTML_head4},          HTML_HEAD4_ON},
-    {{OOO_STRING_SVTOOLS_HTML_head5},          HTML_HEAD5_ON},
-    {{OOO_STRING_SVTOOLS_HTML_head6},          HTML_HEAD6_ON},
-    {{OOO_STRING_SVTOOLS_HTML_html},            HTML_HTML_ON},
-    {{OOO_STRING_SVTOOLS_HTML_iframe},      HTML_IFRAME_ON},    // IE 3.0b2
-    {{OOO_STRING_SVTOOLS_HTML_insertedtext},    HTML_INSERTEDTEXT_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_italic},        HTML_ITALIC_ON},
-    {{OOO_STRING_SVTOOLS_HTML_keyboard},        HTML_KEYBOARD_ON},
-    {{OOO_STRING_SVTOOLS_HTML_language},        HTML_LANGUAGE_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_li},            HTML_LI_ON},
-    {{OOO_STRING_SVTOOLS_HTML_listheader},  HTML_LISTHEADER_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_map},         HTML_MAP_ON},   // Netscape 2.0
-    {{OOO_STRING_SVTOOLS_HTML_menulist},        HTML_MENULIST_ON},
-    {{OOO_STRING_SVTOOLS_HTML_multicol},        HTML_MULTICOL_ON},  // Netscape 3.0b5
-    {{OOO_STRING_SVTOOLS_HTML_nobr},            HTML_NOBR_ON},  // Netscape
-    {{OOO_STRING_SVTOOLS_HTML_noembed},     HTML_NOEMBED_ON},   // Netscape 2.0 ???
-    {{OOO_STRING_SVTOOLS_HTML_noframe},     HTML_NOFRAMES_ON},  // Netscape 2.0 ???
-    {{OOO_STRING_SVTOOLS_HTML_noframes},        HTML_NOFRAMES_ON},  // Netscape 2.0
-    {{OOO_STRING_SVTOOLS_HTML_noscript},        HTML_NOSCRIPT_ON},  // Netscape 3.0
-    {{OOO_STRING_SVTOOLS_HTML_note},            HTML_NOTE_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_object},     HTML_OBJECT_ON},
-    {{OOO_STRING_SVTOOLS_HTML_orderlist},      HTML_ORDERLIST_ON},
-    {{OOO_STRING_SVTOOLS_HTML_parabreak},      HTML_PARABREAK_ON},
-    {{OOO_STRING_SVTOOLS_HTML_person},      HTML_PERSON_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_plaintext},   HTML_PLAINTEXT_ON}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_preformtxt},    HTML_PREFORMTXT_ON},
-    {{OOO_STRING_SVTOOLS_HTML_sample},        HTML_SAMPLE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_script},        HTML_SCRIPT_ON}, // HTML 3.2
-    {{OOO_STRING_SVTOOLS_HTML_select},        HTML_SELECT_ON},
-    {{OOO_STRING_SVTOOLS_HTML_shortquote},  HTML_SHORTQUOTE_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_smallprint},  HTML_SMALLPRINT_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_span},            HTML_SPAN_ON},  // Style Sheets
-    {{OOO_STRING_SVTOOLS_HTML_strikethrough},HTML_STRIKETHROUGH_ON},    // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_strong},        HTML_STRONG_ON},
-    {{OOO_STRING_SVTOOLS_HTML_style},       HTML_STYLE_ON}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_subscript},   HTML_SUBSCRIPT_ON}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_superscript}, HTML_SUPERSCRIPT_ON},   // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_table},       HTML_TABLE_ON}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_tabledata},   HTML_TABLEDATA_ON}, // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_tableheader}, HTML_TABLEHEADER_ON},   // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_tablerow},        HTML_TABLEROW_ON},  // HTML 3.0
-    {{OOO_STRING_SVTOOLS_HTML_tbody},          HTML_TBODY_ON}, // HTML 3 Table Model Draft
-    {{OOO_STRING_SVTOOLS_HTML_teletype},        HTML_TELETYPE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_textarea},        HTML_TEXTAREA_ON},
-    {{OOO_STRING_SVTOOLS_HTML_tfoot},          HTML_TFOOT_ON}, // HTML 3 Table Model Draft
-    {{OOO_STRING_SVTOOLS_HTML_thead},          HTML_THEAD_ON}, // HTML 3 Table Model Draft
-    {{OOO_STRING_SVTOOLS_HTML_title},          HTML_TITLE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_underline},      HTML_UNDERLINE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_unorderlist},  HTML_UNORDERLIST_ON},
-    {{OOO_STRING_SVTOOLS_HTML_variable},        HTML_VARIABLE_ON},
-
-    {{OOO_STRING_SVTOOLS_HTML_xmp},         HTML_XMP_ON},
-    {{OOO_STRING_SVTOOLS_HTML_listing},     HTML_LISTING_ON},
-
-    {{OOO_STRING_SVTOOLS_HTML_definstance},  HTML_DEFINSTANCE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_strike},        HTML_STRIKE_ON},
-
-    {{OOO_STRING_SVTOOLS_HTML_comment2},        HTML_COMMENT2_ON},
-    {{OOO_STRING_SVTOOLS_HTML_marquee},         HTML_MARQUEE_ON},
-    {{OOO_STRING_SVTOOLS_HTML_plaintext2},    HTML_PLAINTEXT2_ON},
-
-    {{OOO_STRING_SVTOOLS_HTML_sdfield},     HTML_SDFIELD_ON}
+    {{OOO_STRING_SVTOOLS_HTML_area},            HtmlTokenId::AREA}, // Netscape 2.0
+    {{OOO_STRING_SVTOOLS_HTML_base},            HtmlTokenId::BASE}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_comment},     HtmlTokenId::COMMENT},
+    {{OOO_STRING_SVTOOLS_HTML_doctype},      HtmlTokenId::DOCTYPE},
+    {{OOO_STRING_SVTOOLS_HTML_embed},       HtmlTokenId::EMBED},    // Netscape 2.0
+    {{OOO_STRING_SVTOOLS_HTML_horzrule},        HtmlTokenId::HORZRULE},
+    {{OOO_STRING_SVTOOLS_HTML_image},          HtmlTokenId::IMAGE},
+    {{OOO_STRING_SVTOOLS_HTML_input},          HtmlTokenId::INPUT},
+    {{OOO_STRING_SVTOOLS_HTML_linebreak},      HtmlTokenId::LINEBREAK},
+    {{OOO_STRING_SVTOOLS_HTML_link},            HtmlTokenId::LINK}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_meta},            HtmlTokenId::META}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_option},        HtmlTokenId::OPTION},
+    {{OOO_STRING_SVTOOLS_HTML_param},       HtmlTokenId::PARAM},    // HotJava
+    {{OOO_STRING_SVTOOLS_HTML_spacer},      HtmlTokenId::SPACER},   // Netscape 3.0b5
+
+    {{OOO_STRING_SVTOOLS_HTML_abbreviation},    HtmlTokenId::ABBREVIATION_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_acronym},     HtmlTokenId::ACRONYM_ON},   // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_address},      HtmlTokenId::ADDRESS_ON},
+    {{OOO_STRING_SVTOOLS_HTML_anchor},        HtmlTokenId::ANCHOR_ON},
+    {{OOO_STRING_SVTOOLS_HTML_applet},      HtmlTokenId::APPLET_ON},    // HotJava
+    {{OOO_STRING_SVTOOLS_HTML_author},      HtmlTokenId::AUTHOR_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_banner},      HtmlTokenId::BANNER_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_basefont},        HtmlTokenId::BASEFONT_ON},  // Netscape
+    {{OOO_STRING_SVTOOLS_HTML_bigprint},        HtmlTokenId::BIGPRINT_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_blink},       HtmlTokenId::BLINK_ON}, // Netscape
+    {{OOO_STRING_SVTOOLS_HTML_blockquote},    HtmlTokenId::BLOCKQUOTE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_blockquote30},    HtmlTokenId::BLOCKQUOTE30_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_body},            HtmlTokenId::BODY_ON},
+    {{OOO_STRING_SVTOOLS_HTML_bold},            HtmlTokenId::BOLD_ON},
+    {{OOO_STRING_SVTOOLS_HTML_caption},     HtmlTokenId::CAPTION_ON},   // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_center},      HtmlTokenId::CENTER_ON},    // Netscape
+    {{OOO_STRING_SVTOOLS_HTML_citiation},      HtmlTokenId::CITIATION_ON},
+    {{OOO_STRING_SVTOOLS_HTML_col},             HtmlTokenId::COL_ON}, // HTML 3 Table Model Draft
+    {{OOO_STRING_SVTOOLS_HTML_colgroup},        HtmlTokenId::COLGROUP_ON}, // HTML 3 Table Model Draft
+    {{OOO_STRING_SVTOOLS_HTML_code},            HtmlTokenId::CODE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_credit},      HtmlTokenId::CREDIT_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_dd},            HtmlTokenId::DD_ON},
+    {{OOO_STRING_SVTOOLS_HTML_deflist},      HtmlTokenId::DEFLIST_ON},
+    {{OOO_STRING_SVTOOLS_HTML_deletedtext}, HtmlTokenId::DELETEDTEXT_ON},   // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_dirlist},      HtmlTokenId::DIRLIST_ON},
+    {{OOO_STRING_SVTOOLS_HTML_division},        HtmlTokenId::DIVISION_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_dt},            HtmlTokenId::DT_ON},
+    {{OOO_STRING_SVTOOLS_HTML_emphasis},        HtmlTokenId::EMPHASIS_ON},
+    {{OOO_STRING_SVTOOLS_HTML_figure},      HtmlTokenId::FIGURE_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_font},            HtmlTokenId::FONT_ON}, // Netscape
+    {{OOO_STRING_SVTOOLS_HTML_footnote},        HtmlTokenId::FOOTNOTE_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_form},            HtmlTokenId::FORM_ON},
+    {{OOO_STRING_SVTOOLS_HTML_frame},       HtmlTokenId::FRAME_ON}, // Netscape 2.0
+    {{OOO_STRING_SVTOOLS_HTML_frameset},        HtmlTokenId::FRAMESET_ON},  // Netscape 2.0
+    {{OOO_STRING_SVTOOLS_HTML_head},            HtmlTokenId::HEAD_ON},
+    {{OOO_STRING_SVTOOLS_HTML_head1},          HtmlTokenId::HEAD1_ON},
+    {{OOO_STRING_SVTOOLS_HTML_head2},          HtmlTokenId::HEAD2_ON},
+    {{OOO_STRING_SVTOOLS_HTML_head3},          HtmlTokenId::HEAD3_ON},
+    {{OOO_STRING_SVTOOLS_HTML_head4},          HtmlTokenId::HEAD4_ON},
+    {{OOO_STRING_SVTOOLS_HTML_head5},          HtmlTokenId::HEAD5_ON},
+    {{OOO_STRING_SVTOOLS_HTML_head6},          HtmlTokenId::HEAD6_ON},
+    {{OOO_STRING_SVTOOLS_HTML_html},            HtmlTokenId::HTML_ON},
+    {{OOO_STRING_SVTOOLS_HTML_iframe},      HtmlTokenId::IFRAME_ON},    // IE 3.0b2
+    {{OOO_STRING_SVTOOLS_HTML_insertedtext},    HtmlTokenId::INSERTEDTEXT_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_italic},        HtmlTokenId::ITALIC_ON},
+    {{OOO_STRING_SVTOOLS_HTML_keyboard},        HtmlTokenId::KEYBOARD_ON},
+    {{OOO_STRING_SVTOOLS_HTML_language},        HtmlTokenId::LANGUAGE_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_li},            HtmlTokenId::LI_ON},
+    {{OOO_STRING_SVTOOLS_HTML_listheader},  HtmlTokenId::LISTHEADER_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_map},         HtmlTokenId::MAP_ON},   // Netscape 2.0
+    {{OOO_STRING_SVTOOLS_HTML_menulist},        HtmlTokenId::MENULIST_ON},
+    {{OOO_STRING_SVTOOLS_HTML_multicol},        HtmlTokenId::MULTICOL_ON},  // Netscape 3.0b5
+    {{OOO_STRING_SVTOOLS_HTML_nobr},            HtmlTokenId::NOBR_ON},  // Netscape
+    {{OOO_STRING_SVTOOLS_HTML_noembed},     HtmlTokenId::NOEMBED_ON},   // Netscape 2.0 ???
+    {{OOO_STRING_SVTOOLS_HTML_noframe},     HtmlTokenId::NOFRAMES_ON},  // Netscape 2.0 ???
+    {{OOO_STRING_SVTOOLS_HTML_noframes},        HtmlTokenId::NOFRAMES_ON},  // Netscape 2.0
+    {{OOO_STRING_SVTOOLS_HTML_noscript},        HtmlTokenId::NOSCRIPT_ON},  // Netscape 3.0
+    {{OOO_STRING_SVTOOLS_HTML_note},            HtmlTokenId::NOTE_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_object},     HtmlTokenId::OBJECT_ON},
+    {{OOO_STRING_SVTOOLS_HTML_orderlist},      HtmlTokenId::ORDERLIST_ON},
+    {{OOO_STRING_SVTOOLS_HTML_parabreak},      HtmlTokenId::PARABREAK_ON},
+    {{OOO_STRING_SVTOOLS_HTML_person},      HtmlTokenId::PERSON_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_plaintext},   HtmlTokenId::PLAINTEXT_ON}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_preformtxt},    HtmlTokenId::PREFORMTXT_ON},
+    {{OOO_STRING_SVTOOLS_HTML_sample},        HtmlTokenId::SAMPLE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_script},        HtmlTokenId::SCRIPT_ON}, // HTML 3.2
+    {{OOO_STRING_SVTOOLS_HTML_select},        HtmlTokenId::SELECT_ON},
+    {{OOO_STRING_SVTOOLS_HTML_shortquote},  HtmlTokenId::SHORTQUOTE_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_smallprint},  HtmlTokenId::SMALLPRINT_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_span},            HtmlTokenId::SPAN_ON},  // Style Sheets
+    {{OOO_STRING_SVTOOLS_HTML_strikethrough}, HtmlTokenId::STRIKETHROUGH_ON},    // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_strong},        HtmlTokenId::STRONG_ON},
+    {{OOO_STRING_SVTOOLS_HTML_style},       HtmlTokenId::STYLE_ON}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_subscript},   HtmlTokenId::SUBSCRIPT_ON}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_superscript}, HtmlTokenId::SUPERSCRIPT_ON},   // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_table},       HtmlTokenId::TABLE_ON}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_tabledata},   HtmlTokenId::TABLEDATA_ON}, // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_tableheader}, HtmlTokenId::TABLEHEADER_ON},   // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_tablerow},        HtmlTokenId::TABLEROW_ON},  // HTML 3.0
+    {{OOO_STRING_SVTOOLS_HTML_tbody},          HtmlTokenId::TBODY_ON}, // HTML 3 Table Model Draft
+    {{OOO_STRING_SVTOOLS_HTML_teletype},        HtmlTokenId::TELETYPE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_textarea},        HtmlTokenId::TEXTAREA_ON},
+    {{OOO_STRING_SVTOOLS_HTML_tfoot},          HtmlTokenId::TFOOT_ON}, // HTML 3 Table Model Draft
+    {{OOO_STRING_SVTOOLS_HTML_thead},          HtmlTokenId::THEAD_ON}, // HTML 3 Table Model Draft
+    {{OOO_STRING_SVTOOLS_HTML_title},          HtmlTokenId::TITLE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_underline},      HtmlTokenId::UNDERLINE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_unorderlist},  HtmlTokenId::UNORDERLIST_ON},
+    {{OOO_STRING_SVTOOLS_HTML_variable},        HtmlTokenId::VARIABLE_ON},
+
+    {{OOO_STRING_SVTOOLS_HTML_xmp},         HtmlTokenId::XMP_ON},
+    {{OOO_STRING_SVTOOLS_HTML_listing},     HtmlTokenId::LISTING_ON},
+
+    {{OOO_STRING_SVTOOLS_HTML_definstance},  HtmlTokenId::DEFINSTANCE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_strike},        HtmlTokenId::STRIKE_ON},
+
+    {{OOO_STRING_SVTOOLS_HTML_comment2},        HtmlTokenId::COMMENT2_ON},
+    {{OOO_STRING_SVTOOLS_HTML_marquee},         HtmlTokenId::MARQUEE_ON},
+    {{OOO_STRING_SVTOOLS_HTML_plaintext2},    HtmlTokenId::PLAINTEXT2_ON},
+
+    {{OOO_STRING_SVTOOLS_HTML_sdfield},     HtmlTokenId::SDFIELD_ON}
 };
 
 
@@ -167,16 +167,16 @@ static int SAL_CALL HTMLKeyCompare( const void *pFirst, const void *pSecond)
     HTML_TokenEntry const * pFirstEntry = static_cast<HTML_TokenEntry const *>(pFirst);
     HTML_TokenEntry const * pSecondEntry = static_cast<HTML_TokenEntry const *>(pSecond);
     int nRet = 0;
-    if( -1 == pFirstEntry->nToken )
+    if( HtmlTokenId::INVALID == pFirstEntry->nToken )
     {
-        if( -1 == pSecondEntry->nToken )
+        if( HtmlTokenId::INVALID == pSecondEntry->nToken )
             nRet = pFirstEntry->pUToken->compareTo( *pSecondEntry->pUToken );
         else
             nRet = pFirstEntry->pUToken->compareToAscii( pSecondEntry->sToken );
     }
     else
     {
-        if( -1 == pSecondEntry->nToken )
+        if( HtmlTokenId::INVALID == pSecondEntry->nToken )
             nRet = -1 * pSecondEntry->pUToken->compareToAscii( pFirstEntry->sToken );
         else
             nRet = strcmp( pFirstEntry->sToken, pSecondEntry->sToken );
@@ -187,7 +187,7 @@ static int SAL_CALL HTMLKeyCompare( const void *pFirst, const void *pSecond)
 
 }
 
-int GetHTMLToken( const OUString& rName )
+HtmlTokenId GetHTMLToken( const OUString& rName )
 {
     if( !bSortKeyWords )
     {
@@ -198,15 +198,15 @@ int GetHTMLToken( const OUString& rName )
         bSortKeyWords = true;
     }
 
-    int nRet = 0;
+    HtmlTokenId nRet = HtmlTokenId::NONE;
 
     if( !rName.compareTo( OOO_STRING_SVTOOLS_HTML_comment, 3  ) )
-        return HTML_COMMENT;
+        return HtmlTokenId::COMMENT;
 
     void* pFound;
     HTML_TokenEntry aSrch;
     aSrch.pUToken = &rName;
-    aSrch.nToken = -1;
+    aSrch.nToken = HtmlTokenId::INVALID;
 
     pFound = bsearch( &aSrch,
                       static_cast<void*>(aHTMLTokenTab),
@@ -732,7 +732,7 @@ HtmlOptionId GetHTMLOption( const OUString& rName )
     void* pFound;
     HTML_TokenEntry aSrch;
     aSrch.pUToken = &rName;
-    aSrch.nToken = -1;
+    aSrch.nToken = HtmlTokenId::INVALID;
 
     if( nullptr != ( pFound = bsearch( &aSrch,
                         static_cast<void*>(aHTMLOptionTab),
diff --git a/svtools/source/svhtml/parhtml.cxx b/svtools/source/svhtml/parhtml.cxx
index f0826f8acdde..c35856b9ba88 100644
--- a/svtools/source/svhtml/parhtml.cxx
+++ b/svtools/source/svhtml/parhtml.cxx
@@ -212,7 +212,7 @@ HTMLTableRules HTMLOption::GetTableRules() const
 }
 
 HTMLParser::HTMLParser( SvStream& rIn, bool bReadNewDoc ) :
-    SvParser( rIn ),
+    SvParser<HtmlTokenId>( rIn ),
     bNewDoc(bReadNewDoc),
     bIsInHeader(true),
     bIsInBody(false),
@@ -227,7 +227,7 @@ HTMLParser::HTMLParser( SvStream& rIn, bool bReadNewDoc ) :
     bReadNextChar(false),
     bReadComment(false),
     nPre_LinePos(0),
-    mnPendingOffToken(0)
+    mnPendingOffToken(HtmlTokenId::NONE)
 {
     //#i76649, default to UTF-8 for HTML unless we know differently
     SetSrcEncoding(RTL_TEXTENCODING_UTF8);
@@ -241,22 +241,22 @@ SvParserState HTMLParser::CallParser()
 {
     eState = SvParserState::Working;
     nNextCh = GetNextChar();
-    SaveState( 0 );
+    SaveState( HtmlTokenId::NONE );
 
     nPre_LinePos = 0;
     bPre_IgnoreNewPara = false;
 
     AddFirstRef();
-    Continue( 0 );
+    Continue( HtmlTokenId::NONE );
     if( SvParserState::Pending != eState )
         ReleaseRef();       // Parser not needed anymore
 
     return eState;
 }
 
-void HTMLParser::Continue( int nToken )
+void HTMLParser::Continue( HtmlTokenId nToken )
 {
-    if( !nToken )
+    if( nToken == HtmlTokenId::NONE )
         nToken = GetNextToken();
 
     while( IsParserWorking() )
@@ -264,73 +264,73 @@ void HTMLParser::Continue( int nToken )
         SaveState( nToken );
         nToken = FilterToken( nToken );
 
-        if( nToken )
+        if( nToken != HtmlTokenId::NONE )
             NextToken( nToken );
 
         if( IsParserWorking() )
-            SaveState( 0 );         // continue with new token
+            SaveState( HtmlTokenId::NONE );         // continue with new token
 
         nToken = GetNextToken();
     }
 }
 
-int HTMLParser::FilterToken( int nToken )
+HtmlTokenId HTMLParser::FilterToken( HtmlTokenId nToken )
 {
     switch( nToken )
     {
-    case sal_Unicode(EOF):
-        nToken = 0;
+    case HtmlTokenId(EOF):
+        nToken = HtmlTokenId::NONE;
         break;          // don't pass
 
-    case HTML_HEAD_OFF:
+    case HtmlTokenId::HEAD_OFF:
         bIsInBody = true;
         bIsInHeader = false;
         break;
 
-    case HTML_HEAD_ON:
+    case HtmlTokenId::HEAD_ON:
         bIsInHeader = true;
         break;
 
-    case HTML_BODY_ON:
+    case HtmlTokenId::BODY_ON:
         bIsInHeader = false;
         bIsInBody = true;
         break;
 
-    case HTML_FRAMESET_ON:
+    case HtmlTokenId::FRAMESET_ON:
         bIsInHeader = false;
         bIsInBody = false;
         break;
 
-    case HTML_BODY_OFF:
+    case HtmlTokenId::BODY_OFF:
         bIsInBody = bReadPRE = bReadListing = bReadXMP = false;
         break;
 
-    case HTML_HTML_OFF:
-        nToken = 0;
+    case HtmlTokenId::HTML_OFF:
+        nToken = HtmlTokenId::NONE;
         bReadPRE = bReadListing = bReadXMP = false;
-        break;      // HTML_ON hasn't been passed either !
+        break;      // HtmlTokenId::ON hasn't been passed either !
 
-    case HTML_PREFORMTXT_ON:
+    case HtmlTokenId::PREFORMTXT_ON:
         StartPRE();
         break;
 
-    case HTML_PREFORMTXT_OFF:
+    case HtmlTokenId::PREFORMTXT_OFF:
         FinishPRE();
         break;
 
-    case HTML_LISTING_ON:
+    case HtmlTokenId::LISTING_ON:
         StartListing();
         break;
 
-    case HTML_LISTING_OFF:
+    case HtmlTokenId::LISTING_OFF:
         FinishListing();
         break;
 
-    case HTML_XMP_ON:
+    case HtmlTokenId::XMP_ON:
         StartXMP();
         break;
 
-    case HTML_XMP_OFF:
+    case HtmlTokenId::XMP_OFF:
         FinishXMP();
         break;
 
@@ -355,7 +355,7 @@ int HTMLParser::FilterToken( int nToken )
 #define HTML_ISPRINTABLE( c ) ( c >= 32 && c != 127)
 #define HTML_ISHEXDIGIT( c ) rtl::isAsciiHexDigit(c)
 
-int HTMLParser::ScanText( const sal_Unicode cBreak )
+HtmlTokenId HTMLParser::ScanText( const sal_Unicode cBreak )
 {
     OUStringBuffer sTmpBuffer( MAX_LEN );
     bool bContinue = true;
@@ -530,7 +530,7 @@ int HTMLParser::ScanText( const sal_Unicode cBreak )
                                     rInput.Seek( nStreamPos );
                                     nlLinePos = nLinePos;
                                     ClearTxtConvContext();
-                                    return HTML_TEXTTOKEN;
+                                    return HtmlTokenId::TEXTTOKEN;
                                 }
 
                                 // Hack: _GetNextChar shall not read the
@@ -538,9 +538,9 @@ int HTMLParser::ScanText( const sal_Unicode cBreak )
                                 if( ';' != nNextCh )
                                     aToken += " ";
                                 if( 1U == cChar )
-                                    return HTML_NONBREAKSPACE;
+                                    return HtmlTokenId::NONBREAKSPACE;
                                 else //2U
-                                    return HTML_SOFTHYPH;
+                                    return HtmlTokenId::SOFTHYPH;
                             }
                         }
                     }
@@ -700,12 +700,12 @@ int HTMLParser::ScanText( const sal_Unicode cBreak )
                         {
                             // Have seen s.th. aside from blanks?
                             aToken += sTmpBuffer.makeStringAndClear();
-                            return HTML_TEXTTOKEN;
+                            return HtmlTokenId::TEXTTOKEN;
                         }
                         else
                             // Only read blanks: no text must be returned
                             // and GetNextToken_ has to read until EOF
-                            return 0;
+                            return HtmlTokenId::NONE;
                     }
                 } while ( ' ' == nNextCh || '\t' == nNextCh ||
                           '\r' == nNextCh || '\n' == nNextCh ||
@@ -733,7 +733,7 @@ int HTMLParser::ScanText( const sal_Unicode cBreak )
                     {
                         if( !sTmpBuffer.isEmpty() )
                             aToken += sTmpBuffer.makeStringAndClear();
-                        return HTML_TEXTTOKEN;
+                        return HtmlTokenId::TEXTTOKEN;
                     }
                 } while( HTML_ISALPHA( nNextCh ) || HTML_ISDIGIT( nNextCh ) );
                 bNextCh = false;
@@ -750,10 +750,10 @@ int HTMLParser::ScanText( const sal_Unicode cBreak )
     if( !sTmpBuffer.isEmpty() )
         aToken += sTmpBuffer.makeStringAndClear();
 
-    return HTML_TEXTTOKEN;
+    return HtmlTokenId::TEXTTOKEN;
 }
 
-int HTMLParser::GetNextRawToken()
+HtmlTokenId HTMLParser::GetNextRawToken()
 {
     OUStringBuffer sTmpBuffer( MAX_LEN );
 
@@ -766,13 +766,13 @@ int HTMLParser::GetNextRawToken()
         aEndToken.clear();
         bEndTokenFound = false;
 
-        return 0;
+        return HtmlTokenId::NONE;
     }
 
-    // Default return value: HTML_RAWDATA
+    // Default return value: HtmlTokenId::RAWDATA
     bool bContinue = true;
-    int nToken = HTML_RAWDATA;
-    SaveState( 0 );
+    HtmlTokenId nToken = HtmlTokenId::RAWDATA;
+    SaveState( HtmlTokenId::NONE );
     while( bContinue && IsParserWorking() )
     {
         bool bNextCh = true;
@@ -863,7 +863,7 @@ int HTMLParser::GetNextRawToken()
                         bReadScript = false;
                         bReadStyle = false;
                         aEndToken.clear();
-                        nToken = 0;
+                        nToken = HtmlTokenId::NONE;
                     }
                     else
                     {
@@ -943,7 +943,7 @@ int HTMLParser::GetNextRawToken()
                     bReadScript = false;
                     bReadStyle = false;
                     aEndToken.clear();
-                    nToken = 0;
+                    nToken = HtmlTokenId::NONE;
                 }
                 break;
             }
@@ -963,24 +963,24 @@ int HTMLParser::GetNextRawToken()
     }
 
     if( IsParserWorking() )
-        SaveState( 0 );
+        SaveState( HtmlTokenId::NONE );
     else
-        nToken = 0;
+        nToken = HtmlTokenId::NONE;
 
     return nToken;
 }
 
 // Scan next token
-int HTMLParser::GetNextToken_()
+HtmlTokenId HTMLParser::GetNextToken_()
 {
-    int nRet = 0;
+    HtmlTokenId nRet = HtmlTokenId::NONE;
     sSaveToken.clear();
 
-    if (mnPendingOffToken)
+    if (mnPendingOffToken != HtmlTokenId::NONE)
     {
-        // HTML_<TOKEN>_OFF generated for HTML_<TOKEN>_ON
+        // HtmlTokenId::<TOKEN>_OFF generated for HtmlTokenId::<TOKEN>_ON
         nRet = mnPendingOffToken;
-        mnPendingOffToken = 0;
+        mnPendingOffToken = HtmlTokenId::NONE;
         aToken.clear();
         return nRet;
     }
@@ -990,7 +990,7 @@ int HTMLParser::GetNextToken_()
         maOptions.clear();
 
     if( !IsParserWorking() )        // Don't continue if already an error occurred
-        return 0;
+        return HtmlTokenId::NONE;
 
     bool bReadNextCharSave = bReadNextChar;
     if( bReadNextChar )
@@ -999,14 +999,14 @@ int HTMLParser::GetNextToken_()
                     "Read a character despite </SCRIPT> was read?" );
         nNextCh = GetNextChar();
         if( !IsParserWorking() )        // Don't continue if already an error occurred
-            return 0;
+            return HtmlTokenId::NONE;
         bReadNextChar = false;
     }
 
     if( bReadScript || bReadStyle || !aEndToken.isEmpty() )
     {
         nRet = GetNextRawToken();
-        if( nRet || !IsParserWorking() )
+        if( nRet != HtmlTokenId::NONE || !IsParserWorking() )
             return nRet;
     }
 
@@ -1054,27 +1054,27 @@ int HTMLParser::GetNextToken_()
                     // Search token in table:
                     sSaveToken = aToken;
                     aToken = aToken.toAsciiLowerCase();
-                    if( 0 == (nRet = GetHTMLToken( aToken )) )
+                    if( HtmlTokenId::NONE == (nRet = GetHTMLToken( aToken )) )
                         // Unknown control
-                        nRet = HTML_UNKNOWNCONTROL_ON;
+                        nRet = HtmlTokenId::UNKNOWNCONTROL_ON;
 
                     // If it's a token which can be switched off...
                     if( bOffState )
                     {
-                         if( HTML_TOKEN_ONOFF & nRet )
+                         if( nRet >= HtmlTokenId::ONOFF_START )
                          {
                             // and there is an off token, return off token instead
-                            ++nRet;
+                            nRet = (HtmlTokenId)((int)nRet + 1);
                          }
-                         else if( HTML_LINEBREAK!=nRet )
+                         else if( HtmlTokenId::LINEBREAK!=nRet )
                          {
                             // and there is no off token, return unknown token.
                             // (except for </BR>, that is treated like <BR>)
-                            nRet = HTML_UNKNOWNCONTROL_OFF;
+                            nRet = HtmlTokenId::UNKNOWNCONTROL_OFF;
                          }
                     }
 
-                    if( nRet == HTML_COMMENT )
+                    if( nRet == HtmlTokenId::COMMENT )
                     {
                         // fix: due to being case sensitive use sSaveToken as start of comment
                         //      and append a blank.
@@ -1130,12 +1130,12 @@ int HTMLParser::GetNextToken_()
                         ScanText( '>' );
 
                         // fdo#34666 fdo#36080 fdo#36390: closing "/>"?:
-                        // generate pending HTML_<TOKEN>_OFF for HTML_<TOKEN>_ON
-                        // Do not convert this to a single HTML_<TOKEN>_OFF
+                        // generate pending HtmlTokenId::<TOKEN>_OFF for HtmlTokenId::<TOKEN>_ON
+                        // Do not convert this to a single HtmlTokenId::<TOKEN>_OFF
                         // which lead to fdo#56772.
-                        if ((HTML_TOKEN_ONOFF & nRet) && aToken.endsWith("/"))
+                        if ((nRet >= HtmlTokenId::ONOFF_START) && aToken.endsWith("/"))
                         {
-                            mnPendingOffToken = nRet + 1;       // HTML_<TOKEN>_ON -> HTML_<TOKEN>_OFF
+                            mnPendingOffToken = (HtmlTokenId)((int)nRet + 1);       // HtmlTokenId::<TOKEN>_ON -> HtmlTokenId::<TOKEN>_OFF
                             aToken = aToken.replaceAt( aToken.getLength()-1, 1, "");   // remove trailing '/'
                         }
                         if( sal_Unicode(EOF) == nNextCh && rInput.IsEof() )
@@ -1148,7 +1148,7 @@ int HTMLParser::GetNextToken_()
                             ClearTxtConvContext();
 
                             aToken = "<";
-                            nRet = HTML_TEXTTOKEN;
+                            nRet = HtmlTokenId::TEXTTOKEN;
                             nNextCh = GetNextChar();
                             bNextCh = false;
                             break;
@@ -1173,7 +1173,7 @@ int HTMLParser::GetNextToken_()
                             ClearTxtConvContext();
 
                             aToken = "<";
-                            nRet = HTML_TEXTTOKEN;
+                            nRet = HtmlTokenId::TEXTTOKEN;
                             nNextCh = GetNextChar();
                             bNextCh = false;
                             break;
@@ -1184,7 +1184,7 @@ int HTMLParser::GetNextToken_()
                     }
                     else if( '%' == nNextCh )
                     {
-                        nRet = HTML_UNKNOWNCONTROL_ON;
+                        nRet = HtmlTokenId::UNKNOWNCONTROL_ON;
 
                         sal_uLong nCStreamPos = rInput.Tell();
                         sal_uLong nCLineNr = GetLineNr(), nCLinePos = GetLinePos();
@@ -1207,7 +1207,7 @@ int HTMLParser::GetNextToken_()
                             SetLinePos( nCLinePos );
                             ClearTxtConvContext();
                             aToken = "<%";
-                            nRet = HTML_TEXTTOKEN;
+                            nRet = HtmlTokenId::TEXTTOKEN;
                             break;
                         }
                         if( IsParserWorking() )
@@ -1219,7 +1219,7 @@ int HTMLParser::GetNextToken_()
                     else
                     {
                         aToken = "<";
-                        nRet = HTML_TEXTTOKEN;
+                        nRet = HtmlTokenId::TEXTTOKEN;
                         bNextCh = false;
                         break;
                     }
@@ -1230,17 +1230,17 @@ int HTMLParser::GetNextToken_()
                     bNextCh = '>' == nNextCh;
                     switch( nRet )
                     {
-                    case HTML_TEXTAREA_ON:
+                    case HtmlTokenId::TEXTAREA_ON:
                         bReadTextArea = true;
                         break;
-                    case HTML_TEXTAREA_OFF:
+                    case HtmlTokenId::TEXTAREA_OFF:
                         bReadTextArea = false;
                         break;
-                    case HTML_SCRIPT_ON:
+                    case HtmlTokenId::SCRIPT_ON:
                         if( !bReadTextArea )
                             bReadScript = true;
                         break;
-                    case HTML_SCRIPT_OFF:
+                    case HtmlTokenId::SCRIPT_OFF:
                         if( !bReadTextArea )
                         {
                             bReadScript = false;
@@ -1251,12 +1251,13 @@ int HTMLParser::GetNextToken_()
                         }
                         break;
 
-                    case HTML_STYLE_ON:
+                    case HtmlTokenId::STYLE_ON:
                         bReadStyle = true;
                         break;
-                    case HTML_STYLE_OFF:
+                    case HtmlTokenId::STYLE_OFF:
                         bReadStyle = false;
                         break;
+                    default: break;
                     }
                 }
             }
@@ -1266,7 +1267,7 @@ int HTMLParser::GetNextToken_()
             if( rInput.IsEof() )
             {
                 eState = SvParserState::Accepted;
-                nRet = nNextCh;
+                nRet = HtmlTokenId(nNextCh);
             }
             else
             {
@@ -1277,7 +1278,7 @@ int HTMLParser::GetNextToken_()
 
         case '\f':
             // form feeds are passed upwards separately
-            nRet = HTML_LINEFEEDCHAR; // !!! should be FORMFEEDCHAR
+            nRet = HtmlTokenId::LINEFEEDCHAR; // !!! should be FORMFEEDCHAR
             break;
 
         case '\n':
@@ -1291,14 +1292,14 @@ int HTMLParser::GetNextToken_()
                     bNextCh = false;
                     nNextCh = c;
                 }
-                nRet = HTML_NEWPARA;
+                nRet = HtmlTokenId::NEWPARA;
                 break;
             }
             SAL_FALLTHROUGH;
         case '\t':
             if( bReadPRE )
             {
-                nRet = HTML_TABCHAR;
+                nRet = HtmlTokenId::TABCHAR;
                 break;
             }
             SAL_FALLTHROUGH;
@@ -1324,17 +1325,17 @@ scan_text:
         if( bNextCh && SvParserState::Working == eState )
         {
             nNextCh = GetNextChar();
-            if( SvParserState::Pending == eState && nRet && HTML_TEXTTOKEN != nRet )
+            if( SvParserState::Pending == eState && nRet != HtmlTokenId::NONE && HtmlTokenId::TEXTTOKEN != nRet )
             {
                 bReadNextChar = true;
                 eState = SvParserState::Working;
             }
         }
 
-    } while( !nRet && SvParserState::Working == eState );
+    } while( nRet == HtmlTokenId::NONE && SvParserState::Working == eState );
 
     if( SvParserState::Pending == eState )
-        nRet = -1;      // s.th. invalid
+        nRet = HtmlTokenId::INVALID;      // s.th. invalid
 
     return nRet;
 }
@@ -1537,22 +1538,22 @@ const HTMLOptions& HTMLParser::GetOptions( HtmlOptionId *pNoConvertToken )
     return maOptions;
 }
 
-int HTMLParser::FilterPRE( int nToken )
+HtmlTokenId HTMLParser::FilterPRE( HtmlTokenId nToken )
 {
     switch( nToken )
     {
     // in Netscape they only have impact in not empty paragraphs
-    case HTML_PARABREAK_ON:
-        nToken = HTML_LINEBREAK;
+    case HtmlTokenId::PARABREAK_ON:
+        nToken = HtmlTokenId::LINEBREAK;
         SAL_FALLTHROUGH;
-    case HTML_LINEBREAK:
-    case HTML_NEWPARA:
+    case HtmlTokenId::LINEBREAK:
+    case HtmlTokenId::NEWPARA:
         nPre_LinePos = 0;
         if( bPre_IgnoreNewPara )
-            nToken = 0;
+            nToken = HtmlTokenId::NONE;
         break;
 
-    case HTML_TABCHAR:
+    case HtmlTokenId::TABCHAR:
         {
             sal_Int32 nSpaces = (8 - (nPre_LinePos % 8));
             DBG_ASSERT( aToken.isEmpty(), "Why is the token not empty?" );
@@ -1563,152 +1564,152 @@ int HTMLParser::FilterPRE( int nToken )
                 aToken = padToLength(aBuf, nSpaces, ' ').makeStringAndClear();
             }
             nPre_LinePos += nSpaces;
-            nToken = HTML_TEXTTOKEN;
+            nToken = HtmlTokenId::TEXTTOKEN;
         }
         break;
     // Keep those
-    case HTML_TEXTTOKEN:
+    case HtmlTokenId::TEXTTOKEN:
         nPre_LinePos += aToken.getLength();
         break;
 
-    case HTML_SELECT_ON:
-    case HTML_SELECT_OFF:
-    case HTML_BODY_ON:
-    case HTML_FORM_ON:
-    case HTML_FORM_OFF:
-    case HTML_INPUT:
-    case HTML_OPTION:
-    case HTML_TEXTAREA_ON:
-    case HTML_TEXTAREA_OFF:
-
-    case HTML_IMAGE:
-    case HTML_APPLET_ON:
-    case HTML_APPLET_OFF:
-    case HTML_PARAM:
-    case HTML_EMBED:
-
-    case HTML_HEAD1_ON:
-    case HTML_HEAD1_OFF:
-    case HTML_HEAD2_ON:
-    case HTML_HEAD2_OFF:
-    case HTML_HEAD3_ON:
-    case HTML_HEAD3_OFF:
-    case HTML_HEAD4_ON:
-    case HTML_HEAD4_OFF:
-    case HTML_HEAD5_ON:
-    case HTML_HEAD5_OFF:
-    case HTML_HEAD6_ON:
-    case HTML_HEAD6_OFF:
-    case HTML_BLOCKQUOTE_ON:
-    case HTML_BLOCKQUOTE_OFF:
-    case HTML_ADDRESS_ON:
-    case HTML_ADDRESS_OFF:
-    case HTML_HORZRULE:
-
-    case HTML_CENTER_ON:
-    case HTML_CENTER_OFF:
-    case HTML_DIVISION_ON:
-    case HTML_DIVISION_OFF:
-
-    case HTML_SCRIPT_ON:
-    case HTML_SCRIPT_OFF:
-    case HTML_RAWDATA:
-
-    case HTML_TABLE_ON:
-    case HTML_TABLE_OFF:
-    case HTML_CAPTION_ON:
-    case HTML_CAPTION_OFF:
-    case HTML_COLGROUP_ON:
-    case HTML_COLGROUP_OFF:
-    case HTML_COL_ON:
-    case HTML_COL_OFF:
-    case HTML_THEAD_ON:
-    case HTML_THEAD_OFF:
-    case HTML_TFOOT_ON:
-    case HTML_TFOOT_OFF:
-    case HTML_TBODY_ON:
-    case HTML_TBODY_OFF:
-    case HTML_TABLEROW_ON:
-    case HTML_TABLEROW_OFF:
-    case HTML_TABLEDATA_ON:
-    case HTML_TABLEDATA_OFF:
-    case HTML_TABLEHEADER_ON:
-    case HTML_TABLEHEADER_OFF:
-
-    case HTML_ANCHOR_ON:
-    case HTML_ANCHOR_OFF:
-    case HTML_BOLD_ON:
-    case HTML_BOLD_OFF:
-    case HTML_ITALIC_ON:
-    case HTML_ITALIC_OFF:
-    case HTML_STRIKE_ON:
-    case HTML_STRIKE_OFF:
-    case HTML_STRIKETHROUGH_ON:
-    case HTML_STRIKETHROUGH_OFF:
-    case HTML_UNDERLINE_ON:
-    case HTML_UNDERLINE_OFF:
-    case HTML_BASEFONT_ON:
-    case HTML_BASEFONT_OFF:
-    case HTML_FONT_ON:
-    case HTML_FONT_OFF:
-    case HTML_BLINK_ON:
-    case HTML_BLINK_OFF:
-    case HTML_SPAN_ON:
-    case HTML_SPAN_OFF:
-    case HTML_SUBSCRIPT_ON:
-    case HTML_SUBSCRIPT_OFF:
-    case HTML_SUPERSCRIPT_ON:
-    case HTML_SUPERSCRIPT_OFF:
-    case HTML_BIGPRINT_ON:
-    case HTML_BIGPRINT_OFF:
-    case HTML_SMALLPRINT_OFF:
-    case HTML_SMALLPRINT_ON:
-
-    case HTML_EMPHASIS_ON:
-    case HTML_EMPHASIS_OFF:
-    case HTML_CITIATION_ON:
-    case HTML_CITIATION_OFF:
-    case HTML_STRONG_ON:
-    case HTML_STRONG_OFF:
-    case HTML_CODE_ON:
-    case HTML_CODE_OFF:
-    case HTML_SAMPLE_ON:
-    case HTML_SAMPLE_OFF:
-    case HTML_KEYBOARD_ON:
-    case HTML_KEYBOARD_OFF:
-    case HTML_VARIABLE_ON:
-    case HTML_VARIABLE_OFF:
-    case HTML_DEFINSTANCE_ON:
-    case HTML_DEFINSTANCE_OFF:
-    case HTML_SHORTQUOTE_ON:
-    case HTML_SHORTQUOTE_OFF:
-    case HTML_LANGUAGE_ON:
-    case HTML_LANGUAGE_OFF:
-    case HTML_AUTHOR_ON:
-    case HTML_AUTHOR_OFF:
-    case HTML_PERSON_ON:
-    case HTML_PERSON_OFF:
-    case HTML_ACRONYM_ON:
-    case HTML_ACRONYM_OFF:
-    case HTML_ABBREVIATION_ON:
-    case HTML_ABBREVIATION_OFF:
-    case HTML_INSERTEDTEXT_ON:
-    case HTML_INSERTEDTEXT_OFF:
-    case HTML_DELETEDTEXT_ON:
-    case HTML_DELETEDTEXT_OFF:
-    case HTML_TELETYPE_ON:
-    case HTML_TELETYPE_OFF:
+    case HtmlTokenId::SELECT_ON:
+    case HtmlTokenId::SELECT_OFF:
+    case HtmlTokenId::BODY_ON:
+    case HtmlTokenId::FORM_ON:
+    case HtmlTokenId::FORM_OFF:
+    case HtmlTokenId::INPUT:
+    case HtmlTokenId::OPTION:
+    case HtmlTokenId::TEXTAREA_ON:
+    case HtmlTokenId::TEXTAREA_OFF:
+
+    case HtmlTokenId::IMAGE:
+    case HtmlTokenId::APPLET_ON:
+    case HtmlTokenId::APPLET_OFF:
+    case HtmlTokenId::PARAM:
+    case HtmlTokenId::EMBED:
+
+    case HtmlTokenId::HEAD1_ON:
+    case HtmlTokenId::HEAD1_OFF:
+    case HtmlTokenId::HEAD2_ON:
+    case HtmlTokenId::HEAD2_OFF:
+    case HtmlTokenId::HEAD3_ON:
+    case HtmlTokenId::HEAD3_OFF:
+    case HtmlTokenId::HEAD4_ON:
+    case HtmlTokenId::HEAD4_OFF:
+    case HtmlTokenId::HEAD5_ON:
+    case HtmlTokenId::HEAD5_OFF:
+    case HtmlTokenId::HEAD6_ON:
+    case HtmlTokenId::HEAD6_OFF:
+    case HtmlTokenId::BLOCKQUOTE_ON:
+    case HtmlTokenId::BLOCKQUOTE_OFF:
+    case HtmlTokenId::ADDRESS_ON:
+    case HtmlTokenId::ADDRESS_OFF:
+    case HtmlTokenId::HORZRULE:
+
+    case HtmlTokenId::CENTER_ON:
+    case HtmlTokenId::CENTER_OFF:
+    case HtmlTokenId::DIVISION_ON:
+    case HtmlTokenId::DIVISION_OFF:
+
+    case HtmlTokenId::SCRIPT_ON:
+    case HtmlTokenId::SCRIPT_OFF:
+    case HtmlTokenId::RAWDATA:
+
+    case HtmlTokenId::TABLE_ON:
+    case HtmlTokenId::TABLE_OFF:
+    case HtmlTokenId::CAPTION_ON:
+    case HtmlTokenId::CAPTION_OFF:
+    case HtmlTokenId::COLGROUP_ON:
+    case HtmlTokenId::COLGROUP_OFF:
+    case HtmlTokenId::COL_ON:
+    case HtmlTokenId::COL_OFF:
+    case HtmlTokenId::THEAD_ON:
+    case HtmlTokenId::THEAD_OFF:
+    case HtmlTokenId::TFOOT_ON:
+    case HtmlTokenId::TFOOT_OFF:
+    case HtmlTokenId::TBODY_ON:
+    case HtmlTokenId::TBODY_OFF:
+    case HtmlTokenId::TABLEROW_ON:
+    case HtmlTokenId::TABLEROW_OFF:
+    case HtmlTokenId::TABLEDATA_ON:
+    case HtmlTokenId::TABLEDATA_OFF:
+    case HtmlTokenId::TABLEHEADER_ON:
+    case HtmlTokenId::TABLEHEADER_OFF:
+
+    case HtmlTokenId::ANCHOR_ON:
+    case HtmlTokenId::ANCHOR_OFF:
+    case HtmlTokenId::BOLD_ON:
+    case HtmlTokenId::BOLD_OFF:
+    case HtmlTokenId::ITALIC_ON:
+    case HtmlTokenId::ITALIC_OFF:
+    case HtmlTokenId::STRIKE_ON:
+    case HtmlTokenId::STRIKE_OFF:
+    case HtmlTokenId::STRIKETHROUGH_ON:
+    case HtmlTokenId::STRIKETHROUGH_OFF:
+    case HtmlTokenId::UNDERLINE_ON:
+    case HtmlTokenId::UNDERLINE_OFF:
+    case HtmlTokenId::BASEFONT_ON:
+    case HtmlTokenId::BASEFONT_OFF:
+    case HtmlTokenId::FONT_ON:
+    case HtmlTokenId::FONT_OFF:
+    case HtmlTokenId::BLINK_ON:
+    case HtmlTokenId::BLINK_OFF:
+    case HtmlTokenId::SPAN_ON:
+    case HtmlTokenId::SPAN_OFF:
+    case HtmlTokenId::SUBSCRIPT_ON:
+    case HtmlTokenId::SUBSCRIPT_OFF:
+    case HtmlTokenId::SUPERSCRIPT_ON:
+    case HtmlTokenId::SUPERSCRIPT_OFF:
+    case HtmlTokenId::BIGPRINT_ON:
+    case HtmlTokenId::BIGPRINT_OFF:
+    case HtmlTokenId::SMALLPRINT_OFF:
+    case HtmlTokenId::SMALLPRINT_ON:
+
+    case HtmlTokenId::EMPHASIS_ON:
+    case HtmlTokenId::EMPHASIS_OFF:
+    case HtmlTokenId::CITIATION_ON:
+    case HtmlTokenId::CITIATION_OFF:
+    case HtmlTokenId::STRONG_ON:
+    case HtmlTokenId::STRONG_OFF:
+    case HtmlTokenId::CODE_ON:
+    case HtmlTokenId::CODE_OFF:
+    case HtmlTokenId::SAMPLE_ON:
+    case HtmlTokenId::SAMPLE_OFF:
+    case HtmlTokenId::KEYBOARD_ON:
+    case HtmlTokenId::KEYBOARD_OFF:
+    case HtmlTokenId::VARIABLE_ON:
+    case HtmlTokenId::VARIABLE_OFF:
+    case HtmlTokenId::DEFINSTANCE_ON:
+    case HtmlTokenId::DEFINSTANCE_OFF:
+    case HtmlTokenId::SHORTQUOTE_ON:
+    case HtmlTokenId::SHORTQUOTE_OFF:
+    case HtmlTokenId::LANGUAGE_ON:
+    case HtmlTokenId::LANGUAGE_OFF:
+    case HtmlTokenId::AUTHOR_ON:
+    case HtmlTokenId::AUTHOR_OFF:
+    case HtmlTokenId::PERSON_ON:
+    case HtmlTokenId::PERSON_OFF:
+    case HtmlTokenId::ACRONYM_ON:
+    case HtmlTokenId::ACRONYM_OFF:
+    case HtmlTokenId::ABBREVIATION_ON:
+    case HtmlTokenId::ABBREVIATION_OFF:
+    case HtmlTokenId::INSERTEDTEXT_ON:
+    case HtmlTokenId::INSERTEDTEXT_OFF:
+    case HtmlTokenId::DELETEDTEXT_ON:
+    case HtmlTokenId::DELETEDTEXT_OFF:
+    case HtmlTokenId::TELETYPE_ON:
+    case HtmlTokenId::TELETYPE_OFF:
 
         break;
 
     // The remainder is treated as an unknown token.
     default:
-        if( nToken )
+        if( nToken != HtmlTokenId::NONE )
         {
             nToken =
-                ( ((HTML_TOKEN_ONOFF & nToken) && (1 & nToken))
-                    ? HTML_UNKNOWNCONTROL_OFF
-                    : HTML_UNKNOWNCONTROL_ON );
+                ( ((nToken >= HtmlTokenId::ONOFF_START) && isOffToken(nToken))
+                    ? HtmlTokenId::UNKNOWNCONTROL_OFF
+                    : HtmlTokenId::UNKNOWNCONTROL_ON );
         }
         break;
     }
@@ -1718,23 +1719,23 @@ int HTMLParser::FilterPRE( int nToken )
     return nToken;
 }
 
-int HTMLParser::FilterXMP( int nToken )
+HtmlTokenId HTMLParser::FilterXMP( HtmlTokenId nToken )
 {
     switch( nToken )
     {
-    case HTML_NEWPARA:
+    case HtmlTokenId::NEWPARA:
         if( bPre_IgnoreNewPara )
-            nToken = 0;
+            nToken = HtmlTokenId::NONE;
         SAL_FALLTHROUGH;
-    case HTML_TEXTTOKEN:
-    case HTML_NONBREAKSPACE:
-    case HTML_SOFTHYPH:
+    case HtmlTokenId::TEXTTOKEN:
+    case HtmlTokenId::NONBREAKSPACE:
+    case HtmlTokenId::SOFTHYPH:
         break;              // kept
 
     default:
-        if( nToken )
+        if( nToken != HtmlTokenId::NONE )
         {
-            if( (HTML_TOKEN_ONOFF & nToken) && (1 & nToken) )
+            if( (nToken >= HtmlTokenId::ONOFF_START) && isOffToken(nToken) )
             {
                 sSaveToken = "</" + sSaveToken;
             }
@@ -1749,7 +1750,7 @@ int HTMLParser::FilterXMP( int nToken )
             else
                 aToken = sSaveToken;
             aToken += ">";
-            nToken = HTML_TEXTTOKEN;
+            nToken = HtmlTokenId::TEXTTOKEN;
         }
         break;
     }
@@ -1759,26 +1760,26 @@ int HTMLParser::FilterXMP( int nToken )
     return nToken;
 }
 
-int HTMLParser::FilterListing( int nToken )
+HtmlTokenId HTMLParser::FilterListing( HtmlTokenId nToken )
 {
     switch( nToken )
     {
-    case HTML_NEWPARA:
+    case HtmlTokenId::NEWPARA:
         if( bPre_IgnoreNewPara )
-            nToken = 0;
+            nToken = HtmlTokenId::NONE;
         SAL_FALLTHROUGH;
-    case HTML_TEXTTOKEN:
-    case HTML_NONBREAKSPACE:
-    case HTML_SOFTHYPH:
+    case HtmlTokenId::TEXTTOKEN:
+    case HtmlTokenId::NONBREAKSPACE:
+    case HtmlTokenId::SOFTHYPH:
         break;      // kept
 
     default:
-        if( nToken )
+        if( nToken != HtmlTokenId::NONE )
         {
             nToken =
-                ( ((HTML_TOKEN_ONOFF & nToken) && (1 & nToken))
-                    ? HTML_UNKNOWNCONTROL_OFF
-                    : HTML_UNKNOWNCONTROL_ON );
+                ( ((nToken >= HtmlTokenId::ONOFF_START) && isOffToken(nToken))
+                    ? HtmlTokenId::UNKNOWNCONTROL_OFF
+                    : HtmlTokenId::UNKNOWNCONTROL_ON );
         }
         break;
     }
diff --git a/svtools/source/svrtf/parrtf.cxx b/svtools/source/svrtf/parrtf.cxx
index 625288c1277e..17921cdaf718 100644
--- a/svtools/source/svrtf/parrtf.cxx
+++ b/svtools/source/svrtf/parrtf.cxx
@@ -36,7 +36,7 @@ const int MAX_TOKEN_LEN = 128;
 #define RTF_ISALPHA( c ) rtl::isAsciiAlpha(c)
 
 SvRTFParser::SvRTFParser( SvStream& rIn, sal_uInt8 nStackSize )
-    : SvParser( rIn, nStackSize )
+    : SvParser<int>( rIn, nStackSize )
     , nOpenBrakets(0)
     , eCodeSet(RTL_TEXTENCODING_MS_1252)
     , nUCharOverread(1)
diff --git a/svtools/source/svrtf/svparser.cxx b/svtools/source/svrtf/svparser.cxx
index c2de091f1f0d..789464ddbdf5 100644
--- a/svtools/source/svrtf/svparser.cxx
+++ b/svtools/source/svrtf/svparser.cxx
@@ -28,6 +28,7 @@
 #include <climits>
 
 // structure to store the actuel data
+template<typename T>
 struct SvParser_Impl
 {
     OUString        aToken;             // gescanntes Token
@@ -35,10 +36,10 @@ struct SvParser_Impl
     sal_uLong       nlLineNr;           // actual line number
     sal_uLong       nlLinePos;          // actual column number
     long            nTokenValue;        // extra value (RTF)
-    bool        bTokenHasValue;     // indicates whether nTokenValue is valid
-    int             nToken;             // actual Token
+    bool            bTokenHasValue;     // indicates whether nTokenValue is valid
+    T               nToken;             // actual Token
     sal_uInt32      nNextCh;            // actual character
-    int             nSaveToken;         // the token from Continue
+    T               nSaveToken;         // the token from Continue
 
     rtl_TextToUnicodeConverter hConv;
     rtl_TextToUnicodeContext   hContext;
@@ -49,9 +50,9 @@ struct SvParser_Impl
         , nlLinePos(0)
         , nTokenValue(0)
         , bTokenHasValue(false)
-        , nToken(0)
+        , nToken(static_cast<T>(0))
         , nNextCh(0)
-        , nSaveToken(0)
+        , nSaveToken(static_cast<T>(0))
         , hConv( nullptr )
         , hContext( reinterpret_cast<rtl_TextToUnicodeContext>(1) )
     {
@@ -60,8 +61,17 @@ struct SvParser_Impl
 };
 
 
-// Construktor
-SvParser::SvParser( SvStream& rIn, sal_uInt8 nStackSize )
+template<typename T>
+SvParser<T>::TokenStackType::TokenStackType()
+  : nTokenValue(0)
+    , bTokenHasValue(false)
+    , nTokenId(static_cast<T>(0))
+{
+}
+
+// Constructor
+template<typename T>
+SvParser<T>::SvParser( SvStream& rIn, sal_uInt8 nStackSize )
     : rInput( rIn )
     , nlLineNr( 1 )
     , nlLinePos( 1 )
@@ -85,7 +95,8 @@ SvParser::SvParser( SvStream& rIn, sal_uInt8 nStackSize )
     pTokenStackPos = pTokenStack;
 }
 
-SvParser::~SvParser()
+template<typename T>
+SvParser<T>::~SvParser()
 {
     if( pImplData && pImplData->hConv )
     {
@@ -97,13 +108,32 @@ SvParser::~SvParser()
     delete [] pTokenStack;
 }
 
-void SvParser::ClearTxtConvContext()
+template<typename T> SvParserState SvParser<T>::GetStatus() const { return eState; }
+template<typename T> sal_uLong  SvParser<T>::GetLineNr() const       { return nlLineNr; }
+template<typename T> sal_uLong  SvParser<T>::GetLinePos() const      { return nlLinePos; }
+template<typename T> void       SvParser<T>::IncLineNr()             { ++nlLineNr; }
+template<typename T> sal_uLong  SvParser<T>::IncLinePos()            { return ++nlLinePos; }
+template<typename T> void       SvParser<T>::SetLineNr( sal_uLong nlNum ) { nlLineNr = nlNum; }
+template<typename T> void       SvParser<T>::SetLinePos( sal_uLong nlPos ) {   nlLinePos = nlPos; }
+template<typename T> bool       SvParser<T>::IsParserWorking() const { return SvParserState::Working == eState; }
+template<typename T> rtl_TextEncoding SvParser<T>::GetSrcEncoding() const { return eSrcEnc; }
+template<typename T> void       SvParser<T>::SetSwitchToUCS2( bool bSet ) { bSwitchToUCS2 = bSet; }
+template<typename T> bool       SvParser<T>::IsSwitchToUCS2() const { return bSwitchToUCS2; }
+template<typename T> sal_uInt16 SvParser<T>::GetCharSize() const { return (RTL_TEXTENCODING_UCS2 == eSrcEnc) ? 2 : 1; }
+template<typename T> Link<LinkParamNone*,void> SvParser<T>::GetAsynchCallLink() const
+{
+    return LINK( const_cast<SvParser*>(this), SvParser, NewDataRead );
+}
+
+template<typename T>
+void SvParser<T>::ClearTxtConvContext()
 {
     if( pImplData && pImplData->hConv )
         rtl_resetTextToUnicodeContext( pImplData->hConv, pImplData->hContext );
 }
 
-void SvParser::SetSrcEncoding( rtl_TextEncoding eEnc )
+template<typename T>
+void SvParser<T>::SetSrcEncoding( rtl_TextEncoding eEnc )
 {
     if( eEnc != eSrcEnc )
     {
@@ -121,7 +151,7 @@ void SvParser::SetSrcEncoding( rtl_TextEncoding eEnc )
         {
             eSrcEnc = eEnc;
             if( !pImplData )
-                pImplData.reset(new SvParser_Impl);
+                pImplData.reset(new SvParser_Impl<T>);
             pImplData->hConv = rtl_createTextToUnicodeConverter( eSrcEnc );
             DBG_ASSERT( pImplData->hConv,
                         "SvParser::SetSrcEncoding: no converter for source encoding" );
@@ -140,13 +170,15 @@ void SvParser::SetSrcEncoding( rtl_TextEncoding eEnc )
     }
 }
 
-void SvParser::RereadLookahead()
+template<typename T>
+void SvParser<T>::RereadLookahead()
 {
     rInput.Seek(nNextChPos);
     nNextCh = GetNextChar();
 }
 
-sal_uInt32 SvParser::GetNextChar()
+template<typename T>
+sal_uInt32 SvParser<T>::GetNextChar()
 {
     sal_uInt32 c = 0U;
 
@@ -416,9 +448,10 @@ sal_uInt32 SvParser::GetNextChar()
     return c;
 }
 
-int SvParser::GetNextToken()
+template<typename T>
+T SvParser<T>::GetNextToken()
 {
-    int nRet = 0;
+    T nRet = static_cast<T>(0);
 
     if( !nTokenStackPos )
     {
@@ -458,7 +491,8 @@ int SvParser::GetNextToken()
     return nRet;
 }
 
-int SvParser::SkipToken( short nCnt )       // "skip" n Tokens backward
+template<typename T>
+T SvParser<T>::SkipToken( short nCnt )       // "skip" n Tokens backward
 {
     pTokenStackPos = GetStackPtr( nCnt );
     short nTmp = nTokenStackPos - nCnt;
@@ -476,7 +510,8 @@ int SvParser::SkipToken( short nCnt )       // "skip" n Tokens backward
     return pTokenStackPos->nTokenId;
 }
 
-SvParser::TokenStackType* SvParser::GetStackPtr( short nCnt )
+template<typename T>
+typename SvParser<T>::TokenStackType* SvParser<T>::GetStackPtr( short nCnt )
 {
     sal_uInt8 nAktPos = sal_uInt8(pTokenStackPos - pTokenStack );
     if( nCnt > 0 )
@@ -503,25 +538,28 @@ SvParser::TokenStackType* SvParser::GetStackPtr( short nCnt )
 }
 
 // is called for each token which is recognised by CallParser
-void SvParser::NextToken( int )
+template<typename T>
+void SvParser<T>::NextToken( T )
 {
 }
 
 
 // to read asynchronous from SvStream
 
-int SvParser::GetSaveToken() const
+template<typename T>
+T SvParser<T>::GetSaveToken() const
 {
-    return pImplData ? pImplData->nSaveToken : 0;
+    return pImplData ? pImplData->nSaveToken : static_cast<T>(0);
 }
 
-void SvParser::SaveState( int nToken )
+template<typename T>
+void SvParser<T>::SaveState( T nToken )
 {
     // save actual status
     if( !pImplData )
     {
-        pImplData.reset(new SvParser_Impl);
-        pImplData->nSaveToken = 0;
+        pImplData.reset(new SvParser_Impl<T>);
+        pImplData->nSaveToken = static_cast<T>(0);
     }
 
     pImplData->nFilePos = rInput.Tell();
@@ -535,7 +573,8 @@ void SvParser::SaveState( int nToken )
     pImplData->nNextCh = nNextCh;
 }
 
-void SvParser::RestoreState()
+template<typename T>
+void SvParser<T>::RestoreState()
 {
     // restore old status
     if( pImplData )
@@ -555,13 +594,14 @@ void SvParser::RestoreState()
     }
 }
 
-void SvParser::Continue( int )
+template<typename T>
+void SvParser<T>::Continue( T )
 {
 }
 
-void SvParser::BuildWhichTable( std::vector<sal_uInt16> &rWhichMap,
-                              sal_uInt16 *pWhichIds,
-                              sal_uInt16 nWhichIds )
+void BuildWhichTable( std::vector<sal_uInt16> &rWhichMap,
+                      sal_uInt16 *pWhichIds,
+                      sal_uInt16 nWhichIds )
 {
     sal_uInt16 aNewRange[2];
 
@@ -615,7 +655,15 @@ void SvParser::BuildWhichTable( std::vector<sal_uInt16> &rWhichMap,
 }
 
 
-IMPL_LINK_NOARG( SvParser, NewDataRead, LinkParamNone*, void )
+// expanded out version of
+//   IMPL_LINK_NOARG( SvParser, NewDataRead, LinkParamNone*, void )
+// since it can't cope with template methods
+template<typename T>
+void SvParser<T>::LinkStubNewDataRead(void * instance, LinkParamNone* data) {
+    return static_cast<SvParser<T> *>(instance)->NewDataRead(data);
+}
+template<typename T>
+void SvParser<T>::NewDataRead(SAL_UNUSED_PARAMETER LinkParamNone*)
 {
     switch( eState )
     {
@@ -642,6 +690,9 @@ IMPL_LINK_NOARG( SvParser, NewDataRead, LinkParamNone*, void )
     }
 }
 
+template class SVT_DLLPUBLIC SvParser<int>;
+template class SVT_DLLPUBLIC SvParser<HtmlTokenId>;
+
 /*========================================================================
  *
  * SvKeyValueIterator.