formula/inc/core_resource.hrc | 604 ++++++++++++++-------------- formula/source/core/api/FormulaCompiler.cxx | 58 +- formula/source/core/api/token.cxx | 12 formula/source/ui/dlg/formula.cxx | 4 include/formula/compiler.hxx | 94 ++++ include/formula/opcode.hxx | 148 +++--- sc/inc/scfuncs.hrc | 94 ++-- sc/source/core/data/funcdesc.cxx | 24 - sc/source/core/tool/appoptio.cxx | 3 sc/source/core/tool/compiler.cxx | 10 sc/source/core/tool/parclass.cxx | 4 sc/source/core/tool/token.cxx | 2 12 files changed, 564 insertions(+), 493 deletions(-)
New commits: commit a465133a02d83c0b7f5ca796f76018cb925c109d Author: Noel Grandin <[email protected]> AuthorDate: Thu Mar 12 17:26:20 2026 +0100 Commit: Noel Grandin <[email protected]> CommitDate: Thu Mar 12 20:58:59 2026 +0100 Revert "replace SC_OPCODE* with oc* constants (1)" This reverts commit 23ef4be9b8b96b4b7008ed3d7ab85c9177915317. Revert for this now, I messed up some of the search and replace and renamed things I did not intend to touch, Change-Id: Ibf862fc3559f41bf200ec2ca50a5369bb356b4f8 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/201564 Tested-by: Jenkins Reviewed-by: Noel Grandin <[email protected]> diff --git a/formula/inc/core_resource.hrc b/formula/inc/core_resource.hrc index 440e990411cd..cb2359afc069 100644 --- a/formula/inc/core_resource.hrc +++ b/formula/inc/core_resource.hrc @@ -34,40 +34,40 @@ // ScCompiler::IsOpCode() in the if (mxSymbols->isODFF()) block. const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = { - { "IF" , ocIf }, - { "IFERROR" , ocIfError }, - { "IFNA" , ocIfNA }, - { "CHOOSE" , ocChoose }, - { "(" , ocOpen }, - { ")" , ocClose }, + { "IF" , SC_OPCODE_IF }, + { "IFERROR" , SC_OPCODE_IF_ERROR }, + { "IFNA" , SC_OPCODE_IF_NA }, + { "CHOOSE" , SC_OPCODE_CHOOSE }, + { "(" , SC_OPCODE_OPEN }, + { ")" , SC_OPCODE_CLOSE }, // SC_OPCODE_TABLE_REF_... not supported in ODFF - { "{" , ocArrayOpen }, - { "}" , ocArrayClose }, - { "|" , ocArrayRowSep }, - { ";" , ocArrayColSep }, - { ";" , ocSep }, - { "%" , ocPercentSign }, - { "+" , ocAdd }, - { "-" , ocSub }, - { "*" , ocMul }, - { "/" , ocDiv }, - { "&" , ocAmpersand }, - { "^" , ocPow }, - { "=" , ocEqual }, - { "<>" , ocNotEqual }, - { "<" , ocLess }, - { ">" , ocGreater }, - { "<=" , ocLessEqual }, - { ">=" , ocGreaterEqual }, - { "AND" , ocAnd }, - { "OR" , ocOr }, - { "XOR" , ocXor }, - { "!" , ocIntersect }, - { "~" , ocUnion }, - { ":" , ocRange }, + { "{" , SC_OPCODE_ARRAY_OPEN }, + { "}" , SC_OPCODE_ARRAY_CLOSE }, + { "|" , SC_OPCODE_ARRAY_ROW_SEP }, + { ";" , SC_OPCODE_ARRAY_COL_SEP }, + { ";" , SC_OPCODE_SEP }, + { "%" , SC_OPCODE_PERCENT_SIGN }, + { "+" , SC_OPCODE_ADD }, + { "-" , SC_OPCODE_SUB }, + { "*" , SC_OPCODE_MUL }, + { "/" , SC_OPCODE_DIV }, + { "&" , SC_OPCODE_AMPERSAND }, + { "^" , SC_OPCODE_POW }, + { "=" , SC_OPCODE_EQUAL }, + { "<>" , SC_OPCODE_NOT_EQUAL }, + { "<" , SC_OPCODE_LESS }, + { ">" , SC_OPCODE_GREATER }, + { "<=" , SC_OPCODE_LESS_EQUAL }, + { ">=" , SC_OPCODE_GREATER_EQUAL }, + { "AND" , SC_OPCODE_AND }, + { "OR" , SC_OPCODE_OR }, + { "XOR" , SC_OPCODE_XOR }, + { "!" , SC_OPCODE_INTERSECT }, + { "~" , SC_OPCODE_UNION }, + { ":" , SC_OPCODE_RANGE }, { "NOT" , SC_OPCODE_NOT }, { "NEG" , SC_OPCODE_NEG }, - { "-" , ocNegSub }, + { "-" , SC_OPCODE_NEG_SUB }, { "PI" , SC_OPCODE_PI }, { "RAND" , SC_OPCODE_RANDOM }, { "TRUE" , SC_OPCODE_TRUE }, @@ -173,7 +173,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = { "ROUNDDOWN" , SC_OPCODE_ROUND_DOWN }, { "TRUNC" , SC_OPCODE_TRUNC }, { "LOG" , SC_OPCODE_LOG }, - { "POWER" , ocPowER }, + { "POWER" , SC_OPCODE_POWER }, { "GCD" , SC_OPCODE_GCD }, { "LCM" , SC_OPCODE_LCM }, { "MOD" , SC_OPCODE_MOD }, @@ -250,7 +250,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = { "CUMPRINC" , SC_OPCODE_CUM_PRINC }, { "EFFECT" , SC_OPCODE_EFFECT }, { "NOMINAL" , SC_OPCODE_NOMINAL }, - { "SUBTOTAL" , ocSub_TOTAL }, + { "SUBTOTAL" , SC_OPCODE_SUB_TOTAL }, { "DSUM" , SC_OPCODE_DB_SUM }, { "DCOUNT" , SC_OPCODE_DB_COUNT }, { "DCOUNTA" , SC_OPCODE_DB_COUNT_2 }, @@ -264,7 +264,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = { "DVAR" , SC_OPCODE_DB_VAR }, { "DVARP" , SC_OPCODE_DB_VAR_P }, { "INDIRECT" , SC_OPCODE_INDIRECT }, - { "ADDRESS" , ocAddRESS }, + { "ADDRESS" , SC_OPCODE_ADDRESS }, { "MATCH" , SC_OPCODE_MATCH }, { "COM.MICROSOFT.XMATCH" , SC_OPCODE_X_MATCH }, { "COUNTBLANK" , SC_OPCODE_COUNT_EMPTY_CELLS }, @@ -294,11 +294,11 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = { "COM.MICROSOFT.TOCOL" , SC_OPCODE_TOCOL }, { "COM.MICROSOFT.TOROW" , SC_OPCODE_TOROW }, { "COM.MICROSOFT.UNIQUE" , SC_OPCODE_UNIQUE }, - { "COM.MICROSOFT.LET" , ocLet }, + { "COM.MICROSOFT.LET" , SC_OPCODE_LET }, { "COM.MICROSOFT.WRAPCOLS" , SC_OPCODE_WRAPCOLS }, { "COM.MICROSOFT.WRAPROWS" , SC_OPCODE_WRAPROWS }, - { "_xlpm." , ocStringName }, - { "ORG.OPENOFFICE.MULTIRANGE" , ocMulTI_AREA }, // legacy for range list (union) + { "_xlpm." , SC_OPCODE_STRINGNAME }, + { "ORG.OPENOFFICE.MULTIRANGE" , SC_OPCODE_MULTI_AREA }, // legacy for range list (union) { "OFFSET" , SC_OPCODE_OFFSET }, { "INDEX" , SC_OPCODE_INDEX }, { "AREAS" , SC_OPCODE_AREAS }, @@ -319,7 +319,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = { "SEARCHB" , SC_OPCODE_SEARCHB }, { "MIDB" , SC_OPCODE_MIDB }, { "TEXT" , SC_OPCODE_TEXT }, - { "SUBSTITUTE" , ocSubSTITUTE }, + { "SUBSTITUTE" , SC_OPCODE_SUBSTITUTE }, { "REPT" , SC_OPCODE_REPT }, { "CONCATENATE" , SC_OPCODE_CONCAT }, { "COM.MICROSOFT.CONCAT" , SC_OPCODE_CONCAT_MS }, @@ -472,13 +472,13 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = { "BITRSHIFT" , SC_OPCODE_BITRSHIFT }, { "BITLSHIFT" , SC_OPCODE_BITLSHIFT }, /* BEGIN defined ERROR.TYPE() values. */ - { "#NULL!" , ocErrNull }, - { "#DIV/0!" , ocErrDivZero }, - { "#VALUE!" , ocErrValue }, - { "#REF!" , ocErrRef }, - { "#NAME?" , ocErrName }, - { "#NUM!" , ocErrNum }, - { "#N/A" , ocErrNA }, + { "#NULL!" , SC_OPCODE_ERROR_NULL }, + { "#DIV/0!" , SC_OPCODE_ERROR_DIVZERO }, + { "#VALUE!" , SC_OPCODE_ERROR_VALUE }, + { "#REF!" , SC_OPCODE_ERROR_REF }, + { "#NAME?" , SC_OPCODE_ERROR_NAME }, + { "#NUM!" , SC_OPCODE_ERROR_NUM }, + { "#N/A" , SC_OPCODE_ERROR_NA }, /* END defined ERROR.TYPE() values. */ { "COM.MICROSOFT.FILTERXML" , SC_OPCODE_FILTERXML }, { "COM.MICROSOFT.WEBSERVICE" , SC_OPCODE_WEBSERVICE }, @@ -499,46 +499,46 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_ODFF[] = /** These function names are used in the OOXML XLSX import/export. */ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { - { "IF" , ocIf }, - { "IFERROR" , ocIfError }, - { "_xlfn.IFNA" , ocIfNA }, - { "CHOOSE" , ocChoose }, - { "(" , ocOpen }, - { ")" , ocClose }, - { "[" , ocTableRefOpen }, - { "]" , ocTableRefClose }, - { "#All" , ocTableRefItemAll }, - { "#Headers" , ocTableRefItemHeaders }, - { "#Data" , ocTableRefItemData }, - { "#Totals" , ocTableRefItemTotals }, - { "#This Row" , ocTableRefItemThisRow }, - { "{" , ocArrayOpen }, - { "}" , ocArrayClose }, - { ";" , ocArrayRowSep }, - { "," , ocArrayColSep }, - { "," , ocSep }, - { "%" , ocPercentSign }, - { "+" , ocAdd }, - { "-" , ocSub }, - { "*" , ocMul }, - { "/" , ocDiv }, - { "&" , ocAmpersand }, - { "^" , ocPow }, - { "=" , ocEqual }, - { "<>" , ocNotEqual }, - { "<" , ocLess }, - { ">" , ocGreater }, - { "<=" , ocLessEqual }, - { ">=" , ocGreaterEqual }, - { "AND" , ocAnd }, - { "OR" , ocOr }, - { "_xlfn.XOR" , ocXor }, - { " " , ocIntersect }, - { "," , ocUnion }, // Excel uses ',' as Union operator - { ":" , ocRange }, + { "IF" , SC_OPCODE_IF }, + { "IFERROR" , SC_OPCODE_IF_ERROR }, + { "_xlfn.IFNA" , SC_OPCODE_IF_NA }, + { "CHOOSE" , SC_OPCODE_CHOOSE }, + { "(" , SC_OPCODE_OPEN }, + { ")" , SC_OPCODE_CLOSE }, + { "[" , SC_OPCODE_TABLE_REF_OPEN }, + { "]" , SC_OPCODE_TABLE_REF_CLOSE }, + { "#All" , SC_OPCODE_TABLE_REF_ITEM_ALL }, + { "#Headers" , SC_OPCODE_TABLE_REF_ITEM_HEADERS }, + { "#Data" , SC_OPCODE_TABLE_REF_ITEM_DATA }, + { "#Totals" , SC_OPCODE_TABLE_REF_ITEM_TOTALS }, + { "#This Row" , SC_OPCODE_TABLE_REF_ITEM_THIS_ROW }, + { "{" , SC_OPCODE_ARRAY_OPEN }, + { "}" , SC_OPCODE_ARRAY_CLOSE }, + { ";" , SC_OPCODE_ARRAY_ROW_SEP }, + { "," , SC_OPCODE_ARRAY_COL_SEP }, + { "," , SC_OPCODE_SEP }, + { "%" , SC_OPCODE_PERCENT_SIGN }, + { "+" , SC_OPCODE_ADD }, + { "-" , SC_OPCODE_SUB }, + { "*" , SC_OPCODE_MUL }, + { "/" , SC_OPCODE_DIV }, + { "&" , SC_OPCODE_AMPERSAND }, + { "^" , SC_OPCODE_POW }, + { "=" , SC_OPCODE_EQUAL }, + { "<>" , SC_OPCODE_NOT_EQUAL }, + { "<" , SC_OPCODE_LESS }, + { ">" , SC_OPCODE_GREATER }, + { "<=" , SC_OPCODE_LESS_EQUAL }, + { ">=" , SC_OPCODE_GREATER_EQUAL }, + { "AND" , SC_OPCODE_AND }, + { "OR" , SC_OPCODE_OR }, + { "_xlfn.XOR" , SC_OPCODE_XOR }, + { " " , SC_OPCODE_INTERSECT }, + { "," , SC_OPCODE_UNION }, // Excel uses ',' as Union operator + { ":" , SC_OPCODE_RANGE }, { "NOT" , SC_OPCODE_NOT }, { "NEG" , SC_OPCODE_NEG }, - { "-" , ocNegSub }, + { "-" , SC_OPCODE_NEG_SUB }, { "PI" , SC_OPCODE_PI }, { "RAND" , SC_OPCODE_RANDOM }, { "TRUE" , SC_OPCODE_TRUE }, @@ -644,7 +644,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { "ROUNDDOWN" , SC_OPCODE_ROUND_DOWN }, { "TRUNC" , SC_OPCODE_TRUNC }, { "LOG" , SC_OPCODE_LOG }, - { "POWER" , ocPowER }, + { "POWER" , SC_OPCODE_POWER }, { "GCD" , SC_OPCODE_GCD }, { "LCM" , SC_OPCODE_LCM }, { "MOD" , SC_OPCODE_MOD }, @@ -721,7 +721,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { "CUMPRINC" , SC_OPCODE_CUM_PRINC }, { "EFFECT" , SC_OPCODE_EFFECT }, { "NOMINAL" , SC_OPCODE_NOMINAL }, - { "SUBTOTAL" , ocSub_TOTAL }, + { "SUBTOTAL" , SC_OPCODE_SUB_TOTAL }, { "DSUM" , SC_OPCODE_DB_SUM }, { "DCOUNT" , SC_OPCODE_DB_COUNT }, { "DCOUNTA" , SC_OPCODE_DB_COUNT_2 }, @@ -735,7 +735,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { "DVAR" , SC_OPCODE_DB_VAR }, { "DVARP" , SC_OPCODE_DB_VAR_P }, { "INDIRECT" , SC_OPCODE_INDIRECT }, - { "ADDRESS" , ocAddRESS }, + { "ADDRESS" , SC_OPCODE_ADDRESS }, { "MATCH" , SC_OPCODE_MATCH }, { "_xlfn.XMATCH" , SC_OPCODE_X_MATCH }, { "COUNTBLANK" , SC_OPCODE_COUNT_EMPTY_CELLS }, @@ -765,11 +765,11 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { "_xlfn.TOCOL" , SC_OPCODE_TOCOL }, { "_xlfn.TOROW" , SC_OPCODE_TOROW }, { "_xlfn.UNIQUE" , SC_OPCODE_UNIQUE }, - { "_xlfn.LET" , ocLet }, + { "_xlfn.LET" , SC_OPCODE_LET }, { "_xlfn.WRAPCOLS" , SC_OPCODE_WRAPCOLS }, { "_xlfn.WRAPROWS" , SC_OPCODE_WRAPROWS }, - { "_xlpm." , ocStringName }, - { "_xlfn.ORG.OPENOFFICE.MULTIRANGE" , ocMulTI_AREA }, // legacy for range list (union) + { "_xlpm." , SC_OPCODE_STRINGNAME }, + { "_xlfn.ORG.OPENOFFICE.MULTIRANGE" , SC_OPCODE_MULTI_AREA }, // legacy for range list (union) { "OFFSET" , SC_OPCODE_OFFSET }, { "INDEX" , SC_OPCODE_INDEX }, { "AREAS" , SC_OPCODE_AREAS }, @@ -790,7 +790,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { "SEARCHB" , SC_OPCODE_SEARCHB }, { "MIDB" , SC_OPCODE_MIDB }, { "TEXT" , SC_OPCODE_TEXT }, - { "SUBSTITUTE" , ocSubSTITUTE }, + { "SUBSTITUTE" , SC_OPCODE_SUBSTITUTE }, { "REPT" , SC_OPCODE_REPT }, { "CONCATENATE" , SC_OPCODE_CONCAT }, { "_xlfn.CONCAT" , SC_OPCODE_CONCAT_MS }, @@ -942,13 +942,13 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { "_xlfn.BITXOR" , SC_OPCODE_BITXOR }, { "_xlfn.BITRSHIFT" , SC_OPCODE_BITRSHIFT }, { "_xlfn.BITLSHIFT" , SC_OPCODE_BITLSHIFT }, - { "#NULL!" , ocErrNull }, - { "#DIV/0!" , ocErrDivZero }, - { "#VALUE!" , ocErrValue }, - { "#REF!" , ocErrRef }, - { "#NAME?" , ocErrName }, - { "#NUM!" , ocErrNum }, - { "#N/A" , ocErrNA }, + { "#NULL!" , SC_OPCODE_ERROR_NULL }, + { "#DIV/0!" , SC_OPCODE_ERROR_DIVZERO }, + { "#VALUE!" , SC_OPCODE_ERROR_VALUE }, + { "#REF!" , SC_OPCODE_ERROR_REF }, + { "#NAME?" , SC_OPCODE_ERROR_NAME }, + { "#NUM!" , SC_OPCODE_ERROR_NUM }, + { "#N/A" , SC_OPCODE_ERROR_NA }, /* END defined ERROR.TYPE() values. */ { "_xlfn.FILTERXML" , SC_OPCODE_FILTERXML }, { "_xlfn.WEBSERVICE" , SC_OPCODE_WEBSERVICE }, @@ -963,7 +963,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = { "_xlfn.ORG.LIBREOFFICE.RAND.NV" , SC_OPCODE_RANDOM_NV }, { "_xlfn.ORG.LIBREOFFICE.RANDBETWEEN.NV" , SC_OPCODE_RANDBETWEEN_NV }, { "_xlfn.RANDARRAY" , SC_OPCODE_RANDARRAY }, - { "#REF!", ocStop }, + { "#REF!", SC_OPCODE_STOP }, { nullptr, -1 } }; @@ -974,46 +974,46 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_OOXML[] = // ScCompiler::IsOpCode() in the else if (mxSymbols->isPODF()) block. const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = { - { "IF" , ocIf }, - { "IFERROR" , ocIfError }, - { "IFNA" , ocIfNA }, - { "CHOOSE" , ocChoose }, - { "(" , ocOpen }, - { ")" , ocClose }, - { "[" , ocTableRefOpen }, - { "]" , ocTableRefClose }, - { "#All" , ocTableRefItemAll }, - { "#Headers" , ocTableRefItemHeaders }, - { "#Data" , ocTableRefItemData }, - { "#Totals" , ocTableRefItemTotals }, - { "#This Row" , ocTableRefItemThisRow }, - { "{" , ocArrayOpen }, - { "}" , ocArrayClose }, - { "|" , ocArrayRowSep }, - { ";" , ocArrayColSep }, - { ";" , ocSep }, - { "%" , ocPercentSign }, - { "+" , ocAdd }, - { "-" , ocSub }, - { "*" , ocMul }, - { "/" , ocDiv }, - { "&" , ocAmpersand }, - { "^" , ocPow }, - { "=" , ocEqual }, - { "<>" , ocNotEqual }, - { "<" , ocLess }, - { ">" , ocGreater }, - { "<=" , ocLessEqual }, - { ">=" , ocGreaterEqual }, - { "AND" , ocAnd }, - { "OR" , ocOr }, - { "XOR" , ocXor }, - { "!" , ocIntersect }, - { "~" , ocUnion }, - { ":" , ocRange }, + { "IF" , SC_OPCODE_IF }, + { "IFERROR" , SC_OPCODE_IF_ERROR }, + { "IFNA" , SC_OPCODE_IF_NA }, + { "CHOOSE" , SC_OPCODE_CHOOSE }, + { "(" , SC_OPCODE_OPEN }, + { ")" , SC_OPCODE_CLOSE }, + { "[" , SC_OPCODE_TABLE_REF_OPEN }, + { "]" , SC_OPCODE_TABLE_REF_CLOSE }, + { "#All" , SC_OPCODE_TABLE_REF_ITEM_ALL }, + { "#Headers" , SC_OPCODE_TABLE_REF_ITEM_HEADERS }, + { "#Data" , SC_OPCODE_TABLE_REF_ITEM_DATA }, + { "#Totals" , SC_OPCODE_TABLE_REF_ITEM_TOTALS }, + { "#This Row" , SC_OPCODE_TABLE_REF_ITEM_THIS_ROW }, + { "{" , SC_OPCODE_ARRAY_OPEN }, + { "}" , SC_OPCODE_ARRAY_CLOSE }, + { "|" , SC_OPCODE_ARRAY_ROW_SEP }, + { ";" , SC_OPCODE_ARRAY_COL_SEP }, + { ";" , SC_OPCODE_SEP }, + { "%" , SC_OPCODE_PERCENT_SIGN }, + { "+" , SC_OPCODE_ADD }, + { "-" , SC_OPCODE_SUB }, + { "*" , SC_OPCODE_MUL }, + { "/" , SC_OPCODE_DIV }, + { "&" , SC_OPCODE_AMPERSAND }, + { "^" , SC_OPCODE_POW }, + { "=" , SC_OPCODE_EQUAL }, + { "<>" , SC_OPCODE_NOT_EQUAL }, + { "<" , SC_OPCODE_LESS }, + { ">" , SC_OPCODE_GREATER }, + { "<=" , SC_OPCODE_LESS_EQUAL }, + { ">=" , SC_OPCODE_GREATER_EQUAL }, + { "AND" , SC_OPCODE_AND }, + { "OR" , SC_OPCODE_OR }, + { "XOR" , SC_OPCODE_XOR }, + { "!" , SC_OPCODE_INTERSECT }, + { "~" , SC_OPCODE_UNION }, + { ":" , SC_OPCODE_RANGE }, { "NOT" , SC_OPCODE_NOT }, { "NEG" , SC_OPCODE_NEG }, - { "-" , ocNegSub }, + { "-" , SC_OPCODE_NEG_SUB }, { "PI" , SC_OPCODE_PI }, { "RAND" , SC_OPCODE_RANDOM }, { "TRUE" , SC_OPCODE_TRUE }, @@ -1119,7 +1119,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = { "ROUNDDOWN" , SC_OPCODE_ROUND_DOWN }, { "TRUNC" , SC_OPCODE_TRUNC }, { "LOG" , SC_OPCODE_LOG }, - { "POWER" , ocPowER }, + { "POWER" , SC_OPCODE_POWER }, { "GCD" , SC_OPCODE_GCD }, { "LCM" , SC_OPCODE_LCM }, { "MOD" , SC_OPCODE_MOD }, @@ -1196,7 +1196,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = { "CUMPRINC" , SC_OPCODE_CUM_PRINC }, { "EFFECTIVE" , SC_OPCODE_EFFECT }, { "NOMINAL" , SC_OPCODE_NOMINAL }, - { "SUBTOTAL" , ocSub_TOTAL }, + { "SUBTOTAL" , SC_OPCODE_SUB_TOTAL }, { "DSUM" , SC_OPCODE_DB_SUM }, { "DCOUNT" , SC_OPCODE_DB_COUNT }, { "DCOUNTA" , SC_OPCODE_DB_COUNT_2 }, @@ -1210,7 +1210,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = { "DVAR" , SC_OPCODE_DB_VAR }, { "DVARP" , SC_OPCODE_DB_VAR_P }, { "INDIRECT" , SC_OPCODE_INDIRECT }, - { "ADDRESS" , ocAddRESS }, + { "ADDRESS" , SC_OPCODE_ADDRESS }, { "MATCH" , SC_OPCODE_MATCH }, { "XMATCH" , SC_OPCODE_X_MATCH }, { "COUNTBLANK" , SC_OPCODE_COUNT_EMPTY_CELLS }, @@ -1240,10 +1240,10 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = { "TOCOL" , SC_OPCODE_TOCOL }, { "TOROW" , SC_OPCODE_TOROW }, { "UNIQUE" , SC_OPCODE_UNIQUE }, - { "LET" , ocLet }, + { "LET" , SC_OPCODE_LET }, { "WRAPCOLS" , SC_OPCODE_WRAPCOLS }, { "WRAPROWS" , SC_OPCODE_WRAPROWS }, - { "MULTIRANGE" , ocMulTI_AREA }, // legacy for range list (union) + { "MULTIRANGE" , SC_OPCODE_MULTI_AREA }, // legacy for range list (union) { "OFFSET" , SC_OPCODE_OFFSET }, { "INDEX" , SC_OPCODE_INDEX }, { "AREAS" , SC_OPCODE_AREAS }, @@ -1264,7 +1264,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = { "SEARCHB" , SC_OPCODE_SEARCHB }, { "MIDB" , SC_OPCODE_MIDB }, { "TEXT" , SC_OPCODE_TEXT }, - { "SUBSTITUTE" , ocSubSTITUTE }, + { "SUBSTITUTE" , SC_OPCODE_SUBSTITUTE }, { "REPT" , SC_OPCODE_REPT }, { "CONCATENATE" , SC_OPCODE_CONCAT }, { "CONCAT" , SC_OPCODE_CONCAT_MS }, @@ -1417,13 +1417,13 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = { "BITRSHIFT" , SC_OPCODE_BITRSHIFT }, { "BITLSHIFT" , SC_OPCODE_BITLSHIFT }, /* BEGIN defined ERROR.TYPE() values. */ - { "#NULL!" , ocErrNull }, - { "#DIV/0!" , ocErrDivZero }, - { "#VALUE!" , ocErrValue }, - { "#REF!" , ocErrRef }, - { "#NAME?" , ocErrName }, - { "#NUM!" , ocErrNum }, - { "#N/A" , ocErrNA }, + { "#NULL!" , SC_OPCODE_ERROR_NULL }, + { "#DIV/0!" , SC_OPCODE_ERROR_DIVZERO }, + { "#VALUE!" , SC_OPCODE_ERROR_VALUE }, + { "#REF!" , SC_OPCODE_ERROR_REF }, + { "#NAME?" , SC_OPCODE_ERROR_NAME }, + { "#NUM!" , SC_OPCODE_ERROR_NUM }, + { "#N/A" , SC_OPCODE_ERROR_NA }, /* END defined ERROR.TYPE() values. */ { "FILTERXML" , SC_OPCODE_FILTERXML }, { "WEBSERVICE" , SC_OPCODE_WEBSERVICE }, @@ -1448,46 +1448,46 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_PODF[] = // ScCompiler::IsOpCode(). const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = { - { "IF" , ocIf }, - { "IFERROR" , ocIfError }, - { "IFNA" , ocIfNA }, - { "CHOOSE" , ocChoose }, - { "(" , ocOpen }, - { ")" , ocClose }, - { "[" , ocTableRefOpen }, - { "]" , ocTableRefClose }, - { "#All" , ocTableRefItemAll }, - { "#Headers" , ocTableRefItemHeaders }, - { "#Data" , ocTableRefItemData }, - { "#Totals" , ocTableRefItemTotals }, - { "#This Row" , ocTableRefItemThisRow }, - { "{" , ocArrayOpen }, - { "}" , ocArrayClose }, - { "|" , ocArrayRowSep }, - { ";" , ocArrayColSep }, - { ";" , ocSep }, - { "%" , ocPercentSign }, - { "+" , ocAdd }, - { "-" , ocSub }, - { "*" , ocMul }, - { "/" , ocDiv }, - { "&" , ocAmpersand }, - { "^" , ocPow }, - { "=" , ocEqual }, - { "<>" , ocNotEqual }, - { "<" , ocLess }, - { ">" , ocGreater }, - { "<=" , ocLessEqual }, - { ">=" , ocGreaterEqual }, - { "AND" , ocAnd }, - { "OR" , ocOr }, - { "XOR" , ocXor }, - { "!" , ocIntersect }, - { "~" , ocUnion }, - { ":" , ocRange }, + { "IF" , SC_OPCODE_IF }, + { "IFERROR" , SC_OPCODE_IF_ERROR }, + { "IFNA" , SC_OPCODE_IF_NA }, + { "CHOOSE" , SC_OPCODE_CHOOSE }, + { "(" , SC_OPCODE_OPEN }, + { ")" , SC_OPCODE_CLOSE }, + { "[" , SC_OPCODE_TABLE_REF_OPEN }, + { "]" , SC_OPCODE_TABLE_REF_CLOSE }, + { "#All" , SC_OPCODE_TABLE_REF_ITEM_ALL }, + { "#Headers" , SC_OPCODE_TABLE_REF_ITEM_HEADERS }, + { "#Data" , SC_OPCODE_TABLE_REF_ITEM_DATA }, + { "#Totals" , SC_OPCODE_TABLE_REF_ITEM_TOTALS }, + { "#This Row" , SC_OPCODE_TABLE_REF_ITEM_THIS_ROW }, + { "{" , SC_OPCODE_ARRAY_OPEN }, + { "}" , SC_OPCODE_ARRAY_CLOSE }, + { "|" , SC_OPCODE_ARRAY_ROW_SEP }, + { ";" , SC_OPCODE_ARRAY_COL_SEP }, + { ";" , SC_OPCODE_SEP }, + { "%" , SC_OPCODE_PERCENT_SIGN }, + { "+" , SC_OPCODE_ADD }, + { "-" , SC_OPCODE_SUB }, + { "*" , SC_OPCODE_MUL }, + { "/" , SC_OPCODE_DIV }, + { "&" , SC_OPCODE_AMPERSAND }, + { "^" , SC_OPCODE_POW }, + { "=" , SC_OPCODE_EQUAL }, + { "<>" , SC_OPCODE_NOT_EQUAL }, + { "<" , SC_OPCODE_LESS }, + { ">" , SC_OPCODE_GREATER }, + { "<=" , SC_OPCODE_LESS_EQUAL }, + { ">=" , SC_OPCODE_GREATER_EQUAL }, + { "AND" , SC_OPCODE_AND }, + { "OR" , SC_OPCODE_OR }, + { "XOR" , SC_OPCODE_XOR }, + { "!" , SC_OPCODE_INTERSECT }, + { "~" , SC_OPCODE_UNION }, + { ":" , SC_OPCODE_RANGE }, { "NOT" , SC_OPCODE_NOT }, { "NEG" , SC_OPCODE_NEG }, - { "-" , ocNegSub }, + { "-" , SC_OPCODE_NEG_SUB }, { "PI" , SC_OPCODE_PI }, { "RAND" , SC_OPCODE_RANDOM }, { "TRUE" , SC_OPCODE_TRUE }, @@ -1593,7 +1593,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = { "ROUNDDOWN" , SC_OPCODE_ROUND_DOWN }, { "TRUNC" , SC_OPCODE_TRUNC }, { "LOG" , SC_OPCODE_LOG }, - { "POWER" , ocPowER }, + { "POWER" , SC_OPCODE_POWER }, { "GCD" , SC_OPCODE_GCD }, { "LCM" , SC_OPCODE_LCM }, { "MOD" , SC_OPCODE_MOD }, @@ -1670,7 +1670,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = { "CUMPRINC" , SC_OPCODE_CUM_PRINC }, { "EFFECTIVE" , SC_OPCODE_EFFECT }, { "NOMINAL" , SC_OPCODE_NOMINAL }, - { "SUBTOTAL" , ocSub_TOTAL }, + { "SUBTOTAL" , SC_OPCODE_SUB_TOTAL }, { "DSUM" , SC_OPCODE_DB_SUM }, { "DCOUNT" , SC_OPCODE_DB_COUNT }, { "DCOUNTA" , SC_OPCODE_DB_COUNT_2 }, @@ -1684,7 +1684,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = { "DVAR" , SC_OPCODE_DB_VAR }, { "DVARP" , SC_OPCODE_DB_VAR_P }, { "INDIRECT" , SC_OPCODE_INDIRECT }, - { "ADDRESS" , ocAddRESS }, + { "ADDRESS" , SC_OPCODE_ADDRESS }, { "MATCH" , SC_OPCODE_MATCH }, { "XMATCH" , SC_OPCODE_X_MATCH }, { "COUNTBLANK" , SC_OPCODE_COUNT_EMPTY_CELLS }, @@ -1714,10 +1714,10 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = { "TOCOL" , SC_OPCODE_TOCOL }, { "TOROW" , SC_OPCODE_TOROW }, { "UNIQUE" , SC_OPCODE_UNIQUE }, - { "LET" , ocLet }, + { "LET" , SC_OPCODE_LET }, { "WRAPCOLS" , SC_OPCODE_WRAPCOLS }, { "WRAPROWS" , SC_OPCODE_WRAPROWS }, - { "MULTIRANGE" , ocMulTI_AREA }, // legacy for range list (union) + { "MULTIRANGE" , SC_OPCODE_MULTI_AREA }, // legacy for range list (union) { "OFFSET" , SC_OPCODE_OFFSET }, { "INDEX" , SC_OPCODE_INDEX }, // ?? first character = I ?? { "AREAS" , SC_OPCODE_AREAS }, @@ -1738,7 +1738,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = { "SEARCHB" , SC_OPCODE_SEARCHB }, { "MIDB" , SC_OPCODE_MIDB }, { "TEXT" , SC_OPCODE_TEXT }, - { "SUBSTITUTE" , ocSubSTITUTE }, + { "SUBSTITUTE" , SC_OPCODE_SUBSTITUTE }, { "REPT" , SC_OPCODE_REPT }, { "CONCATENATE" , SC_OPCODE_CONCAT }, { "CONCAT" , SC_OPCODE_CONCAT_MS }, @@ -1890,13 +1890,13 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = { "BITXOR" , SC_OPCODE_BITXOR }, { "BITRSHIFT" , SC_OPCODE_BITRSHIFT }, { "BITLSHIFT" , SC_OPCODE_BITLSHIFT }, - { "#NULL!" , ocErrNull }, - { "#DIV/0!" , ocErrDivZero }, - { "#VALUE!" , ocErrValue }, - { "#REF!" , ocErrRef }, - { "#NAME?" , ocErrName }, - { "#NUM!" , ocErrNum }, - { "#N/A" , ocErrNA }, + { "#NULL!" , SC_OPCODE_ERROR_NULL }, + { "#DIV/0!" , SC_OPCODE_ERROR_DIVZERO }, + { "#VALUE!" , SC_OPCODE_ERROR_VALUE }, + { "#REF!" , SC_OPCODE_ERROR_REF }, + { "#NAME?" , SC_OPCODE_ERROR_NAME }, + { "#NUM!" , SC_OPCODE_ERROR_NUM }, + { "#N/A" , SC_OPCODE_ERROR_NA }, /* END defined ERROR.TYPE() values. */ { "FILTERXML" , SC_OPCODE_FILTERXML }, { "WEBSERVICE" , SC_OPCODE_WEBSERVICE }, @@ -1920,46 +1920,46 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH_API[] = // at the same time. const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = { - { "IF" , ocIf }, - { "IFERROR" , ocIfError }, - { "IFNA" , ocIfNA }, - { "CHOOSE" , ocChoose }, - { "(" , ocOpen }, - { ")" , ocClose }, - { "[" , ocTableRefOpen }, - { "]" , ocTableRefClose }, - { "#All" , ocTableRefItemAll }, - { "#Headers" , ocTableRefItemHeaders }, - { "#Data" , ocTableRefItemData }, - { "#Totals" , ocTableRefItemTotals }, - { "#This Row" , ocTableRefItemThisRow }, - { "{" , ocArrayOpen }, - { "}" , ocArrayClose }, - { "|" , ocArrayRowSep }, - { ";" , ocArrayColSep }, - { ";" , ocSep }, - { "%" , ocPercentSign }, - { "+" , ocAdd }, - { "-" , ocSub }, - { "*" , ocMul }, - { "/" , ocDiv }, - { "&" , ocAmpersand }, - { "^" , ocPow }, - { "=" , ocEqual }, - { "<>" , ocNotEqual }, - { "<" , ocLess }, - { ">" , ocGreater }, - { "<=" , ocLessEqual }, - { ">=" , ocGreaterEqual }, - { "AND" , ocAnd }, - { "OR" , ocOr }, - { "XOR" , ocXor }, - { "!" , ocIntersect }, - { "~" , ocUnion }, - { ":" , ocRange }, + { "IF" , SC_OPCODE_IF }, + { "IFERROR" , SC_OPCODE_IF_ERROR }, + { "IFNA" , SC_OPCODE_IF_NA }, + { "CHOOSE" , SC_OPCODE_CHOOSE }, + { "(" , SC_OPCODE_OPEN }, + { ")" , SC_OPCODE_CLOSE }, + { "[" , SC_OPCODE_TABLE_REF_OPEN }, + { "]" , SC_OPCODE_TABLE_REF_CLOSE }, + { "#All" , SC_OPCODE_TABLE_REF_ITEM_ALL }, + { "#Headers" , SC_OPCODE_TABLE_REF_ITEM_HEADERS }, + { "#Data" , SC_OPCODE_TABLE_REF_ITEM_DATA }, + { "#Totals" , SC_OPCODE_TABLE_REF_ITEM_TOTALS }, + { "#This Row" , SC_OPCODE_TABLE_REF_ITEM_THIS_ROW }, + { "{" , SC_OPCODE_ARRAY_OPEN }, + { "}" , SC_OPCODE_ARRAY_CLOSE }, + { "|" , SC_OPCODE_ARRAY_ROW_SEP }, + { ";" , SC_OPCODE_ARRAY_COL_SEP }, + { ";" , SC_OPCODE_SEP }, + { "%" , SC_OPCODE_PERCENT_SIGN }, + { "+" , SC_OPCODE_ADD }, + { "-" , SC_OPCODE_SUB }, + { "*" , SC_OPCODE_MUL }, + { "/" , SC_OPCODE_DIV }, + { "&" , SC_OPCODE_AMPERSAND }, + { "^" , SC_OPCODE_POW }, + { "=" , SC_OPCODE_EQUAL }, + { "<>" , SC_OPCODE_NOT_EQUAL }, + { "<" , SC_OPCODE_LESS }, + { ">" , SC_OPCODE_GREATER }, + { "<=" , SC_OPCODE_LESS_EQUAL }, + { ">=" , SC_OPCODE_GREATER_EQUAL }, + { "AND" , SC_OPCODE_AND }, + { "OR" , SC_OPCODE_OR }, + { "XOR" , SC_OPCODE_XOR }, + { "!" , SC_OPCODE_INTERSECT }, + { "~" , SC_OPCODE_UNION }, + { ":" , SC_OPCODE_RANGE }, { "NOT" , SC_OPCODE_NOT }, { "NEG" , SC_OPCODE_NEG }, - { "-" , ocNegSub }, + { "-" , SC_OPCODE_NEG_SUB }, { "PI" , SC_OPCODE_PI }, { "RAND" , SC_OPCODE_RANDOM }, { "TRUE" , SC_OPCODE_TRUE }, @@ -2065,7 +2065,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = { "ROUNDDOWN" , SC_OPCODE_ROUND_DOWN }, { "TRUNC" , SC_OPCODE_TRUNC }, { "LOG" , SC_OPCODE_LOG }, - { "POWER" , ocPowER }, + { "POWER" , SC_OPCODE_POWER }, { "GCD" , SC_OPCODE_GCD }, { "LCM" , SC_OPCODE_LCM }, { "MOD" , SC_OPCODE_MOD }, @@ -2142,7 +2142,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = { "CUMPRINC" , SC_OPCODE_CUM_PRINC }, { "EFFECT" , SC_OPCODE_EFFECT }, { "NOMINAL" , SC_OPCODE_NOMINAL }, - { "SUBTOTAL" , ocSub_TOTAL }, + { "SUBTOTAL" , SC_OPCODE_SUB_TOTAL }, { "DSUM" , SC_OPCODE_DB_SUM }, { "DCOUNT" , SC_OPCODE_DB_COUNT }, { "DCOUNTA" , SC_OPCODE_DB_COUNT_2 }, @@ -2156,7 +2156,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = { "DVAR" , SC_OPCODE_DB_VAR }, { "DVARP" , SC_OPCODE_DB_VAR_P }, { "INDIRECT" , SC_OPCODE_INDIRECT }, - { "ADDRESS" , ocAddRESS }, + { "ADDRESS" , SC_OPCODE_ADDRESS }, { "MATCH" , SC_OPCODE_MATCH }, { "XMATCH" , SC_OPCODE_X_MATCH }, { "COUNTBLANK" , SC_OPCODE_COUNT_EMPTY_CELLS }, @@ -2186,10 +2186,10 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = { "TOCOL" , SC_OPCODE_TOCOL }, { "TOROW" , SC_OPCODE_TOROW }, { "UNIQUE" , SC_OPCODE_UNIQUE }, - { "LET" , ocLet }, + { "LET" , SC_OPCODE_LET }, { "WRAPCOLS" , SC_OPCODE_WRAPCOLS }, { "WRAPROWS" , SC_OPCODE_WRAPROWS }, - { "MULTIRANGE" , ocMulTI_AREA }, + { "MULTIRANGE" , SC_OPCODE_MULTI_AREA }, { "OFFSET" , SC_OPCODE_OFFSET }, { "INDEX" , SC_OPCODE_INDEX }, { "AREAS" , SC_OPCODE_AREAS }, @@ -2210,7 +2210,7 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = { "SEARCHB" , SC_OPCODE_SEARCHB }, { "MIDB" , SC_OPCODE_MIDB }, { "TEXT" , SC_OPCODE_TEXT }, - { "SUBSTITUTE" , ocSubSTITUTE }, + { "SUBSTITUTE" , SC_OPCODE_SUBSTITUTE }, { "REPT" , SC_OPCODE_REPT }, { "CONCATENATE" , SC_OPCODE_CONCAT }, { "CONCAT" , SC_OPCODE_CONCAT_MS }, @@ -2362,13 +2362,13 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = { "BITXOR" , SC_OPCODE_BITXOR }, { "BITRSHIFT" , SC_OPCODE_BITRSHIFT }, { "BITLSHIFT" , SC_OPCODE_BITLSHIFT }, - { "#NULL!" , ocErrNull }, - { "#DIV/0!" , ocErrDivZero }, - { "#VALUE!" , ocErrValue }, - { "#REF!" , ocErrRef }, - { "#NAME?" , ocErrName }, - { "#NUM!" , ocErrNum }, - { "#N/A" , ocErrNA }, + { "#NULL!" , SC_OPCODE_ERROR_NULL }, + { "#DIV/0!" , SC_OPCODE_ERROR_DIVZERO }, + { "#VALUE!" , SC_OPCODE_ERROR_VALUE }, + { "#REF!" , SC_OPCODE_ERROR_REF }, + { "#NAME?" , SC_OPCODE_ERROR_NAME }, + { "#NUM!" , SC_OPCODE_ERROR_NUM }, + { "#N/A" , SC_OPCODE_ERROR_NA }, /* END defined ERROR.TYPE() values. */ { "FILTERXML" , SC_OPCODE_FILTERXML }, { "WEBSERVICE" , SC_OPCODE_WEBSERVICE }, @@ -2393,23 +2393,23 @@ const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_ENGLISH[] = */ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = { - { NC_("RID_STRLIST_FUNCTION_NAMES", "IF") , ocIf }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "IFERROR") , ocIfError }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "IFNA") , ocIfNA }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "CHOOSE") , ocChoose }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "IF") , SC_OPCODE_IF }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "IFERROR") , SC_OPCODE_IF_ERROR }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "IFNA") , SC_OPCODE_IF_NA }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "CHOOSE") , SC_OPCODE_CHOOSE }, /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#All") , ocTableRefItemAll }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#All") , SC_OPCODE_TABLE_REF_ITEM_ALL }, /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#Headers") , ocTableRefItemHeaders }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#Headers") , SC_OPCODE_TABLE_REF_ITEM_HEADERS }, /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#Data") , ocTableRefItemData }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#Data") , SC_OPCODE_TABLE_REF_ITEM_DATA }, /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#Totals") , ocTableRefItemTotals }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#Totals") , SC_OPCODE_TABLE_REF_ITEM_TOTALS }, /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#This Row") , ocTableRefItemThisRow }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "AND") , ocAnd }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "OR") , ocOr }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "XOR") , ocXor }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#This Row") , SC_OPCODE_TABLE_REF_ITEM_THIS_ROW }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "AND") , SC_OPCODE_AND }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "OR") , SC_OPCODE_OR }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "XOR") , SC_OPCODE_XOR }, { NC_("RID_STRLIST_FUNCTION_NAMES", "NOT") , SC_OPCODE_NOT }, { NC_("RID_STRLIST_FUNCTION_NAMES", "NEG") , SC_OPCODE_NEG }, { NC_("RID_STRLIST_FUNCTION_NAMES", "PI") , SC_OPCODE_PI }, // ??? @@ -2518,7 +2518,7 @@ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = { NC_("RID_STRLIST_FUNCTION_NAMES", "ROUNDDOWN") , SC_OPCODE_ROUND_DOWN }, { NC_("RID_STRLIST_FUNCTION_NAMES", "TRUNC") , SC_OPCODE_TRUNC }, { NC_("RID_STRLIST_FUNCTION_NAMES", "LOG") , SC_OPCODE_LOG }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "POWER") , ocPowER }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "POWER") , SC_OPCODE_POWER }, { NC_("RID_STRLIST_FUNCTION_NAMES", "GCD") , SC_OPCODE_GCD }, { NC_("RID_STRLIST_FUNCTION_NAMES", "LCM") , SC_OPCODE_LCM }, { NC_("RID_STRLIST_FUNCTION_NAMES", "MOD") , SC_OPCODE_MOD }, @@ -2595,7 +2595,7 @@ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = { NC_("RID_STRLIST_FUNCTION_NAMES", "CUMPRINC") , SC_OPCODE_CUM_PRINC }, { NC_("RID_STRLIST_FUNCTION_NAMES", "EFFECT") , SC_OPCODE_EFFECT }, { NC_("RID_STRLIST_FUNCTION_NAMES", "NOMINAL") , SC_OPCODE_NOMINAL }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "SUBTOTAL") , ocSub_TOTAL }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "SUBTOTAL") , SC_OPCODE_SUB_TOTAL }, { NC_("RID_STRLIST_FUNCTION_NAMES", "DSUM") , SC_OPCODE_DB_SUM }, { NC_("RID_STRLIST_FUNCTION_NAMES", "DCOUNT") , SC_OPCODE_DB_COUNT }, { NC_("RID_STRLIST_FUNCTION_NAMES", "DCOUNTA") , SC_OPCODE_DB_COUNT_2 }, @@ -2609,7 +2609,7 @@ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = { NC_("RID_STRLIST_FUNCTION_NAMES", "DVAR") , SC_OPCODE_DB_VAR }, { NC_("RID_STRLIST_FUNCTION_NAMES", "DVARP") , SC_OPCODE_DB_VAR_P }, { NC_("RID_STRLIST_FUNCTION_NAMES", "INDIRECT") , SC_OPCODE_INDIRECT }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "ADDRESS") , ocAddRESS }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "ADDRESS") , SC_OPCODE_ADDRESS }, { NC_("RID_STRLIST_FUNCTION_NAMES", "MATCH") , SC_OPCODE_MATCH }, { NC_("RID_STRLIST_FUNCTION_NAMES", "XMATCH") , SC_OPCODE_X_MATCH }, { NC_("RID_STRLIST_FUNCTION_NAMES", "COUNTBLANK") , SC_OPCODE_COUNT_EMPTY_CELLS }, @@ -2639,10 +2639,10 @@ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = { NC_("RID_STRLIST_FUNCTION_NAMES", "TOCOL") , SC_OPCODE_TOCOL }, { NC_("RID_STRLIST_FUNCTION_NAMES", "TOROW") , SC_OPCODE_TOROW }, { NC_("RID_STRLIST_FUNCTION_NAMES", "UNIQUE") , SC_OPCODE_UNIQUE }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "LET") , ocLet }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "LET") , SC_OPCODE_LET }, { NC_("RID_STRLIST_FUNCTION_NAMES", "WRAPCOLS") , SC_OPCODE_WRAPCOLS }, { NC_("RID_STRLIST_FUNCTION_NAMES", "WRAPROWS") , SC_OPCODE_WRAPROWS }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "MULTIRANGE") , ocMulTI_AREA }, // legacy for range list (union) + { NC_("RID_STRLIST_FUNCTION_NAMES", "MULTIRANGE") , SC_OPCODE_MULTI_AREA }, // legacy for range list (union) { NC_("RID_STRLIST_FUNCTION_NAMES", "OFFSET") , SC_OPCODE_OFFSET }, { NC_("RID_STRLIST_FUNCTION_NAMES", "INDEX") , SC_OPCODE_INDEX }, // ?? first character = I ?? { NC_("RID_STRLIST_FUNCTION_NAMES", "AREAS") , SC_OPCODE_AREAS }, @@ -2661,7 +2661,7 @@ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = { NC_("RID_STRLIST_FUNCTION_NAMES", "REPLACEB") , SC_OPCODE_REPLACEB }, { NC_("RID_STRLIST_FUNCTION_NAMES", "MIDB") , SC_OPCODE_MIDB }, { NC_("RID_STRLIST_FUNCTION_NAMES", "TEXT") , SC_OPCODE_TEXT }, - { NC_("RID_STRLIST_FUNCTION_NAMES", "SUBSTITUTE") , ocSubSTITUTE }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "SUBSTITUTE") , SC_OPCODE_SUBSTITUTE }, { NC_("RID_STRLIST_FUNCTION_NAMES", "REPT") , SC_OPCODE_REPT }, { NC_("RID_STRLIST_FUNCTION_NAMES", "CONCATENATE") , SC_OPCODE_CONCAT }, { NC_("RID_STRLIST_FUNCTION_NAMES", "CONCAT") , SC_OPCODE_CONCAT_MS }, @@ -2816,25 +2816,25 @@ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = /* BEGIN defined ERROR.TYPE() values. */ /* ERROR.TYPE( #NULL! ) == 1 */ /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#NULL!") , ocErrNull }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#NULL!") , SC_OPCODE_ERROR_NULL }, /* ERROR.TYPE( #DIV/0! ) == 2 */ /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#DIV/0!") , ocErrDivZero }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#DIV/0!") , SC_OPCODE_ERROR_DIVZERO }, /* ERROR.TYPE( #VALUE! ) == 3 */ /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#VALUE!") , ocErrValue }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#VALUE!") , SC_OPCODE_ERROR_VALUE }, /* ERROR.TYPE( #REF! ) == 4 */ /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#REF!") , ocErrRef }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#REF!") , SC_OPCODE_ERROR_REF }, /* ERROR.TYPE( #NAME! ) == 5 */ /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#NAME?") , ocErrName }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#NAME?") , SC_OPCODE_ERROR_NAME }, /* ERROR.TYPE( #NUM! ) == 6 */ /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#NUM!") , ocErrNum }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#NUM!") , SC_OPCODE_ERROR_NUM }, /* ERROR.TYPE( #N/A ) == 7 */ /* L10n: preserve the leading '#' hash character in translations. */ - { NC_("RID_STRLIST_FUNCTION_NAMES", "#N/A") , ocErrNA }, + { NC_("RID_STRLIST_FUNCTION_NAMES", "#N/A") , SC_OPCODE_ERROR_NA }, /* END defined ERROR.TYPE() values. */ { NC_("RID_STRLIST_FUNCTION_NAMES", "FILTERXML") , SC_OPCODE_FILTERXML }, @@ -2858,32 +2858,32 @@ const std::pair<TranslateId, int> RID_STRLIST_FUNCTION_NAMES[] = const std::pair<const char *, int> RID_STRLIST_FUNCTION_NAMES_SYMBOLS[] = { - { "(" , ocOpen }, - { ")" , ocClose }, - { "[" , ocTableRefOpen }, - { "]" , ocTableRefClose }, - { "{" , ocArrayOpen }, - { "}" , ocArrayClose }, - { "|" , ocArrayRowSep }, - { ";" , ocArrayColSep }, - { ";" , ocSep }, - { "%" , ocPercentSign }, - { "+" , ocAdd }, - { "-" , ocSub }, - { "*" , ocMul }, - { "/" , ocDiv }, - { "&" , ocAmpersand }, - { "^" , ocPow }, - { "=" , ocEqual }, - { "<>" , ocNotEqual }, - { "<" , ocLess }, - { ">" , ocGreater }, - { "<=" , ocLessEqual }, - { ">=" , ocGreaterEqual }, - { "!" , ocIntersect }, - { "~" , ocUnion }, - { ":" , ocRange }, - { "-" , ocNegSub }, + { "(" , SC_OPCODE_OPEN }, + { ")" , SC_OPCODE_CLOSE }, + { "[" , SC_OPCODE_TABLE_REF_OPEN }, + { "]" , SC_OPCODE_TABLE_REF_CLOSE }, + { "{" , SC_OPCODE_ARRAY_OPEN }, + { "}" , SC_OPCODE_ARRAY_CLOSE }, + { "|" , SC_OPCODE_ARRAY_ROW_SEP }, + { ";" , SC_OPCODE_ARRAY_COL_SEP }, + { ";" , SC_OPCODE_SEP }, + { "%" , SC_OPCODE_PERCENT_SIGN }, + { "+" , SC_OPCODE_ADD }, + { "-" , SC_OPCODE_SUB }, + { "*" , SC_OPCODE_MUL }, + { "/" , SC_OPCODE_DIV }, + { "&" , SC_OPCODE_AMPERSAND }, + { "^" , SC_OPCODE_POW }, + { "=" , SC_OPCODE_EQUAL }, + { "<>" , SC_OPCODE_NOT_EQUAL }, + { "<" , SC_OPCODE_LESS }, + { ">" , SC_OPCODE_GREATER }, + { "<=" , SC_OPCODE_LESS_EQUAL }, + { ">=" , SC_OPCODE_GREATER_EQUAL }, + { "!" , SC_OPCODE_INTERSECT }, + { "~" , SC_OPCODE_UNION }, + { ":" , SC_OPCODE_RANGE }, + { "-" , SC_OPCODE_NEG_SUB }, { nullptr, -1 } }; diff --git a/formula/source/core/api/FormulaCompiler.cxx b/formula/source/core/api/FormulaCompiler.cxx index 91215d5bf42c..d1708115abbb 100644 --- a/formula/source/core/api/FormulaCompiler.cxx +++ b/formula/source/core/api/FormulaCompiler.cxx @@ -231,7 +231,7 @@ bool OpCodeList::getOpCodeString( OUString& rStr, sal_uInt16 nOp ) { switch (nOp) { - case ocSep: + case SC_OPCODE_SEP: { if (meSepType == FormulaCompiler::SeparatorType::SEMICOLON_BASE) { @@ -240,7 +240,7 @@ bool OpCodeList::getOpCodeString( OUString& rStr, sal_uInt16 nOp ) } } break; - case ocArrayColSep: + case SC_OPCODE_ARRAY_COL_SEP: { if (meSepType == FormulaCompiler::SeparatorType::SEMICOLON_BASE) { @@ -249,7 +249,7 @@ bool OpCodeList::getOpCodeString( OUString& rStr, sal_uInt16 nOp ) } } break; - case ocArrayRowSep: + case SC_OPCODE_ARRAY_ROW_SEP: { if (meSepType == FormulaCompiler::SeparatorType::SEMICOLON_BASE) { @@ -565,19 +565,19 @@ uno::Sequence< sheet::FormulaOpCodeMapEntry > FormulaCompiler::OpCodeMap::create if ((nGroups & FormulaMapGroup::SEPARATORS) != 0) { static const sal_uInt16 aOpCodes[] = { - ocOpen, - ocClose, - ocSep, + SC_OPCODE_OPEN, + SC_OPCODE_CLOSE, + SC_OPCODE_SEP, }; lclPushOpCodeMapEntries( aVec, mpTable.get(), aOpCodes, std::size(aOpCodes) ); } if ((nGroups & FormulaMapGroup::ARRAY_SEPARATORS) != 0) { static const sal_uInt16 aOpCodes[] = { - ocArrayOpen, - ocArrayClose, - ocArrayRowSep, - ocArrayColSep + SC_OPCODE_ARRAY_OPEN, + SC_OPCODE_ARRAY_CLOSE, + SC_OPCODE_ARRAY_ROW_SEP, + SC_OPCODE_ARRAY_COL_SEP }; lclPushOpCodeMapEntries( aVec, mpTable.get(), aOpCodes, std::size(aOpCodes) ); } @@ -590,21 +590,21 @@ uno::Sequence< sheet::FormulaOpCodeMapEntry > FormulaCompiler::OpCodeMap::create if ((nGroups & FormulaMapGroup::BINARY_OPERATORS) == 0) lclPushOpCodeMapEntry( aVec, mpTable.get(), ocAdd ); // regular unary operators - for (sal_uInt16 nOp = ocStartUnaryOp; nOp < ocStopUnaryOp && nOp < mnSymbols; ++nOp) + for (sal_uInt16 nOp = SC_OPCODE_START_UN_OP; nOp < SC_OPCODE_STOP_UN_OP && nOp < mnSymbols; ++nOp) { lclPushOpCodeMapEntry( aVec, mpTable.get(), nOp ); } } if ((nGroups & FormulaMapGroup::BINARY_OPERATORS) != 0) { - for (sal_uInt16 nOp = ocStartBinOp; nOp < ocStopBinOp && nOp < mnSymbols; ++nOp) + for (sal_uInt16 nOp = SC_OPCODE_START_BIN_OP; nOp < SC_OPCODE_STOP_BIN_OP && nOp < mnSymbols; ++nOp) { switch (nOp) { // AND and OR in fact are functions but for legacy reasons // are sorted into binary operators for compiler interna. - case ocAnd : - case ocOr : + case SC_OPCODE_AND : + case SC_OPCODE_OR : break; // nothing, default: lclPushOpCodeMapEntry( aVec, mpTable.get(), nOp ); @@ -621,13 +621,13 @@ uno::Sequence< sheet::FormulaOpCodeMapEntry > FormulaCompiler::OpCodeMap::create ::std::min< sal_uInt16 >( SC_OPCODE_STOP_1_PAR, mnSymbols ) ); // Additional functions not within range of functions. static const sal_uInt16 aOpCodes[] = { - ocIf, - ocIfError, - ocIfNA, - ocChoose, - ocLet, - ocAnd, - ocOr + SC_OPCODE_IF, + SC_OPCODE_IF_ERROR, + SC_OPCODE_IF_NA, + SC_OPCODE_CHOOSE, + SC_OPCODE_LET, + SC_OPCODE_AND, + SC_OPCODE_OR }; lclPushOpCodeMapEntries( aVec, mpTable.get(), aOpCodes, std::size(aOpCodes) ); // functions with 2 or more parameters. @@ -2194,8 +2194,8 @@ void FormulaCompiler::UnaryLine() { if( mpToken->GetOpCode() == ocAdd ) GetToken(); - else if (ocStartUnaryOp <= mpToken->GetOpCode() && - mpToken->GetOpCode() < ocStopUnaryOp) + else if (SC_OPCODE_START_UN_OP <= mpToken->GetOpCode() && + mpToken->GetOpCode() < SC_OPCODE_STOP_UN_OP) { FormulaTokenRef p = mpToken; NextToken(); @@ -2862,11 +2862,11 @@ OpCode FormulaCompiler::NextToken() // There must be an operator before a push if ( (eOp == ocPush || eOp == ocColRowNameAuto) && !( (eLastOp == ocOpen) || (eLastOp == ocSep) || - (ocStartBinOp <= eLastOp && eLastOp < ocStopUnaryOp)) ) + (SC_OPCODE_START_BIN_OP <= eLastOp && eLastOp < SC_OPCODE_STOP_UN_OP)) ) SetError( FormulaError::OperatorExpected); // Operator and Plus => operator if (eOp == ocAdd && (eLastOp == ocOpen || eLastOp == ocSep || - (ocStartBinOp <= eLastOp && eLastOp < ocStopUnaryOp))) + (SC_OPCODE_START_BIN_OP <= eLastOp && eLastOp < SC_OPCODE_STOP_UN_OP))) { FormulaCompilerRecursionGuard aRecursionGuard( nRecursion ); eOp = NextToken(); @@ -2876,9 +2876,9 @@ OpCode FormulaCompiler::NextToken() // Before an operator there must not be another operator, with the // exception of AND and OR. if ( eOp != ocAnd && eOp != ocOr && - (ocStartBinOp <= eOp && eOp < ocStopBinOp ) + (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP ) && (eLastOp == ocOpen || eLastOp == ocSep || - (ocStartBinOp <= eLastOp && eLastOp < ocStopUnaryOp))) + (SC_OPCODE_START_BIN_OP <= eLastOp && eLastOp < SC_OPCODE_STOP_UN_OP))) { SetError( FormulaError::VariableExpected); if ( bAutoCorrect && !pStack ) @@ -3121,7 +3121,7 @@ void FormulaCompiler::ForceArrayOperator( FormulaTokenRef const & rCurr ) // below. rCurr->SetInForceArray( ParamClass::ForceArray); } - else if (pc >= 2 && ocStartBinOp <= eOp && eOp < ocStopBinOp) + else if (pc >= 2 && SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP) { // Binary operators are not functions followed by arguments // and need some peeking into RPN to inspect their operands. @@ -3148,7 +3148,7 @@ void FormulaCompiler::ForceArrayOperator( FormulaTokenRef const & rCurr ) rCurr->SetInForceArray( eArrayReturn); } } - else if (pc >= 1 && ocStartUnaryOp <= eOp && eOp < ocStopUnaryOp) + else if (pc >= 1 && SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP) { // Similar for unary operators. if (pCode[-1]->GetInForceArray() != ParamClass::Unknown || IsMatrixFunction(pCode[-1]->GetOpCode())) diff --git a/formula/source/core/api/token.cxx b/formula/source/core/api/token.cxx index d413d29d4b7c..ceebc87e9ec5 100644 --- a/formula/source/core/api/token.cxx +++ b/formula/source/core/api/token.cxx @@ -88,7 +88,7 @@ bool FormulaToken::IsFunction() const sal_uInt8 FormulaToken::GetParamCount() const { - if ( eOp < ocStopDiv && eOp != ocExternal && eOp != ocMacro && + if ( eOp < SC_OPCODE_STOP_DIV && eOp != ocExternal && eOp != ocMacro && !FormulaCompiler::IsOpCodeJumpCommand( eOp ) && eOp != ocPercentSign ) return 0; // parameters and specials @@ -96,9 +96,9 @@ sal_uInt8 FormulaToken::GetParamCount() const //2do: bool parameter whether FAP or not? else if (GetByte()) return GetByte(); // all functions, also ocExternal and ocMacro - else if (ocStartBinOp <= eOp && eOp < ocStopBinOp && eOp != ocAnd && eOp != ocOr) + else if (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP && eOp != ocAnd && eOp != ocOr) return 2; // binary operators, compiler checked; OR and AND legacy but are functions - else if ((ocStartUnaryOp <= eOp && eOp < ocStopUnaryOp) || eOp == ocPercentSign) + else if ((SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP) || eOp == ocPercentSign) return 1; // unary operators, compiler checked else if (SC_OPCODE_START_NO_PAR <= eOp && eOp < SC_OPCODE_STOP_NO_PAR) return 0; // no parameter @@ -1624,9 +1624,9 @@ bool FormulaTokenArray::MayReferenceFollow() if (i > 0 || !isWhitespace( pCode[i]->GetOpCode())) { OpCode eOp = pCode[i]->GetOpCode(); - if ( (ocStartBinOp <= eOp && eOp < ocStopBinOp ) || - (ocStartUnaryOp <= eOp && eOp < ocStopUnaryOp ) || - eOp == ocOpen || eOp == ocSep ) + if ( (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP ) || + (SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP ) || + eOp == SC_OPCODE_OPEN || eOp == SC_OPCODE_SEP ) { return true; } diff --git a/formula/source/ui/dlg/formula.cxx b/formula/source/ui/dlg/formula.cxx index c76fd76af656..c569de51832b 100644 --- a/formula/source/ui/dlg/formula.cxx +++ b/formula/source/ui/dlg/formula.cxx @@ -630,8 +630,8 @@ void FormulaDlg_Impl::MakeTree(StructPage* _pTree, weld::TreeIter* pParent, cons { _pTree->InsertEntry(aResult, pParent, StructType::Error, 0, _pToken, *xEntry); } - else if (!((ocStartBinOp <= eOp && eOp < ocStopBinOp) || - (ocStartUnaryOp <= eOp && eOp < ocStopUnaryOp))) + else if (!((SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP) || + (SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP))) { // Not a binary or unary operator. bCalcSubformula = true; diff --git a/include/formula/compiler.hxx b/include/formula/compiler.hxx index d487cecce77f..2ac73403f5de 100644 --- a/include/formula/compiler.hxx +++ b/include/formula/compiler.hxx @@ -19,6 +19,89 @@ #pragma once +/* Central definition of OpCodes for spreadsheet functions */ + +/*** Special commands ***/ +#define SC_OPCODE_PUSH 0 /* internal commands */ +// used to be SC_OPCODE_CALL +#define SC_OPCODE_STOP 2 +#define SC_OPCODE_EXTERNAL 3 +#define SC_OPCODE_NAME 4 +#define SC_OPCODE_EXTERNAL_REF 5 +#define SC_OPCODE_IF 6 /* jump commands */ +#define SC_OPCODE_IF_ERROR 7 +#define SC_OPCODE_IF_NA 8 +#define SC_OPCODE_CHOOSE 9 +#define SC_OPCODE_OPEN 10 /* parentheses and separators */ +#define SC_OPCODE_CLOSE 11 +#define SC_OPCODE_SEP 12 +#define SC_OPCODE_MISSING 13 /* special OpCodes */ +#define SC_OPCODE_BAD 14 +#define SC_OPCODE_STRINGXML 15 +#define SC_OPCODE_SPACES 16 +#define SC_OPCODE_WHITESPACE 17 +#define SC_OPCODE_MAT_REF 18 +#define SC_OPCODE_DB_AREA 19 /* additional access operators */ +#define SC_OPCODE_TABLE_REF 20 +#define SC_OPCODE_MACRO 21 +#define SC_OPCODE_COL_ROW_NAME 22 +#define SC_OPCODE_COL_ROW_NAME_AUTO 23 +#define SC_OPCODE_PERCENT_SIGN 24 /* operator _follows_ value */ +#define SC_OPCODE_ARRAY_OPEN 25 +#define SC_OPCODE_ARRAY_CLOSE 26 +#define SC_OPCODE_ARRAY_ROW_SEP 27 +#define SC_OPCODE_ARRAY_COL_SEP 28 /* some convs use sep != col_sep */ +#define SC_OPCODE_TABLE_REF_OPEN 29 +#define SC_OPCODE_TABLE_REF_CLOSE 30 +#define SC_OPCODE_TABLE_REF_ITEM_ALL 31 +#define SC_OPCODE_TABLE_REF_ITEM_HEADERS 32 +#define SC_OPCODE_TABLE_REF_ITEM_DATA 33 +#define SC_OPCODE_TABLE_REF_ITEM_TOTALS 34 +#define SC_OPCODE_TABLE_REF_ITEM_THIS_ROW 35 +#define SC_OPCODE_STOP_DIV 36 +#define SC_OPCODE_SKIP 37 /* used to skip raw tokens during string compilation */ +#define SC_OPCODE_STRINGNAME 38 /* special OpCode for lambda function names */ +#define SC_OPCODE_LET 39 + +/*** error constants #... ***/ +#define SC_OPCODE_START_ERRORS 40 +#define SC_OPCODE_ERROR_NULL 40 +#define SC_OPCODE_ERROR_DIVZERO 41 +#define SC_OPCODE_ERROR_VALUE 42 +#define SC_OPCODE_ERROR_REF 43 +#define SC_OPCODE_ERROR_NAME 44 +#define SC_OPCODE_ERROR_NUM 45 +#define SC_OPCODE_ERROR_NA 46 +#define SC_OPCODE_STOP_ERRORS 47 + +/*** Binary operators ***/ +#define SC_OPCODE_START_BIN_OP 50 +#define SC_OPCODE_ADD 50 +#define SC_OPCODE_SUB 51 +#define SC_OPCODE_MUL 52 +#define SC_OPCODE_DIV 53 +#define SC_OPCODE_AMPERSAND 54 +#define SC_OPCODE_POW 55 +#define SC_OPCODE_EQUAL 56 +#define SC_OPCODE_NOT_EQUAL 57 +#define SC_OPCODE_LESS 58 +#define SC_OPCODE_GREATER 59 +#define SC_OPCODE_LESS_EQUAL 60 +#define SC_OPCODE_GREATER_EQUAL 61 +#define SC_OPCODE_AND 62 +#define SC_OPCODE_OR 63 +#define SC_OPCODE_INTERSECT 64 +#define SC_OPCODE_UNION 65 +#define SC_OPCODE_RANGE 66 +#define SC_OPCODE_STOP_BIN_OP 67 + +/* NOTE: binary and unary operators must be in sequence for compiler! */ + +/*** Unary operators ***/ +#define SC_OPCODE_START_UN_OP 70 +#define SC_OPCODE_NEG_SUB 70 +#define SC_OPCODE_STOP_UN_OP 71 + #define SC_OPCODE_START_FUNCTION 75 /*** Functions without parameters ***/ @@ -137,7 +220,7 @@ #define SC_OPCODE_ROUND_DOWN 206 #define SC_OPCODE_TRUNC 207 #define SC_OPCODE_LOG 208 -#define ocPowER 209 +#define SC_OPCODE_POWER 209 #define SC_OPCODE_GCD 210 #define SC_OPCODE_LCM 211 #define SC_OPCODE_MOD 212 @@ -194,7 +277,7 @@ #define SC_OPCODE_CUM_PRINC 263 #define SC_OPCODE_EFFECT 264 #define SC_OPCODE_NOMINAL 265 -#define ocSub_TOTAL 266 +#define SC_OPCODE_SUB_TOTAL 266 #define SC_OPCODE_DB_SUM 267 /* database functions */ #define SC_OPCODE_DB_COUNT 268 #define SC_OPCODE_DB_COUNT_2 269 @@ -208,7 +291,7 @@ #define SC_OPCODE_DB_VAR 277 #define SC_OPCODE_DB_VAR_P 278 #define SC_OPCODE_INDIRECT 279 /* management functions */ -#define ocAddRESS 280 +#define SC_OPCODE_ADDRESS 280 #define SC_OPCODE_MATCH 281 #define SC_OPCODE_COUNT_EMPTY_CELLS 282 #define SC_OPCODE_COUNT_IF 283 @@ -216,7 +299,7 @@ #define SC_OPCODE_LOOKUP 285 #define SC_OPCODE_V_LOOKUP 286 #define SC_OPCODE_H_LOOKUP 287 -#define ocMulTI_AREA 288 +#define SC_OPCODE_MULTI_AREA 288 #define SC_OPCODE_OFFSET 289 #define SC_OPCODE_INDEX 290 #define SC_OPCODE_AREAS 291 @@ -230,7 +313,7 @@ #define SC_OPCODE_SEARCH 299 #define SC_OPCODE_MID 300 #define SC_OPCODE_TEXT 301 -#define ocSubSTITUTE 302 +#define SC_OPCODE_SUBSTITUTE 302 #define SC_OPCODE_REPT 303 #define SC_OPCODE_CONCAT 304 #define SC_OPCODE_MAT_VALUE 305 /* matrix functions */ @@ -329,6 +412,7 @@ #define SC_OPCODE_BITRSHIFT 398 #define SC_OPCODE_BITLSHIFT 399 #define SC_OPCODE_GET_DATEDIF 400 +#define SC_OPCODE_XOR 401 #define SC_OPCODE_AVERAGE_IF 402 #define SC_OPCODE_SUM_IFS 403 #define SC_OPCODE_AVERAGE_IFS 404 diff --git a/include/formula/opcode.hxx b/include/formula/opcode.hxx index 907c9c77f081..6905790278a9 100644 --- a/include/formula/opcode.hxx +++ b/include/formula/opcode.hxx @@ -24,90 +24,80 @@ #include <formula/compiler.hxx> #include <sal/types.h> -/* Central definition of OpCodes for spreadsheet functions */ - enum OpCode : sal_uInt16 { // Special commands - ocPush = 0, - // 1 used to be ocCall - ocStop = 2, - ocExternal = 3, - ocName = 4, - // 5 is externalRef + ocPush = SC_OPCODE_PUSH, + ocStop = SC_OPCODE_STOP, + ocExternal = SC_OPCODE_EXTERNAL, + ocName = SC_OPCODE_NAME, // Jump commands - ocIf = 6, - ocIfError = 7, - ocIfNA = 8, - ocChoose = 9, - ocLet = 39, + ocIf = SC_OPCODE_IF, + ocIfError = SC_OPCODE_IF_ERROR, + ocIfNA = SC_OPCODE_IF_NA, + ocChoose = SC_OPCODE_CHOOSE, + ocLet = SC_OPCODE_LET, // Parentheses and separators - ocOpen = 10, - ocClose = 11, - ocTableRefOpen = 29, - ocTableRefClose = 30, - ocSep = 12, - ocArrayOpen = 25, - ocArrayClose = 26, - ocArrayRowSep = 27, - ocArrayColSep = 28, /* some convs use sep != col_sep */ + ocOpen = SC_OPCODE_OPEN, + ocClose = SC_OPCODE_CLOSE, + ocTableRefOpen = SC_OPCODE_TABLE_REF_OPEN, + ocTableRefClose = SC_OPCODE_TABLE_REF_CLOSE, + ocSep = SC_OPCODE_SEP, + ocArrayOpen = SC_OPCODE_ARRAY_OPEN, + ocArrayClose = SC_OPCODE_ARRAY_CLOSE, + ocArrayRowSep = SC_OPCODE_ARRAY_ROW_SEP, + ocArrayColSep = SC_OPCODE_ARRAY_COL_SEP, // Special OpCodes - ocMissing = 13, - ocBad = 14, - ocStringXML = 15, - ocSpaces = 16, - ocWhitespace = 17, - ocMatRef = 18, - ocTableRefItemAll = 31, - ocTableRefItemHeaders = 32, - ocTableRefItemData = 33, - ocTableRefItemTotals = 34, - ocTableRefItemThisRow = 35, - ocStopDiv = 36, - ocSkip = 37, /* used to skip raw tokens during string compilation */ - ocStringName = 38, /* special OpCode for lambda function names */ + ocMissing = SC_OPCODE_MISSING, + ocBad = SC_OPCODE_BAD, + ocStringXML = SC_OPCODE_STRINGXML, + ocSpaces = SC_OPCODE_SPACES, + ocWhitespace = SC_OPCODE_WHITESPACE, + ocMatRef = SC_OPCODE_MAT_REF, + ocTableRefItemAll = SC_OPCODE_TABLE_REF_ITEM_ALL, + ocTableRefItemHeaders = SC_OPCODE_TABLE_REF_ITEM_HEADERS, + ocTableRefItemData = SC_OPCODE_TABLE_REF_ITEM_DATA, + ocTableRefItemTotals = SC_OPCODE_TABLE_REF_ITEM_TOTALS, + ocTableRefItemThisRow = SC_OPCODE_TABLE_REF_ITEM_THIS_ROW, + ocSkip = SC_OPCODE_SKIP, + ocStringName = SC_OPCODE_STRINGNAME, // Access commands - ocDBArea = 19, - ocTableRef = 20, - ocMacro = 21, - ocColRowName = 22, - ocColRowNameAuto = 23, + ocDBArea = SC_OPCODE_DB_AREA, + ocTableRef = SC_OPCODE_TABLE_REF, + ocMacro = SC_OPCODE_MACRO, + ocColRowName = SC_OPCODE_COL_ROW_NAME, + ocColRowNameAuto = SC_OPCODE_COL_ROW_NAME_AUTO, // Percent operator _follows_ value - ocPercentSign = 24, + ocPercentSign = SC_OPCODE_PERCENT_SIGN, // Error constants - ocErrNull = 40, - ocErrDivZero = 41, - ocErrValue = 42, - ocErrRef = 43, - ocErrName = 44, - ocErrNum = 45, - ocErrNA = 46, - /* NOTE: binary and unary operators must be in sequence for compiler! */ + ocErrNull = SC_OPCODE_ERROR_NULL, + ocErrDivZero = SC_OPCODE_ERROR_DIVZERO, + ocErrValue = SC_OPCODE_ERROR_VALUE, + ocErrRef = SC_OPCODE_ERROR_REF, + ocErrName = SC_OPCODE_ERROR_NAME, + ocErrNum = SC_OPCODE_ERROR_NUM, + ocErrNA = SC_OPCODE_ERROR_NA, // Binary operators - ocStartBinOp = 50, - ocAdd = 50, - ocSub = 51, - ocMul = 52, - ocDiv = 53, - ocAmpersand = 54, - ocPow = 55, - ocEqual = 56, - ocNotEqual = 57, - ocLess = 58, - ocGreater = 59, - ocLessEqual = 60, - ocGreaterEqual = 61, - ocAnd = 62, - ocOr = 63, - ocXor = 401, - ocIntersect = 64, - ocUnion = 65, - ocRange = 66, - ocStopBinOp = 67, + ocAdd = SC_OPCODE_ADD, + ocSub = SC_OPCODE_SUB, + ocMul = SC_OPCODE_MUL, + ocDiv = SC_OPCODE_DIV, + ocAmpersand = SC_OPCODE_AMPERSAND, + ocPow = SC_OPCODE_POW, + ocEqual = SC_OPCODE_EQUAL, + ocNotEqual = SC_OPCODE_NOT_EQUAL, + ocLess = SC_OPCODE_LESS, + ocGreater = SC_OPCODE_GREATER, + ocLessEqual = SC_OPCODE_LESS_EQUAL, + ocGreaterEqual = SC_OPCODE_GREATER_EQUAL, + ocAnd = SC_OPCODE_AND, + ocOr = SC_OPCODE_OR, + ocXor = SC_OPCODE_XOR, + ocIntersect = SC_OPCODE_INTERSECT, + ocUnion = SC_OPCODE_UNION, + ocRange = SC_OPCODE_RANGE, // Unary operators - ocStartUnaryOp = 70, - ocNegSub = 70, - ocStopUnaryOp = 71, + ocNegSub = SC_OPCODE_NEG_SUB, // Functions with no parameters ocPi = SC_OPCODE_PI, ocRandom = SC_OPCODE_RANDOM, @@ -224,7 +214,7 @@ enum OpCode : sal_uInt16 ocRoundDown = SC_OPCODE_ROUND_DOWN, ocTrunc = SC_OPCODE_TRUNC, ocLog = SC_OPCODE_LOG, - ocPower = ocPowER, + ocPower = SC_OPCODE_POWER, ocGCD = SC_OPCODE_GCD, ocLCM = SC_OPCODE_LCM, ocMod = SC_OPCODE_MOD, @@ -293,7 +283,7 @@ enum OpCode : sal_uInt16 ocCumPrinc = SC_OPCODE_CUM_PRINC, ocEffect = SC_OPCODE_EFFECT, ocNominal = SC_OPCODE_NOMINAL, - ocSubTotal = ocSub_TOTAL, + ocSubTotal = SC_OPCODE_SUB_TOTAL, ocRawSubtract = SC_OPCODE_RAWSUBTRACT, ocIfs_MS = SC_OPCODE_IFS_MS, ocSwitch_MS = SC_OPCODE_SWITCH_MS, @@ -315,7 +305,7 @@ enum OpCode : sal_uInt16 ocDBVarP = SC_OPCODE_DB_VAR_P, // Management functions ocIndirect = SC_OPCODE_INDIRECT, - ocAddress = ocAddRESS, + ocAddress = SC_OPCODE_ADDRESS, ocMatch = SC_OPCODE_MATCH, ocXMatch = SC_OPCODE_X_MATCH, ocCountEmptyCells = SC_OPCODE_COUNT_EMPTY_CELLS, @@ -329,7 +319,7 @@ enum OpCode : sal_uInt16 ocVLookup = SC_OPCODE_V_LOOKUP, ocXLookup = SC_OPCODE_X_LOOKUP, ocHLookup = SC_OPCODE_H_LOOKUP, - ocMultiArea = ocMulTI_AREA, + ocMultiArea = SC_OPCODE_MULTI_AREA, ocOffset = SC_OPCODE_OFFSET, ocIndex = SC_OPCODE_INDEX, ocAreas = SC_OPCODE_AREAS, @@ -344,7 +334,7 @@ enum OpCode : sal_uInt16 ocSearch = SC_OPCODE_SEARCH, ocMid = SC_OPCODE_MID, ocText = SC_OPCODE_TEXT, - ocSubstitute = ocSubSTITUTE, + ocSubstitute = SC_OPCODE_SUBSTITUTE, ocRept = SC_OPCODE_REPT, ocConcat = SC_OPCODE_CONCAT, ocConcat_MS = SC_OPCODE_CONCAT_MS, @@ -585,7 +575,6 @@ inline std::string OpCodeEnumToString(OpCode eCode) case ocTableRefItemData: return "TableRefItemData"; case ocTableRefItemTotals: return "TableRefItemTotals"; case ocTableRefItemThisRow: return "TableRefItemThisRow"; - case ocStopDiv: return "StopDiv"; case ocSkip: return "Skip"; case ocDBArea: return "DBArea"; case ocTableRef: return "TableRef"; @@ -1040,7 +1029,6 @@ inline std::string OpCodeEnumToString(OpCode eCode) case ocDebugVar: return "DebugVar"; case ocDataToken1: return "DataToken1"; case ocNone: return "None"; - default: break; } std::ostringstream os; os << static_cast<int>(eCode); diff --git a/sc/inc/scfuncs.hrc b/sc/inc/scfuncs.hrc index ca57eab2da63..6c765c304bf9 100644 --- a/sc/inc/scfuncs.hrc +++ b/sc/inc/scfuncs.hrc @@ -898,27 +898,27 @@ const TranslateId SC_OPCODE_IF_NA_ARY[] = }; // -=*# Resource for function OR #*=- -const TranslateId ocOr_ARY[] = +const TranslateId SC_OPCODE_OR_ARY[] = { - NC_("ocOr", "Returns TRUE if an argument is TRUE."), - NC_("ocOr", "Logical value "), - NC_("ocOr", "Logical value 1, logical value 2,... are conditions to be tested and which return either TRUE or FALSE.") + NC_("SC_OPCODE_OR", "Returns TRUE if an argument is TRUE."), + NC_("SC_OPCODE_OR", "Logical value "), + NC_("SC_OPCODE_OR", "Logical value 1, logical value 2,... are conditions to be tested and which return either TRUE or FALSE.") }; // -=*# Resource for function XOR #*=- -const TranslateId ocXor_ARY[] = +const TranslateId SC_OPCODE_XOR_ARY[] = { - NC_("ocXor", "Returns TRUE if an odd number of arguments evaluates to TRUE."), - NC_("ocXor", "Logical value "), - NC_("ocXor", "Logical value 1, logical value 2, ... are conditions to be tested and which return either TRUE or FALSE.") + NC_("SC_OPCODE_XOR", "Returns TRUE if an odd number of arguments evaluates to TRUE."), + NC_("SC_OPCODE_XOR", "Logical value "), + NC_("SC_OPCODE_XOR", "Logical value 1, logical value 2, ... are conditions to be tested and which return either TRUE or FALSE.") }; // -=*# Resource for function AND #*=- -const TranslateId ocAnd_ARY[] = +const TranslateId SC_OPCODE_AND_ARY[] = { - NC_("ocAnd", "Returns TRUE if all arguments are TRUE."), - NC_("ocAnd", "Logical value "), - NC_("ocAnd", "Logical value 1, logical value 2;...are conditions to be tested and each returns either TRUE or FALSE.") + NC_("SC_OPCODE_AND", "Returns TRUE if all arguments are TRUE."), + NC_("SC_OPCODE_AND", "Logical value "), + NC_("SC_OPCODE_AND", "Logical value 1, logical value 2;...are conditions to be tested and each returns either TRUE or FALSE.") }; // -=*# Resource for function ABS #*=- @@ -930,13 +930,13 @@ const TranslateId SC_OPCODE_ABS_ARY[] = }; // -=*# Resource for function POWER #*=- -const TranslateId ocPowER_ARY[] = +const TranslateId SC_OPCODE_POWER_ARY[] = { - NC_("ocPowER", "Returns a^b, base a raised to the power of exponent b."), - NC_("ocPowER", "Base"), - NC_("ocPowER", "The base a of the power a^b."), - NC_("ocPowER", "Exponent"), - NC_("ocPowER", "The exponent b of the power a^b.") + NC_("SC_OPCODE_POWER", "Returns a^b, base a raised to the power of exponent b."), + NC_("SC_OPCODE_POWER", "Base"), + NC_("SC_OPCODE_POWER", "The base a of the power a^b."), + NC_("SC_OPCODE_POWER", "Exponent"), + NC_("SC_OPCODE_POWER", "The exponent b of the power a^b.") }; // -=*# Resource for function COUNTBLANK #*=- @@ -1341,13 +1341,13 @@ const TranslateId SC_OPCODE_PLUS_MINUS_ARY[] = }; // -=*# Resource for function SUBTOTAL #*=- -const TranslateId ocSub_TOTAL_ARY[] = +const TranslateId SC_OPCODE_SUB_TOTAL_ARY[] = { - NC_("ocSub_TOTAL", "Calculates subtotals in a spreadsheet."), - NC_("ocSub_TOTAL", "Function"), - NC_("ocSub_TOTAL", "Function index. Is an index of the possible functions Total, Max, ..."), - NC_("ocSub_TOTAL", "Range"), - NC_("ocSub_TOTAL", "The cells of the range which are to be taken into account.") + NC_("SC_OPCODE_SUB_TOTAL", "Calculates subtotals in a spreadsheet."), + NC_("SC_OPCODE_SUB_TOTAL", "Function"), + NC_("SC_OPCODE_SUB_TOTAL", "Function index. Is an index of the possible functions Total, Max, ..."), + NC_("SC_OPCODE_SUB_TOTAL", "Range"), + NC_("SC_OPCODE_SUB_TOTAL", "The cells of the range which are to be taken into account.") }; // -=*# Resource for function AGGREGATE #*=- @@ -3268,19 +3268,19 @@ const TranslateId SC_OPCODE_FORECAST_LIN_ARY[] = }; // -=*# Resource for function ADDRESS #*=- -const TranslateId ocAddRESS_ARY[] = +const TranslateId SC_OPCODE_ADDRESS_ARY[] = { - NC_("ocAddRESS", "Returns the reference to a cell as text."), - NC_("ocAddRESS", "Row"), - NC_("ocAddRESS", "The row number of the cell."), - NC_("ocAddRESS", "Column"), - NC_("ocAddRESS", "The column number of the cell."), - NC_("ocAddRESS", "ABS"), - NC_("ocAddRESS", "Specifies whether absolute or relative referencing is to be used."), - NC_("ocAddRESS", "A1"), - NC_("ocAddRESS", "The reference style: 0 or FALSE means R1C1 style, any other value or omitted means A1 style."), - NC_("ocAddRESS", "Sheet"), - NC_("ocAddRESS", "The spreadsheet name of the cell reference.") + NC_("SC_OPCODE_ADDRESS", "Returns the reference to a cell as text."), + NC_("SC_OPCODE_ADDRESS", "Row"), + NC_("SC_OPCODE_ADDRESS", "The row number of the cell."), + NC_("SC_OPCODE_ADDRESS", "Column"), + NC_("SC_OPCODE_ADDRESS", "The column number of the cell."), + NC_("SC_OPCODE_ADDRESS", "ABS"), + NC_("SC_OPCODE_ADDRESS", "Specifies whether absolute or relative referencing is to be used."), + NC_("SC_OPCODE_ADDRESS", "A1"), + NC_("SC_OPCODE_ADDRESS", "The reference style: 0 or FALSE means R1C1 style, any other value or omitted means A1 style."), + NC_("SC_OPCODE_ADDRESS", "Sheet"), + NC_("SC_OPCODE_ADDRESS", "The spreadsheet name of the cell reference.") }; // -=*# Resource for function AREAS #*=- @@ -3836,17 +3836,17 @@ const TranslateId SC_OPCODE_REPT_ARY[] = }; // -=*# Resource for function SUBSTITUTE #*=- -const TranslateId ocSubSTITUTE_ARY[] = -{ - NC_("ocSubSTITUTE", "Substitutes new text for old text in a string."), - NC_("ocSubSTITUTE", "Text"), - NC_("ocSubSTITUTE", "The text in which partial words are to be replaced."), - NC_("ocSubSTITUTE", "Search text"), - NC_("ocSubSTITUTE", "The partial string to be (repeatedly) replaced."), - NC_("ocSubSTITUTE", "New text"), - NC_("ocSubSTITUTE", "The text which is to replace the text string."), - NC_("ocSubSTITUTE", "Occurrence"), - NC_("ocSubSTITUTE", "Which occurrence of the old text is to be replaced.") +const TranslateId SC_OPCODE_SUBSTITUTE_ARY[] = +{ + NC_("SC_OPCODE_SUBSTITUTE", "Substitutes new text for old text in a string."), + NC_("SC_OPCODE_SUBSTITUTE", "Text"), + NC_("SC_OPCODE_SUBSTITUTE", "The text in which partial words are to be replaced."), + NC_("SC_OPCODE_SUBSTITUTE", "Search text"), + NC_("SC_OPCODE_SUBSTITUTE", "The partial string to be (repeatedly) replaced."), + NC_("SC_OPCODE_SUBSTITUTE", "New text"), + NC_("SC_OPCODE_SUBSTITUTE", "The text which is to replace the text string."), + NC_("SC_OPCODE_SUBSTITUTE", "Occurrence"), + NC_("SC_OPCODE_SUBSTITUTE", "Which occurrence of the old text is to be replaced.") }; // -=*# Resource for function REGEX #*=- diff --git a/sc/source/core/data/funcdesc.cxx b/sc/source/core/data/funcdesc.cxx index 2611d372abf5..e9e02c78f01c 100644 --- a/sc/source/core/data/funcdesc.cxx +++ b/sc/source/core/data/funcdesc.cxx @@ -390,13 +390,13 @@ ScFunctionList::ScFunctionList( bool bEnglishFunctionNames ) // which will concept check that the list is sorted on first use to ensure this holds static const ScFuncDescCore aDescs[] = { - { ocIf, ENTRY(SC_OPCODE_IF_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_WENN, 3, { 0, 1, 1 }, 0 }, - { ocIfError, ENTRY(SC_OPCODE_IF_ERROR_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_IFERROR, 2, { 0, 0 }, 0 }, - { ocIfNA, ENTRY(SC_OPCODE_IF_NA_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_IFNA, 2, { 0, 0 }, 0 }, - { ocChoose, ENTRY(SC_OPCODE_CHOOSE_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_WAHL, VAR_ARGS+1, { 0, 0 }, 31 }, - { ocLet, ENTRY(SC_OPCODE_LET_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_LET_MS, PAIRED_VAR_ARGS + 1, { 0, 0, 0 }, 0 }, - { ocAnd, ENTRY(ocAnd_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_UND, VAR_ARGS, { 0 }, 0 }, - { ocOr, ENTRY(ocOr_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_ODER, VAR_ARGS, { 0 }, 0 }, + { SC_OPCODE_IF, ENTRY(SC_OPCODE_IF_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_WENN, 3, { 0, 1, 1 }, 0 }, + { SC_OPCODE_IF_ERROR, ENTRY(SC_OPCODE_IF_ERROR_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_IFERROR, 2, { 0, 0 }, 0 }, + { SC_OPCODE_IF_NA, ENTRY(SC_OPCODE_IF_NA_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_IFNA, 2, { 0, 0 }, 0 }, + { SC_OPCODE_CHOOSE, ENTRY(SC_OPCODE_CHOOSE_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_WAHL, VAR_ARGS+1, { 0, 0 }, 31 }, + { SC_OPCODE_LET, ENTRY(SC_OPCODE_LET_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_LET_MS, PAIRED_VAR_ARGS + 1, { 0, 0, 0 }, 0 }, + { SC_OPCODE_AND, ENTRY(SC_OPCODE_AND_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_UND, VAR_ARGS, { 0 }, 0 }, + { SC_OPCODE_OR, ENTRY(SC_OPCODE_OR_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_ODER, VAR_ARGS, { 0 }, 0 }, { SC_OPCODE_PI, ENTRY(SC_OPCODE_PI_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_PI, 0, { }, 0 }, { SC_OPCODE_RANDOM, ENTRY(SC_OPCODE_RANDOM_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_ZUFALLSZAHL, 0, { }, 0 }, { SC_OPCODE_TRUE, ENTRY(SC_OPCODE_TRUE_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_WAHR, 0, { }, 0 }, @@ -502,7 +502,7 @@ ScFunctionList::ScFunctionList( bool bEnglishFunctionNames ) { SC_OPCODE_ROUND_DOWN, ENTRY(SC_OPCODE_ROUND_DOWN_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_ABRUNDEN, 2, { 0, 1 }, 0 }, { SC_OPCODE_TRUNC, ENTRY(SC_OPCODE_TRUNC_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_KUERZEN, 2, { 0, 0 }, 0 }, { SC_OPCODE_LOG, ENTRY(SC_OPCODE_LOG_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_LOG, 2, { 0, 1 }, 0 }, - { ocPowER, ENTRY(ocPowER_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_POTENZ, 2, { 0, 0 }, 0 }, + { SC_OPCODE_POWER, ENTRY(SC_OPCODE_POWER_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_POTENZ, 2, { 0, 0 }, 0 }, { SC_OPCODE_GCD, ENTRY(SC_OPCODE_GCD_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_GGT, VAR_ARGS, { 0 }, 0 }, { SC_OPCODE_LCM, ENTRY(SC_OPCODE_LCM_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_KGV, VAR_ARGS, { 0 }, 0 }, { SC_OPCODE_MOD, ENTRY(SC_OPCODE_MOD_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_REST, 2, { 0, 0 }, 0 }, @@ -559,7 +559,7 @@ ScFunctionList::ScFunctionList( bool bEnglishFunctionNames ) { SC_OPCODE_CUM_PRINC, ENTRY(SC_OPCODE_CUM_PRINC_ARY), 0, ID_FUNCTION_GRP_FINANCIAL, HID_FUNC_KUMKAPITAL, 6, { 0, 0, 0, 0, 0, 0 }, 0 }, { SC_OPCODE_EFFECT, ENTRY(SC_OPCODE_EFFECT_ARY), 0, ID_FUNCTION_GRP_FINANCIAL, HID_FUNC_EFFEKTIV, 2, { 0, 0 }, 0 }, { SC_OPCODE_NOMINAL, ENTRY(SC_OPCODE_NOMINAL_ARY), 0, ID_FUNCTION_GRP_FINANCIAL, HID_FUNC_NOMINAL, 2, { 0, 0 }, 0 }, - { ocSub_TOTAL, ENTRY(ocSub_TOTAL_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_TEILERGEBNIS, 2, { 0, 0 }, 0 }, + { SC_OPCODE_SUB_TOTAL, ENTRY(SC_OPCODE_SUB_TOTAL_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_TEILERGEBNIS, 2, { 0, 0 }, 0 }, { SC_OPCODE_DB_SUM, ENTRY(SC_OPCODE_DB_SUM_ARY), 0, ID_FUNCTION_GRP_DATABASE, HID_FUNC_DBSUMME, 3, { 0, 0, 0 }, 0 }, { SC_OPCODE_DB_COUNT, ENTRY(SC_OPCODE_DB_COUNT_ARY), 0, ID_FUNCTION_GRP_DATABASE, HID_FUNC_DBANZAHL, 3, { 0, 1, 0 }, 0 }, { SC_OPCODE_DB_COUNT_2, ENTRY(SC_OPCODE_DB_COUNT_2_ARY), 0, ID_FUNCTION_GRP_DATABASE, HID_FUNC_DBANZAHL2, 3, { 0, 1, 0 }, 0 }, @@ -573,7 +573,7 @@ ScFunctionList::ScFunctionList( bool bEnglishFunctionNames ) { SC_OPCODE_DB_VAR, ENTRY(SC_OPCODE_DB_VAR_ARY), 0, ID_FUNCTION_GRP_DATABASE, HID_FUNC_DBVARIANZ, 3, { 0, 0, 0 }, 0 }, { SC_OPCODE_DB_VAR_P, ENTRY(SC_OPCODE_DB_VAR_P_ARY), 0, ID_FUNCTION_GRP_DATABASE, HID_FUNC_DBVARIANZEN, 3, { 0, 0, 0 }, 0 }, { SC_OPCODE_INDIRECT, ENTRY(SC_OPCODE_INDIRECT_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_INDIREKT, 2, { 0, 1 }, 0 }, - { ocAddRESS, ENTRY(ocAddRESS_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_ADRESSE, 5, { 0, 0, 1, 1, 1 }, 0 }, + { SC_OPCODE_ADDRESS, ENTRY(SC_OPCODE_ADDRESS_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_ADRESSE, 5, { 0, 0, 1, 1, 1 }, 0 }, { SC_OPCODE_MATCH, ENTRY(SC_OPCODE_MATCH_ARY), 0, ID_FUNCTION_GRP_TABLE, HID_FUNC_VERGLEICH, 3, { 0, 0, 1 }, 0 }, { SC_OPCODE_COUNT_EMPTY_CELLS, ENTRY(SC_OPCODE_COUNT_EMPTY_CELLS_ARY), 0, ID_FUNCTION_GRP_STATISTIC, HID_FUNC_ANZAHLLEEREZELLEN, 1, { 0 }, 0 }, { SC_OPCODE_COUNT_IF, ENTRY(SC_OPCODE_COUNT_IF_ARY), 0, ID_FUNCTION_GRP_STATISTIC, HID_FUNC_ZAEHLENWENN, 2, { 0, 0 }, 0 }, @@ -594,7 +594,7 @@ ScFunctionList::ScFunctionList( bool bEnglishFunctionNames ) { SC_OPCODE_SEARCH, ENTRY(SC_OPCODE_SEARCH_ARY), 0, ID_FUNCTION_GRP_TEXT, HID_FUNC_SUCHEN, 3, { 0, 0, 1 }, 0 }, { SC_OPCODE_MID, ENTRY(SC_OPCODE_MID_ARY), 0, ID_FUNCTION_GRP_TEXT, HID_FUNC_TEIL, 3, { 0, 0, 0 }, 0 }, { SC_OPCODE_TEXT, ENTRY(SC_OPCODE_TEXT_ARY), 0, ID_FUNCTION_GRP_TEXT, HID_FUNC_TEXT, 2, { 0, 0 }, 0 }, - { ocSubSTITUTE, ENTRY(ocSubSTITUTE_ARY), 0, ID_FUNCTION_GRP_TEXT, HID_FUNC_WECHSELN, 4, { 0, 0, 0, 1 }, 0 }, + { SC_OPCODE_SUBSTITUTE, ENTRY(SC_OPCODE_SUBSTITUTE_ARY), 0, ID_FUNCTION_GRP_TEXT, HID_FUNC_WECHSELN, 4, { 0, 0, 0, 1 }, 0 }, { SC_OPCODE_REPT, ENTRY(SC_OPCODE_REPT_ARY), 0, ID_FUNCTION_GRP_TEXT, HID_FUNC_WIEDERHOLEN, 2, { 0, 0 }, 0 }, { SC_OPCODE_CONCAT, ENTRY(SC_OPCODE_CONCAT_ARY), 0, ID_FUNCTION_GRP_TEXT, HID_FUNC_VERKETTEN, VAR_ARGS, { 0 }, 0 }, { SC_OPCODE_MAT_DET, ENTRY(SC_OPCODE_MAT_DET_ARY), 0, ID_FUNCTION_GRP_MATRIX, HID_FUNC_MDET, 1, { 0 }, 0 }, @@ -689,7 +689,7 @@ ScFunctionList::ScFunctionList( bool bEnglishFunctionNames ) { SC_OPCODE_BITRSHIFT, ENTRY(SC_OPCODE_BITRSHIFT_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_BITRSHIFT, 2, { 0, 0 }, 0 }, { SC_OPCODE_BITLSHIFT, ENTRY(SC_OPCODE_BITLSHIFT_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_BITLSHIFT, 2, { 0, 0 }, 0 }, { SC_OPCODE_GET_DATEDIF, ENTRY(SC_OPCODE_GET_DATEDIF_ARY), 0, ID_FUNCTION_GRP_DATETIME, HID_FUNC_DATEDIF, 3, { 0, 0, 0 }, 0 }, - { ocXor, ENTRY(ocXor_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_XOR, VAR_ARGS, { 0 }, 0 }, + { SC_OPCODE_XOR, ENTRY(SC_OPCODE_XOR_ARY), 0, ID_FUNCTION_GRP_LOGIC, HID_FUNC_XOR, VAR_ARGS, { 0 }, 0 }, { SC_OPCODE_AVERAGE_IF, ENTRY(SC_OPCODE_AVERAGE_IF_ARY), 0, ID_FUNCTION_GRP_STATISTIC, HID_FUNC_AVERAGEIF, 3, { 0, 0, 1 }, 0 }, { SC_OPCODE_SUM_IFS, ENTRY(SC_OPCODE_SUM_IFS_ARY), 0, ID_FUNCTION_GRP_MATH, HID_FUNC_SUMIFS, PAIRED_VAR_ARGS+1, { 0, 0, 0 }, 0 }, { SC_OPCODE_AVERAGE_IFS, ENTRY(SC_OPCODE_AVERAGE_IFS_ARY), 0, ID_FUNCTION_GRP_STATISTIC, HID_FUNC_AVERAGEIFS, PAIRED_VAR_ARGS+1, { 0, 0, 0 }, 0 }, diff --git a/sc/source/core/tool/appoptio.cxx b/sc/source/core/tool/appoptio.cxx index 3f3f5d6dcada..3825ccf8468b 100644 --- a/sc/source/core/tool/appoptio.cxx +++ b/sc/source/core/tool/appoptio.cxx @@ -23,7 +23,6 @@ #include <global.hxx> #include <userlist.hxx> #include <formula/compiler.hxx> -#include <formula/opcode.hxx> #include <miscuno.hxx> #include <vector> #include <osl/diagnose.h> @@ -67,7 +66,7 @@ void ScAppOptions::SetDefaults() pLRUList[1] = SC_OPCODE_AVERAGE; pLRUList[2] = SC_OPCODE_MIN; pLRUList[3] = SC_OPCODE_MAX; - pLRUList[4] = ocIf; + pLRUList[4] = SC_OPCODE_IF; nLRUFuncCount = 5; nTrackContentColor = COL_TRANSPARENT; diff --git a/sc/source/core/tool/compiler.cxx b/sc/source/core/tool/compiler.cxx index 3a0a6babf3c2..5a3e20c24d0d 100644 --- a/sc/source/core/tool/compiler.cxx +++ b/sc/source/core/tool/compiler.cxx @@ -3212,7 +3212,7 @@ bool ScCompiler::ParseOpCode( const OUString& rName, bool bInArray ) { bool bShouldBeNegSub = (eLastOp == ocOpen || eLastOp == ocSep || eLastOp == ocNegSub || - (ocStartBinOp <= eLastOp && eLastOp < ocStopBinOp) || + (SC_OPCODE_START_BIN_OP <= eLastOp && eLastOp < SC_OPCODE_STOP_BIN_OP) || eLastOp == ocArrayOpen || eLastOp == ocArrayColSep || eLastOp == ocArrayRowSep); if (bShouldBeNegSub && eOp == ocSub) @@ -5757,8 +5757,8 @@ bool ScCompiler::GetRefColRowNames(const FormulaToken* pToken, ScComplexRefData& if (eOp1 != ocColRowName && eOp1 != ocIntersect && eOp2 != ocColRowName && eOp2 != ocIntersect) { - if ((ocStartBinOp <= eOp1 && eOp1 < ocStopBinOp) - || (ocStartBinOp <= eOp2 && eOp2 < ocStopBinOp)) + if ((SC_OPCODE_START_BIN_OP <= eOp1 && eOp1 < SC_OPCODE_STOP_BIN_OP) + || (SC_OPCODE_START_BIN_OP <= eOp2 && eOp2 < SC_OPCODE_STOP_BIN_OP)) bSingle = true; } if (bSingle) @@ -6524,7 +6524,7 @@ bool ScCompiler::HandleIIOpCodeInternal(FormulaToken* token, FormulaToken*** ppp mPendingImplicitIntersectionOptimizations.emplace_back( pppToken[0], token ); return true; } - else if ((nOpCode >= ocStartBinOp && nOpCode < ocStopBinOp + else if ((nOpCode >= SC_OPCODE_START_BIN_OP && nOpCode < SC_OPCODE_STOP_BIN_OP && nOpCode != ocAnd && nOpCode != ocOr) || nOpCode == ocRound || nOpCode == ocRoundUp || nOpCode == ocRoundDown) { @@ -6543,7 +6543,7 @@ bool ScCompiler::HandleIIOpCodeInternal(FormulaToken* token, FormulaToken*** ppp mPendingImplicitIntersectionOptimizations.emplace_back( pppToken[1], token ); return true; } - else if ((nOpCode >= ocStartUnaryOp && nOpCode < ocStopUnaryOp) + else if ((nOpCode >= SC_OPCODE_START_UN_OP && nOpCode < SC_OPCODE_STOP_UN_OP) || nOpCode == ocPercentSign) { if (nNumParams != 1) diff --git a/sc/source/core/tool/parclass.cxx b/sc/source/core/tool/parclass.cxx index b6425d0f824a..e7e07cdccdd2 100644 --- a/sc/source/core/tool/parclass.cxx +++ b/sc/source/core/tool/parclass.cxx @@ -604,7 +604,7 @@ void ScParameterClassification::GenerateDocumentation() bAddParentheses = false; aToken.SetByte(0); } - else if ( eOp < ocStopBinOp ) + else if ( eOp < SC_OPCODE_STOP_BIN_OP ) { switch ( eOp ) { @@ -616,7 +616,7 @@ void ScParameterClassification::GenerateDocumentation() aToken.SetByte(2); } } - else if ( eOp < ocStopUnaryOp ) + else if ( eOp < SC_OPCODE_STOP_UN_OP ) aToken.SetByte(1); else if ( eOp < SC_OPCODE_STOP_NO_PAR ) aToken.SetByte(0); diff --git a/sc/source/core/tool/token.cxx b/sc/source/core/tool/token.cxx index f8609366d435..0e2e2ab5d884 100644 --- a/sc/source/core/tool/token.cxx +++ b/sc/source/core/tool/token.cxx @@ -1655,7 +1655,7 @@ void ScTokenArray::CheckToken( const FormulaToken& r ) ; } } - else if (ocStartBinOp <= eOp && eOp < ocStopUnaryOp) + else if (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP) { if (ScInterpreter::GetGlobalConfig().mbOpenCLSubsetOnly && ScInterpreter::GetGlobalConfig().mpOpenCLSubsetOpCodes->find(eOp) == ScInterpreter::GetGlobalConfig().mpOpenCLSubsetOpCodes->end())
