mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

convert SC_COMPILER to scoped enum

Browse Source 
Change-Id: Ib8fdce056847b2b2514f61da18c106bb3e78631c
Reviewed-on: https://gerrit.libreoffice.org/25079
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Noel Grandin <noelgrandin@gmail.com>
This commit is contained in:
Noel Grandin
2016-05-18 09:34:13 +02:00
committed by Noel Grandin
parent fd6e86572a
commit aad5eced79
4 changed files with 158 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
sc/inc/compiler.hxx
View File

@@ -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

226
sc/source/core/tool/compiler.cxx
View File

@@ -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;
/* 0-9 */ t[i] = ScCharFlags::CharValue | ScCharFlags::Word | ScCharFlags::Value | ScCharFlags::ValueExp | ScCharFlags::ValueValue | ScCharFlags::Ident | ScCharFlags::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;
/* : */ 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[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] |= 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[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;

10
sc/source/core/tool/rangenam.cxx
View File

@@ -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;

4
sc/source/filter/ftools/ftools.cxx
View File

@@ -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;
}