convert SC_COMPILER to scoped enum

Change-Id: Ib8fdce056847b2b2514f61da18c106bb3e78631c
Reviewed-on: https://gerrit.libreoffice.org/25079
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Noel Grandin <noelgrandin@gmail.com>

4 files changed, 160 insertions, 153 deletions

diff --git a/sc/inc/compiler.hxx b/sc/inc/compiler.hxx
index abc41e5a4407..5f89b97044c7 100644
--- a/sc/inc/compiler.hxx
+++ b/sc/inc/compiler.hxx
@@ -35,38 +35,45 @@
 #include <vector>
 
 #include <formula/FormulaCompiler.hxx>
+#include <o3tl/typed_flags_set.hxx>
 
 // constants and data types also for external modules (ScInterpreter et al)
 
 #define MAXSTRLEN    1024   /* maximum length of input string of one symbol */
 
 // flag values of CharTable
-#define SC_COMPILER_C_ILLEGAL         0x00000000
-#define SC_COMPILER_C_CHAR            0x00000001
-#define SC_COMPILER_C_CHAR_BOOL       0x00000002
-#define SC_COMPILER_C_CHAR_WORD       0x00000004
-#define SC_COMPILER_C_CHAR_VALUE      0x00000008
-#define SC_COMPILER_C_CHAR_STRING     0x00000010
-#define SC_COMPILER_C_CHAR_DONTCARE   0x00000020
-#define SC_COMPILER_C_BOOL            0x00000040
-#define SC_COMPILER_C_WORD            0x00000080
-#define SC_COMPILER_C_WORD_SEP        0x00000100
-#define SC_COMPILER_C_VALUE           0x00000200
-#define SC_COMPILER_C_VALUE_SEP       0x00000400
-#define SC_COMPILER_C_VALUE_EXP       0x00000800
-#define SC_COMPILER_C_VALUE_SIGN      0x00001000
-#define SC_COMPILER_C_VALUE_VALUE     0x00002000
-#define SC_COMPILER_C_STRING_SEP      0x00004000
-#define SC_COMPILER_C_NAME_SEP        0x00008000  // there can be only one! '\''
-#define SC_COMPILER_C_CHAR_IDENT      0x00010000  // identifier (built-in function) or reference start
-#define SC_COMPILER_C_IDENT           0x00020000  // identifier or reference continuation
-#define SC_COMPILER_C_ODF_LBRACKET    0x00040000  // ODF '[' reference bracket
-#define SC_COMPILER_C_ODF_RBRACKET    0x00080000  // ODF ']' reference bracket
-#define SC_COMPILER_C_ODF_LABEL_OP    0x00100000  // ODF '!!' automatic intersection of labels
-#define SC_COMPILER_C_ODF_NAME_MARKER 0x00200000  // ODF '$$' marker that starts a defined (range) name
-#define SC_COMPILER_C_CHAR_NAME       0x00400000  // start character of a defined name
-#define SC_COMPILER_C_NAME            0x00800000  // continuation character of a defined name
-#define SC_COMPILER_C_CHAR_ERRCONST   0x01000000  // start character of an error constant ('#')
+enum class ScCharFlags : sal_uInt32 {
+    NONE            = 0x00000000,
+    Illegal         = 0x00000000,
+    Char            = 0x00000001,
+    CharBool        = 0x00000002,
+    CharWord        = 0x00000004,
+    CharValue       = 0x00000008,
+    CharString      = 0x00000010,
+    CharDontCare    = 0x00000020,
+    Bool            = 0x00000040,
+    Word            = 0x00000080,
+    WordSep         = 0x00000100,
+    Value           = 0x00000200,
+    ValueSep        = 0x00000400,
+    ValueExp        = 0x00000800,
+    ValueSign       = 0x00001000,
+    ValueValue      = 0x00002000,
+    StringSep       = 0x00004000,
+    NameSep         = 0x00008000,  // there can be only one! '\''
+    CharIdent       = 0x00010000,  // identifier (built-in function) or reference start
+    Ident           = 0x00020000,  // identifier or reference continuation
+    OdfLBracket     = 0x00040000,  // ODF '[' reference bracket
+    OdfRBracket     = 0x00080000,  // ODF ']' reference bracket
+    OdfLabelOp      = 0x00100000,  // ODF '!!' automatic intersection of labels
+    OdfNameMarker   = 0x00200000,  // ODF '$$' marker that starts a defined (range) name
+    CharName        = 0x00400000,  // start character of a defined name
+    Name            = 0x00800000,  // continuation character of a defined name
+    CharErrConst    = 0x01000000,  // start character of an error constant ('#')
+};
+namespace o3tl {
+    template<> struct typed_flags<ScCharFlags> : is_typed_flags<ScCharFlags, 0x01ffffff> {};
+}
 
 #define SC_COMPILER_FILE_TAB_SEP      '#'         // 'Doc'#Tab
 
@@ -245,10 +252,10 @@ public:
         };
         virtual sal_Unicode getSpecialSymbol( SpecialSymbolType eSymType ) const = 0;
 
-        virtual sal_uLong getCharTableFlags( sal_Unicode c, sal_Unicode cLast ) const = 0;
+        virtual ScCharFlags getCharTableFlags( sal_Unicode c, sal_Unicode cLast ) const = 0;
 
     protected:
-        const sal_uLong* mpCharTable;
+        const ScCharFlags* mpCharTable;
     };
     friend struct Convention;
 
@@ -441,7 +448,7 @@ public:
         bits) for all known address conventions. If more than one bit is given
         in nFlags, all bits must match. */
     static bool IsCharFlagAllConventions(
-        OUString const & rStr, sal_Int32 nPos, sal_uLong nFlags );
+        OUString const & rStr, sal_Int32 nPos, ScCharFlags nFlags );
 
 private:
     // FormulaCompiler
@@ -468,8 +475,8 @@ private:
     virtual bool IsForceArrayParameter( const formula::FormulaToken* pToken, sal_uInt16 nParam ) const override;
 
     /// Access the CharTable flags
-    inline sal_uLong GetCharTableFlags( sal_Unicode c, sal_Unicode cLast )
-        { return c < 128 ? pConv->getCharTableFlags(c, cLast) : 0; }
+    inline ScCharFlags GetCharTableFlags( sal_Unicode c, sal_Unicode cLast )
+        { return c < 128 ? pConv->getCharTableFlags(c, cLast) : ScCharFlags::NONE; }
 };
 
 #endif
diff --git a/sc/source/core/tool/compiler.cxx b/sc/source/core/tool/compiler.cxx
index cc2ddfbc2dbd..eb00c651773f 100644
--- a/sc/source/core/tool/compiler.cxx
+++ b/sc/source/core/tool/compiler.cxx
@@ -305,87 +305,87 @@ ScCompiler::Convention::Convention( FormulaGrammar::AddressConvention eConv )
     meConv( eConv )
 {
     int i;
-    sal_uLong *t= new sal_uLong [128];
+    ScCharFlags *t= new ScCharFlags [128];
 
     ScCompiler::pConventions[ meConv ] = this;
     mpCharTable = t;
 
     for (i = 0; i < 128; i++)
-        t[i] = SC_COMPILER_C_ILLEGAL;
+        t[i] = ScCharFlags::Illegal;
 
 // tdf#56036: Allow tabs/newlines in imported formulas (for now simply treat them as (and convert to) space)
 // TODO: tdf#76310: allow saving newlines as is (as per OpenFormula specification v.1.2, clause 5.14 "Whitespace")
 // This is compliant with the OASIS decision (see https://issues.oasis-open.org/browse/OFFICE-701)
 // Also, this would enable correct roundtrip from/to OOXML without losing tabs/newlines
 // This requires saving actual space characters in ocSpaces token, using them in UI and saving
-/* tab */   t[ 9] = SC_COMPILER_C_CHAR_DONTCARE | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* lf  */   t[10] = SC_COMPILER_C_CHAR_DONTCARE | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* cr  */   t[13] = SC_COMPILER_C_CHAR_DONTCARE | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
+/* tab */   t[ 9] = ScCharFlags::CharDontCare | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* lf  */   t[10] = ScCharFlags::CharDontCare | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* cr  */   t[13] = ScCharFlags::CharDontCare | ScCharFlags::WordSep | ScCharFlags::ValueSep;
 
-/*   */     t[32] = SC_COMPILER_C_CHAR_DONTCARE | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* ! */     t[33] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
+/*   */     t[32] = ScCharFlags::CharDontCare | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* ! */     t[33] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
             if (FormulaGrammar::CONV_ODF == meConv)
-/* ! */         t[33] |= SC_COMPILER_C_ODF_LABEL_OP;
-/* " */     t[34] = SC_COMPILER_C_CHAR_STRING | SC_COMPILER_C_STRING_SEP;
-/* # */     t[35] = SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_CHAR_ERRCONST;
-/* $ */     t[36] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT;
+/* ! */         t[33] |= ScCharFlags::OdfLabelOp;
+/* " */     t[34] = ScCharFlags::CharString | ScCharFlags::StringSep;
+/* # */     t[35] = ScCharFlags::WordSep | ScCharFlags::CharErrConst;
+/* $ */     t[36] = ScCharFlags::CharWord | ScCharFlags::Word | ScCharFlags::CharIdent | ScCharFlags::Ident;
             if (FormulaGrammar::CONV_ODF == meConv)
-/* $ */         t[36] |= SC_COMPILER_C_ODF_NAME_MARKER;
-/* % */     t[37] = SC_COMPILER_C_VALUE;
-/* & */     t[38] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* ' */     t[39] = SC_COMPILER_C_NAME_SEP;
-/* ( */     t[40] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* ) */     t[41] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* * */     t[42] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* + */     t[43] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_EXP | SC_COMPILER_C_VALUE_SIGN;
-/* , */     t[44] = SC_COMPILER_C_CHAR_VALUE | SC_COMPILER_C_VALUE;
-/* - */     t[45] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_EXP | SC_COMPILER_C_VALUE_SIGN;
-/* . */     t[46] = SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_VALUE | SC_COMPILER_C_VALUE | SC_COMPILER_C_IDENT | SC_COMPILER_C_NAME;
-/* / */     t[47] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
+/* $ */         t[36] |= ScCharFlags::OdfNameMarker;
+/* % */     t[37] = ScCharFlags::Value;
+/* & */     t[38] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* ' */     t[39] = ScCharFlags::NameSep;
+/* ( */     t[40] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* ) */     t[41] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* * */     t[42] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* + */     t[43] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueExp | ScCharFlags::ValueSign;
+/* , */     t[44] = ScCharFlags::CharValue | ScCharFlags::Value;
+/* - */     t[45] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueExp | ScCharFlags::ValueSign;
+/* . */     t[46] = ScCharFlags::Word | ScCharFlags::CharValue | ScCharFlags::Value | ScCharFlags::Ident | ScCharFlags::Name;
+/* / */     t[47] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
 
             for (i = 48; i < 58; i++)
-/* 0-9 */       t[i] = SC_COMPILER_C_CHAR_VALUE | SC_COMPILER_C_WORD | SC_COMPILER_C_VALUE | SC_COMPILER_C_VALUE_EXP | SC_COMPILER_C_VALUE_VALUE | SC_COMPILER_C_IDENT | SC_COMPILER_C_NAME;
-
-/* : */     t[58] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD;
-/* ; */     t[59] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* < */     t[60] = SC_COMPILER_C_CHAR_BOOL | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* = */     t[61] = SC_COMPILER_C_CHAR | SC_COMPILER_C_BOOL | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* > */     t[62] = SC_COMPILER_C_CHAR_BOOL | SC_COMPILER_C_BOOL | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* ? */     t[63] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_NAME;
+/* 0-9 */       t[i] = ScCharFlags::CharValue | ScCharFlags::Word | ScCharFlags::Value | ScCharFlags::ValueExp | ScCharFlags::ValueValue | ScCharFlags::Ident | ScCharFlags::Name;
+
+/* : */     t[58] = ScCharFlags::Char | ScCharFlags::Word;
+/* ; */     t[59] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* < */     t[60] = ScCharFlags::CharBool | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* = */     t[61] = ScCharFlags::Char | ScCharFlags::Bool | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* > */     t[62] = ScCharFlags::CharBool | ScCharFlags::Bool | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* ? */     t[63] = ScCharFlags::CharWord | ScCharFlags::Word | ScCharFlags::Name;
 /* @ */     // FREE
 
     for (i = 65; i < 91; i++)
-/* A-Z */   t[i] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT | SC_COMPILER_C_CHAR_NAME | SC_COMPILER_C_NAME;
+/* A-Z */   t[i] = ScCharFlags::CharWord | ScCharFlags::Word | ScCharFlags::CharIdent | ScCharFlags::Ident | ScCharFlags::CharName | ScCharFlags::Name;
 
     if (FormulaGrammar::CONV_ODF == meConv)
     {
-/* [ */     t[91] = SC_COMPILER_C_ODF_LBRACKET;
+/* [ */     t[91] = ScCharFlags::OdfLBracket;
 /* \ */     // FREE
-/* ] */     t[93] = SC_COMPILER_C_ODF_RBRACKET;
+/* ] */     t[93] = ScCharFlags::OdfRBracket;
     }
     else if (FormulaGrammar::CONV_OOO == meConv)
     {
-/* [ */     t[91] = SC_COMPILER_C_CHAR;
+/* [ */     t[91] = ScCharFlags::Char;
 /* \ */     // FREE
-/* ] */     t[93] = SC_COMPILER_C_CHAR;
+/* ] */     t[93] = ScCharFlags::Char;
     }
     else if (FormulaGrammar::CONV_XL_OOX == meConv)
     {
-/* [ */     t[91] = SC_COMPILER_C_CHAR | SC_COMPILER_C_CHAR_IDENT;
+/* [ */     t[91] = ScCharFlags::Char | ScCharFlags::CharIdent;
 /* \ */     // FREE
-/* ] */     t[93] = SC_COMPILER_C_CHAR | SC_COMPILER_C_IDENT;
+/* ] */     t[93] = ScCharFlags::Char | ScCharFlags::Ident;
     }
     else if (FormulaGrammar::CONV_XL_A1 == meConv)
     {
-/* [ */     t[91] = SC_COMPILER_C_CHAR;
+/* [ */     t[91] = ScCharFlags::Char;
 /* \ */     // FREE
-/* ] */     t[93] = SC_COMPILER_C_CHAR;
+/* ] */     t[93] = ScCharFlags::Char;
     }
     else if( FormulaGrammar::CONV_XL_R1C1 == meConv )
     {
-/* [ */     t[91] = SC_COMPILER_C_IDENT;
+/* [ */     t[91] = ScCharFlags::Ident;
 /* \ */     // FREE
-/* ] */     t[93] = SC_COMPILER_C_IDENT;
+/* ] */     t[93] = ScCharFlags::Ident;
     }
     else
     {
@@ -394,55 +394,55 @@ ScCompiler::Convention::Convention( FormulaGrammar::AddressConvention eConv )
 /* ] */     // FREE
     }
 
-/* ^ */     t[94] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
-/* _ */     t[95] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT | SC_COMPILER_C_CHAR_NAME | SC_COMPILER_C_NAME;
+/* ^ */     t[94] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
+/* _ */     t[95] = ScCharFlags::CharWord | ScCharFlags::Word | ScCharFlags::CharIdent | ScCharFlags::Ident | ScCharFlags::CharName | ScCharFlags::Name;
 /* ` */     // FREE
 
             for (i = 97; i < 123; i++)
-/* a-z */       t[i] = SC_COMPILER_C_CHAR_WORD | SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_IDENT | SC_COMPILER_C_IDENT | SC_COMPILER_C_CHAR_NAME | SC_COMPILER_C_NAME;
+/* a-z */       t[i] = ScCharFlags::CharWord | ScCharFlags::Word | ScCharFlags::CharIdent | ScCharFlags::Ident | ScCharFlags::CharName | ScCharFlags::Name;
 
-/* { */     t[123] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; // array open
-/* | */     t[124] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; // array row sep (Should be OOo specific)
-/* } */     t[125] = SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP; // array close
-/* ~ */     t[126] = SC_COMPILER_C_CHAR;        // OOo specific
+/* { */     t[123] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep; // array open
+/* | */     t[124] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep; // array row sep (Should be OOo specific)
+/* } */     t[125] = ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep; // array close
+/* ~ */     t[126] = ScCharFlags::Char;        // OOo specific
 /* 127 */   // FREE
 
     if( FormulaGrammar::CONV_XL_A1 == meConv || FormulaGrammar::CONV_XL_R1C1 == meConv || FormulaGrammar::CONV_XL_OOX == meConv )
     {
-/*   */     t[32] |=   SC_COMPILER_C_WORD;
-/* ! */     t[33] |=   SC_COMPILER_C_IDENT | SC_COMPILER_C_WORD;
-/* " */     t[34] |=   SC_COMPILER_C_WORD;
-/* # */     t[35] &= (~SC_COMPILER_C_WORD_SEP);
-/* # */     t[35] |=   SC_COMPILER_C_WORD;
-/* % */     t[37] |=   SC_COMPILER_C_WORD;
-/* ' */     t[39] |=   SC_COMPILER_C_WORD;
-
-/* % */     t[37] |=   SC_COMPILER_C_WORD;
-/* & */     t[38] |=   SC_COMPILER_C_WORD;
-/* ' */     t[39] |=   SC_COMPILER_C_WORD;
-/* ( */     t[40] |=   SC_COMPILER_C_WORD;
-/* ) */     t[41] |=   SC_COMPILER_C_WORD;
-/* * */     t[42] |=   SC_COMPILER_C_WORD;
-/* + */     t[43] |=   SC_COMPILER_C_WORD;
+/*   */     t[32] |=   ScCharFlags::Word;
+/* ! */     t[33] |=   ScCharFlags::Ident | ScCharFlags::Word;
+/* " */     t[34] |=   ScCharFlags::Word;
+/* # */     t[35] &= (~ScCharFlags::WordSep);
+/* # */     t[35] |=   ScCharFlags::Word;
+/* % */     t[37] |=   ScCharFlags::Word;
+/* ' */     t[39] |=   ScCharFlags::Word;
+
+/* % */     t[37] |=   ScCharFlags::Word;
+/* & */     t[38] |=   ScCharFlags::Word;
+/* ' */     t[39] |=   ScCharFlags::Word;
+/* ( */     t[40] |=   ScCharFlags::Word;
+/* ) */     t[41] |=   ScCharFlags::Word;
+/* * */     t[42] |=   ScCharFlags::Word;
+/* + */     t[43] |=   ScCharFlags::Word;
 #if 0 /* this really needs to be locale specific. */
-/* , */     t[44]  =   SC_COMPILER_C_CHAR | SC_COMPILER_C_WORD_SEP | SC_COMPILER_C_VALUE_SEP;
+/* , */     t[44]  =   ScCharFlags::Char | ScCharFlags::WordSep | ScCharFlags::ValueSep;
 #else
-/* , */     t[44] |=   SC_COMPILER_C_WORD;
+/* , */     t[44] |=   ScCharFlags::Word;
 #endif
-/* - */     t[45] |=   SC_COMPILER_C_WORD;
+/* - */     t[45] |=   ScCharFlags::Word;
 
-/* ; */     t[59] |=   SC_COMPILER_C_WORD;
-/* < */     t[60] |=   SC_COMPILER_C_WORD;
-/* = */     t[61] |=   SC_COMPILER_C_WORD;
-/* > */     t[62] |=   SC_COMPILER_C_WORD;
+/* ; */     t[59] |=   ScCharFlags::Word;
+/* < */     t[60] |=   ScCharFlags::Word;
+/* = */     t[61] |=   ScCharFlags::Word;
+/* > */     t[62] |=   ScCharFlags::Word;
 /* ? */     // question really is not permitted in sheet name
-/* @ */     t[64] |=   SC_COMPILER_C_WORD;
-/* [ */     t[91] |=   SC_COMPILER_C_WORD;
-/* ] */     t[93] |=   SC_COMPILER_C_WORD;
-/* { */     t[123]|=   SC_COMPILER_C_WORD;
-/* | */     t[124]|=   SC_COMPILER_C_WORD;
-/* } */     t[125]|=   SC_COMPILER_C_WORD;
-/* ~ */     t[126]|=   SC_COMPILER_C_WORD;
+/* @ */     t[64] |=   ScCharFlags::Word;
+/* [ */     t[91] |=   ScCharFlags::Word;
+/* ] */     t[93] |=   ScCharFlags::Word;
+/* { */     t[123]|=   ScCharFlags::Word;
+/* | */     t[124]|=   ScCharFlags::Word;
+/* } */     t[125]|=   ScCharFlags::Word;
+/* ~ */     t[126]|=   ScCharFlags::Word;
     }
 }
 
@@ -726,7 +726,7 @@ struct Convention_A1 : public ScCompiler::Convention
                 nSrcPos, nStartFlags, aAddAllowed, nContFlags, aAddAllowed );
     }
 
-    virtual sal_uLong getCharTableFlags( sal_Unicode c, sal_Unicode /*cLast*/ ) const override
+    virtual ScCharFlags getCharTableFlags( sal_Unicode c, sal_Unicode /*cLast*/ ) const override
     {
         return mpCharTable[static_cast<sal_uInt8>(c)];
     }
@@ -1706,12 +1706,12 @@ struct ConventionXL_R1C1 : public ScCompiler::Convention, public ConventionXL
         r1c1_add_col(rBuffer, rRef.Ref2, aAbsRef.aEnd);
     }
 
-    virtual sal_uLong getCharTableFlags( sal_Unicode c, sal_Unicode cLast ) const override
+    virtual ScCharFlags getCharTableFlags( sal_Unicode c, sal_Unicode cLast ) const override
     {
-        sal_uLong nFlags = mpCharTable[static_cast<sal_uInt8>(c)];
+        ScCharFlags nFlags = mpCharTable[static_cast<sal_uInt8>(c)];
         if (c == '-' && cLast == '[')
             // '-' can occur within a reference string only after '[' e.g. R[-1]C.
-            nFlags |= SC_COMPILER_C_IDENT;
+            nFlags |= ScCharFlags::Ident;
         return nFlags;
     }
 };
@@ -2011,7 +2011,7 @@ sal_Int32 ScCompiler::NextSymbol(bool bInArray)
     while ((c != 0) && (eState != ssStop) )
     {
         pSrc++;
-        sal_uLong nMask = GetCharTableFlags( c, cLast );
+        ScCharFlags nMask = GetCharTableFlags( c, cLast );
 
         // The parameter separator and the array column and row separators end
         // things unconditionally if not in string or reference.
@@ -2044,10 +2044,10 @@ Label_MaskStateMachine:
                     *pSym++ = c;
                     eState = ssGetTableRefColumn;
                 }
-                else if( nMask & SC_COMPILER_C_ODF_LABEL_OP )
+                else if( nMask & ScCharFlags::OdfLabelOp )
                 {
                     // '!!' automatic intersection
-                    if (GetCharTableFlags( pSrc[0], 0 ) & SC_COMPILER_C_ODF_LABEL_OP)
+                    if (GetCharTableFlags( pSrc[0], 0 ) & ScCharFlags::OdfLabelOp)
                     {
                         /* TODO: For now the UI "space operator" is used, this
                          * could be enhanced using a specialized OpCode to get
@@ -2071,25 +2071,25 @@ Label_MaskStateMachine:
                     }
                     else
                     {
-                        nMask &= ~SC_COMPILER_C_ODF_LABEL_OP;
+                        nMask &= ~ScCharFlags::OdfLabelOp;
                         goto Label_MaskStateMachine;
                     }
                 }
-                else if( nMask & SC_COMPILER_C_ODF_NAME_MARKER )
+                else if( nMask & ScCharFlags::OdfNameMarker )
                 {
                     // '$$' defined name marker
-                    if (GetCharTableFlags( pSrc[0], 0 ) & SC_COMPILER_C_ODF_NAME_MARKER)
+                    if (GetCharTableFlags( pSrc[0], 0 ) & ScCharFlags::OdfNameMarker)
                     {
                         // both eaten, not added to pSym
                         ++pSrc;
                     }
                     else
                     {
-                        nMask &= ~SC_COMPILER_C_ODF_NAME_MARKER;
+                        nMask &= ~ScCharFlags::OdfNameMarker;
                         goto Label_MaskStateMachine;
                     }
                 }
-                else if( nMask & SC_COMPILER_C_CHAR )
+                else if( nMask & ScCharFlags::Char )
                 {
                     // '[' is a special case in OOXML, it can start an external
                     // reference ID like [1]Sheet1!A1 that needs to be scanned
@@ -2097,7 +2097,7 @@ Label_MaskStateMachine:
                     // transforms an ocDBArea into an ocTableRef.
                     if (c == '[' && FormulaGrammar::isOOXML( meGrammar) && eLastOp != ocDBArea && maTableRefs.empty())
                     {
-                        nMask &= ~SC_COMPILER_C_CHAR;
+                        nMask &= ~ScCharFlags::Char;
                         goto Label_MaskStateMachine;
                     }
                     else
@@ -2106,28 +2106,28 @@ Label_MaskStateMachine:
                         eState = ssStop;
                     }
                 }
-                else if( nMask & SC_COMPILER_C_ODF_LBRACKET )
+                else if( nMask & ScCharFlags::OdfLBracket )
                 {
                     // eaten, not added to pSym
                     eState = ssGetReference;
                     mnPredetectedReference = 1;
                 }
-                else if( nMask & SC_COMPILER_C_CHAR_BOOL )
+                else if( nMask & ScCharFlags::CharBool )
                 {
                     *pSym++ = c;
                     eState = ssGetBool;
                 }
-                else if( nMask & SC_COMPILER_C_CHAR_VALUE )
+                else if( nMask & ScCharFlags::CharValue )
                 {
                     *pSym++ = c;
                     eState = ssGetValue;
                 }
-                else if( nMask & SC_COMPILER_C_CHAR_STRING )
+                else if( nMask & ScCharFlags::CharString )
                 {
                     *pSym++ = c;
                     eState = ssGetString;
                 }
-                else if( nMask & SC_COMPILER_C_CHAR_ERRCONST )
+                else if( nMask & ScCharFlags::CharErrConst )
                 {
                     *pSym++ = c;
                     if (!maTableRefs.empty() && maTableRefs.back().mnLevel == 2)
@@ -2135,11 +2135,11 @@ Label_MaskStateMachine:
                     else
                         eState = ssGetErrorConstant;
                 }
-                else if( nMask & SC_COMPILER_C_CHAR_DONTCARE )
+                else if( nMask & ScCharFlags::CharDontCare )
                 {
                     nSpaces++;
                 }
-                else if( nMask & SC_COMPILER_C_CHAR_IDENT )
+                else if( nMask & ScCharFlags::CharIdent )
                 {   // try to get a simple ASCII identifier before calling
                     // i18n, to gain performance during import
                     *pSym++ = c;
@@ -2154,7 +2154,7 @@ Label_MaskStateMachine:
             break;
             case ssGetIdent:
             {
-                if ( nMask & SC_COMPILER_C_IDENT )
+                if ( nMask & ScCharFlags::Ident )
                 {   // This catches also $Sheet1.A$1, for example.
                     if( pSym == &cSymbol[ MAXSTRLEN-1 ] )
                     {
@@ -2220,7 +2220,7 @@ Label_MaskStateMachine:
             break;
             case ssGetBool :
             {
-                if( nMask & SC_COMPILER_C_BOOL )
+                if( nMask & ScCharFlags::Bool )
                 {
                     *pSym++ = c;
                     eState = ssStop;
@@ -2250,16 +2250,16 @@ Label_MaskStateMachine:
                     else
                         *pSym++ = c;
                 }
-                else if( nMask & SC_COMPILER_C_VALUE )
+                else if( nMask & ScCharFlags::Value )
                     *pSym++ = c;
-                else if( nMask & SC_COMPILER_C_VALUE_SEP )
+                else if( nMask & ScCharFlags::ValueSep )
                 {
                     pSrc--;
                     eState = ssStop;
                 }
                 else if (c == 'E' || c == 'e')
                 {
-                    if (GetCharTableFlags( pSrc[0], 0 ) & SC_COMPILER_C_VALUE_EXP)
+                    if (GetCharTableFlags( pSrc[0], 0 ) & ScCharFlags::ValueExp)
                         *pSym++ = c;
                     else
                     {
@@ -2268,10 +2268,10 @@ Label_MaskStateMachine:
                         eState = ssStop;
                     }
                 }
-                else if( nMask & SC_COMPILER_C_VALUE_SIGN )
+                else if( nMask & ScCharFlags::ValueSign )
                 {
                     if (((cLast == 'E') || (cLast == 'e')) &&
-                            (GetCharTableFlags( pSrc[0], 0 ) & SC_COMPILER_C_VALUE_VALUE))
+                            (GetCharTableFlags( pSrc[0], 0 ) & ScCharFlags::ValueValue))
                     {
                         *pSym++ = c;
                     }
@@ -2291,7 +2291,7 @@ Label_MaskStateMachine:
             break;
             case ssGetString :
             {
-                if( nMask & SC_COMPILER_C_STRING_SEP )
+                if( nMask & ScCharFlags::StringSep )
                 {
                     if ( !bQuote )
                     {
@@ -2316,7 +2316,7 @@ Label_MaskStateMachine:
             }
             break;
             case ssSkipString:
-                if( nMask & SC_COMPILER_C_STRING_SEP )
+                if( nMask & ScCharFlags::StringSep )
                     eState = ssStop;
                 break;
             case ssGetErrorConstant:
@@ -2338,7 +2338,7 @@ Label_MaskStateMachine:
                         // Check if this is #REF! that starts an invalid reference.
                         // Note we have an implicit '!' here at the end.
                         if (pSym - &cSymbol[0] == 4 && lcl_isUnicodeIgnoreAscii( cSymbol, "#REF", 4) &&
-                                ((GetCharTableFlags( *pSrc, c) & SC_COMPILER_C_IDENT) != 0))
+                                (GetCharTableFlags( *pSrc, c) & ScCharFlags::Ident))
                             eState = ssGetIdent;
                         else
                             eState = ssStop;
@@ -2353,7 +2353,7 @@ Label_MaskStateMachine:
                             eState = ssStop;
                         }
                     }
-                    else if ((nMask & SC_COMPILER_C_WORD_SEP) ||
+                    else if ((nMask & ScCharFlags::WordSep) ||
                             (c < 128 && !rtl::isAsciiAlphanumeric( c)))
                     {
                         bAdd = false;
@@ -2465,7 +2465,7 @@ Label_MaskStateMachine:
                     static const int kRefErr    = (1 << 10);
 
                     bool bAddToSymbol = true;
-                    if ((nMask & SC_COMPILER_C_ODF_RBRACKET) && !(nRefInName & kOpen))
+                    if ((nMask & ScCharFlags::OdfRBracket) && !(nRefInName & kOpen))
                     {
                         OSL_ENSURE( nRefInName & (kPast | kDefName | kRefErr),
                                 "ScCompiler::NextSymbol: reference: "
@@ -3091,7 +3091,7 @@ bool ScCompiler::IsReference( const OUString& rName, const OUString* pErrRef )
             if ( !(ch2 == '$' || rtl::isAsciiAlpha( ch2 )) )
                 return false;
             if ( cDecSep == '.' && (ch2 == 'E' || ch2 == 'e')   // E + - digit
-                    && (GetCharTableFlags( pTabSep[2], pTabSep[1] ) & SC_COMPILER_C_VALUE_EXP) )
+                    && (GetCharTableFlags( pTabSep[2], pTabSep[1] ) & ScCharFlags::ValueExp) )
             {
                 // If it is an 1.E2 expression check if "1" is an existent sheet
                 // name. If so, a desired value 1.E2 would have to be entered as
@@ -3769,7 +3769,7 @@ void ScCompiler::AutoCorrectParsedSymbol()
             // Don't be pedantic: c < 128 should be sufficient here.
             while ( nPos && ((aCorrectedSymbol[nPos] < 128) &&
                     ((GetCharTableFlags(aCorrectedSymbol[nPos], aCorrectedSymbol[nPos-1]) &
-                    (SC_COMPILER_C_WORD | SC_COMPILER_C_CHAR_DONTCARE)) == 0)) )
+                    (ScCharFlags::Word | ScCharFlags::CharDontCare)) == ScCharFlags::NONE)) )
                 nPos--;
             if ( nPos == MAXSTRLEN - 2 )
                 aCorrectedSymbol = aCorrectedSymbol.replaceAt( nPos, 1, OUString(cQuote) );   // '"' the 255th character
@@ -3787,8 +3787,8 @@ void ScCompiler::AutoCorrectParsedSymbol()
             aCorrectedSymbol = mxSymbols->getSymbol(ocMul);
             bCorrected = true;
         }
-        else if ( (GetCharTableFlags( c1, 0 ) & SC_COMPILER_C_CHAR_VALUE)
-               && (GetCharTableFlags( c2, c2p ) & SC_COMPILER_C_CHAR_VALUE) )
+        else if ( (GetCharTableFlags( c1, 0 ) & ScCharFlags::CharValue)
+               && (GetCharTableFlags( c2, c2p ) & ScCharFlags::CharValue) )
         {
             if ( comphelper::string::getTokenCount(aCorrectedSymbol, cx) > 1 )
             {   // x => *
@@ -4719,7 +4719,7 @@ void ScCompiler::MoveRelWrap( ScTokenArray& rArr, ScDocument* pDoc, const ScAddr
 }
 
 bool ScCompiler::IsCharFlagAllConventions(
-    OUString const & rStr, sal_Int32 nPos, sal_uLong nFlags )
+    OUString const & rStr, sal_Int32 nPos, ScCharFlags nFlags )
 {
     sal_Unicode c = rStr[ nPos ];
     sal_Unicode cLast = nPos > 0 ? rStr[ nPos-1 ] : 0;
diff --git a/sc/source/core/tool/rangenam.cxx b/sc/source/core/tool/rangenam.cxx
index 62b90c7da8a3..7626e16ae5f6 100644
--- a/sc/source/core/tool/rangenam.cxx
+++ b/sc/source/core/tool/rangenam.cxx
@@ -437,20 +437,20 @@ void ScRangeData::MakeValidName( OUString& rName )
     // strip leading invalid characters
     sal_Int32 nPos = 0;
     sal_Int32 nLen = rName.getLength();
-    while ( nPos < nLen && !ScCompiler::IsCharFlagAllConventions( rName, nPos, SC_COMPILER_C_NAME) )
+    while ( nPos < nLen && !ScCompiler::IsCharFlagAllConventions( rName, nPos, ScCharFlags::Name) )
         ++nPos;
     if ( nPos>0 )
         rName = rName.copy(nPos);
 
     // if the first character is an invalid start character, precede with '_'
-    if ( !rName.isEmpty() && !ScCompiler::IsCharFlagAllConventions( rName, 0, SC_COMPILER_C_CHAR_NAME ) )
+    if ( !rName.isEmpty() && !ScCompiler::IsCharFlagAllConventions( rName, 0, ScCharFlags::CharName ) )
         rName = "_" + rName;
 
     // replace invalid with '_'
     nLen = rName.getLength();
     for (nPos=0; nPos<nLen; nPos++)
     {
-        if ( !ScCompiler::IsCharFlagAllConventions( rName, nPos, SC_COMPILER_C_NAME) )
+        if ( !ScCompiler::IsCharFlagAllConventions( rName, nPos, ScCharFlags::Name) )
             rName = rName.replaceAt( nPos, 1, "_" );
     }
 
@@ -485,11 +485,11 @@ bool ScRangeData::IsNameValid( const OUString& rName, ScDocument* pDoc )
         return false;
     sal_Int32 nPos = 0;
     sal_Int32 nLen = rName.getLength();
-    if ( !nLen || !ScCompiler::IsCharFlagAllConventions( rName, nPos++, SC_COMPILER_C_CHAR_NAME ) )
+    if ( !nLen || !ScCompiler::IsCharFlagAllConventions( rName, nPos++, ScCharFlags::CharName ) )
         return false;
     while ( nPos < nLen )
     {
-        if ( !ScCompiler::IsCharFlagAllConventions( rName, nPos++, SC_COMPILER_C_NAME ) )
+        if ( !ScCompiler::IsCharFlagAllConventions( rName, nPos++, ScCharFlags::Name ) )
             return false;
     }
     ScAddress aAddr;
diff --git a/sc/source/filter/ftools/ftools.cxx b/sc/source/filter/ftools/ftools.cxx
index fde80bded0b4..e40967b1e143 100644
--- a/sc/source/filter/ftools/ftools.cxx
+++ b/sc/source/filter/ftools/ftools.cxx
@@ -155,10 +155,10 @@ OUString ScfTools::ConvertToScDefinedName(const OUString& rName )
     OUString sName = rName.replace(static_cast<sal_Unicode>('.'),
         static_cast<sal_Unicode>('_'));
     sal_Int32 nLen = sName.getLength();
-    if( nLen && !ScCompiler::IsCharFlagAllConventions( sName, 0, SC_COMPILER_C_CHAR_NAME ) )
+    if( nLen && !ScCompiler::IsCharFlagAllConventions( sName, 0, ScCharFlags::CharName ) )
         sName = sName.replaceAt( 0, 1, "_" );
     for( sal_Int32 nPos = 1; nPos < nLen; ++nPos )
-        if( !ScCompiler::IsCharFlagAllConventions( sName, nPos, SC_COMPILER_C_NAME ) )
+        if( !ScCompiler::IsCharFlagAllConventions( sName, nPos, ScCharFlags::Name ) )
             sName = sName.replaceAt( nPos, 1, "_" );
     return sName;
 }