Second batch of adding SAL_OVERRIDE to overriding function declarations

...mostly done with a rewriting Clang plugin, with just some manual tweaking
necessary to fix poor macro usage.

Change-Id: Ie656f9d653fc716f72ac175925272696d509038f

10 files changed, 651 insertions, 651 deletions

diff --git a/sc/source/core/opencl/formulagroupcl.cxx b/sc/source/core/opencl/formulagroupcl.cxx
index 8b8a8e541920..10b15a9cbc4f 100644
--- a/sc/source/core/opencl/formulagroupcl.cxx
+++ b/sc/source/core/opencl/formulagroupcl.cxx
@@ -138,19 +138,19 @@ public:
         FormulaTreeNodeRef ft):
             DynamicKernelArgument(s, ft) {}
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << "unsigned " << mSymName;
     }
-    virtual void GenDeclRef(std::stringstream &ss) const
+    virtual void GenDeclRef(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << GenSlidingWindowDeclRef(false);
     }
-    virtual void GenSlidingWindowDecl(std::stringstream &ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         GenDecl(ss);
     }
-    virtual std::string GenSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         std::stringstream ss;
         if (GetFormulaToken()->GetType() != formula::svString)
@@ -159,12 +159,12 @@ public:
         ss << Tok->GetString().getString().toAsciiUpperCase().hashCode() << "U";
         return ss.str();
     }
-    virtual size_t GetWindowSize(void) const
+    virtual size_t GetWindowSize(void) const SAL_OVERRIDE
     {
         return 1;
     }
     /// Pass the 32-bit hash of the string to the kernel
-    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program)
+    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program) SAL_OVERRIDE
     {
         FormulaToken *ref = mFormulaTree->GetFormulaToken();
         cl_uint hashCode = 0;
@@ -195,25 +195,25 @@ public:
         FormulaTreeNodeRef ft):
             DynamicKernelArgument(s, ft) {}
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << "double " << mSymName;
     }
-    virtual void GenDeclRef(std::stringstream &ss) const
+    virtual void GenDeclRef(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << mSymName;
     }
-    virtual void GenSlidingWindowDecl(std::stringstream &ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         GenDecl(ss);
     }
-    virtual std::string GenSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         if (GetFormulaToken()->GetType() != formula::svDouble)
             throw Unhandled();
         return mSymName;
     }
-    virtual size_t GetWindowSize(void) const
+    virtual size_t GetWindowSize(void) const SAL_OVERRIDE
     {
         return 1;
     }
@@ -225,7 +225,7 @@ public:
         return Tok->GetDouble();
     }
     /// Create buffer and pass the buffer to a given kernel
-    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program)
+    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program) SAL_OVERRIDE
     {
         double tmp = GetDouble();
         // Pass the scalar result back to the rest of the formula kernel
@@ -244,28 +244,28 @@ public:
         FormulaTreeNodeRef ft):
             DynamicKernelArgument(s, ft) {}
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << "double " << mSymName;
     }
-    virtual void GenDeclRef(std::stringstream &ss) const
+    virtual void GenDeclRef(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << "3.14159265358979";
     }
-    virtual void GenSlidingWindowDecl(std::stringstream &ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         GenDecl(ss);
     }
-    virtual std::string GenSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         return mSymName;
     }
-    virtual size_t GetWindowSize(void) const
+    virtual size_t GetWindowSize(void) const SAL_OVERRIDE
     {
         return 1;
     }
     /// Create buffer and pass the buffer to a given kernel
-    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program)
+    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program) SAL_OVERRIDE
     {
         double tmp = 0.0;
         // Pass the scalar result back to the rest of the formula kernel
@@ -283,23 +283,23 @@ public:
         FormulaTreeNodeRef ft):
             DynamicKernelArgument(s, ft) {}
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << "double " << mSymName;
     }
-    virtual void GenDeclRef(std::stringstream &ss) const
+    virtual void GenDeclRef(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << mSymName;
     }
-    virtual void GenSlidingWindowDecl(std::stringstream &ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         GenDecl(ss);
     }
-    virtual std::string GenSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         return mSymName + "_Random()";
     }
-    void GenSlidingWindowFunction(std::stringstream &ss)
+    void GenSlidingWindowFunction(std::stringstream &ss) SAL_OVERRIDE
     {
         ss << "\ndouble " << mSymName;
         ss << "_Random ()\n{\n";
@@ -319,12 +319,12 @@ public:
         ss << "    return tmp;\n";
         ss << "}";
     }
-    virtual size_t GetWindowSize(void) const
+    virtual size_t GetWindowSize(void) const SAL_OVERRIDE
     {
         return 1;
     }
     /// Create buffer and pass the buffer to a given kernel
-    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program)
+    virtual size_t Marshal(cl_kernel k, int argno, int, cl_program) SAL_OVERRIDE
     {
         double tmp = 0.0;
         // Pass the scalar result back to the rest of the formula kernel
@@ -343,17 +343,17 @@ public:
         FormulaTreeNodeRef ft, int index = 0):
         VectorRef(s, ft, index) {}
 
-    virtual void GenSlidingWindowFunction(std::stringstream &) {}
+    virtual void GenSlidingWindowFunction(std::stringstream &) SAL_OVERRIDE {}
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         ss << "__global unsigned int *"<<mSymName;
     }
-    virtual void GenSlidingWindowDecl(std::stringstream& ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream& ss) const SAL_OVERRIDE
     {
         DynamicKernelStringArgument::GenDecl(ss);
     }
-    virtual size_t Marshal(cl_kernel, int, int, cl_program);
+    virtual size_t Marshal(cl_kernel, int, int, cl_program) SAL_OVERRIDE;
 };
 
 /// Marshal a string vector reference
@@ -419,27 +419,27 @@ public:
     DynamicKernelMixedArgument(const std::string &s,
         FormulaTreeNodeRef ft):
         VectorRef(s, ft), mStringArgument(s+"s", ft) {}
-    virtual void GenSlidingWindowDecl(std::stringstream& ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream& ss) const SAL_OVERRIDE
     {
         VectorRef::GenSlidingWindowDecl(ss);
         ss << ", ";
         mStringArgument.GenSlidingWindowDecl(ss);
     }
-    virtual void GenSlidingWindowFunction(std::stringstream &) {}
+    virtual void GenSlidingWindowFunction(std::stringstream &) SAL_OVERRIDE {}
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         VectorRef::GenDecl(ss);
         ss << ", ";
         mStringArgument.GenDecl(ss);
     }
-    virtual void GenDeclRef(std::stringstream &ss) const
+    virtual void GenDeclRef(std::stringstream &ss) const SAL_OVERRIDE
     {
         VectorRef::GenDeclRef(ss);
         ss << ",";
         mStringArgument.GenDeclRef(ss);
     }
-    virtual std::string GenSlidingWindowDeclRef(bool) const
+    virtual std::string GenSlidingWindowDeclRef(bool) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "(!isNan(" << VectorRef::GenSlidingWindowDeclRef();
@@ -448,19 +448,19 @@ public:
         ss << ")";
         return ss.str();
     }
-    virtual std::string GenDoubleSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenDoubleSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << VectorRef::GenSlidingWindowDeclRef();
         return ss.str();
     }
-    virtual std::string GenStringSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenStringSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << mStringArgument.GenSlidingWindowDeclRef();
         return ss.str();
     }
-    virtual size_t Marshal(cl_kernel k, int argno, int vw, cl_program p)
+    virtual size_t Marshal(cl_kernel k, int argno, int vw, cl_program p) SAL_OVERRIDE
     {
         int i = VectorRef::Marshal(k, argno, vw, p);
         i += mStringArgument.Marshal(k, argno+i, vw, p);
@@ -705,27 +705,27 @@ public:
         VectorRef(s, ft),
         mDoubleArgument(s, ft, CodeGen, index),
         mStringArgument(s+"s", ft, CodeGen, index) {}
-    virtual void GenSlidingWindowDecl(std::stringstream& ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream& ss) const SAL_OVERRIDE
     {
         mDoubleArgument.GenSlidingWindowDecl(ss);
         ss << ", ";
         mStringArgument.GenSlidingWindowDecl(ss);
     }
-    virtual void GenSlidingWindowFunction(std::stringstream &) {}
+    virtual void GenSlidingWindowFunction(std::stringstream &) SAL_OVERRIDE {}
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         mDoubleArgument.GenDecl(ss);
         ss << ", ";
         mStringArgument.GenDecl(ss);
     }
-    virtual void GenDeclRef(std::stringstream &ss) const
+    virtual void GenDeclRef(std::stringstream &ss) const SAL_OVERRIDE
     {
         mDoubleArgument.GenDeclRef(ss);
         ss << ",";
         mStringArgument.GenDeclRef(ss);
     }
-    virtual std::string GenSlidingWindowDeclRef(bool) const
+    virtual std::string GenSlidingWindowDeclRef(bool) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "(!isNan(" << mDoubleArgument.GenSlidingWindowDeclRef();
@@ -734,19 +734,19 @@ public:
         ss << ")";
         return ss.str();
     }
-    virtual std::string GenDoubleSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenDoubleSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << mDoubleArgument.GenSlidingWindowDeclRef();
         return ss.str();
     }
-    virtual std::string GenStringSlidingWindowDeclRef(bool=false) const
+    virtual std::string GenStringSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << mStringArgument.GenSlidingWindowDeclRef();
         return ss.str();
     }
-    virtual size_t Marshal(cl_kernel k, int argno, int vw, cl_program p)
+    virtual size_t Marshal(cl_kernel k, int argno, int vw, cl_program p) SAL_OVERRIDE
     {
         int i = mDoubleArgument.Marshal(k, argno, vw, p);
         i += mStringArgument.Marshal(k, argno + i, vw, p);
@@ -1201,7 +1201,7 @@ public:
     typedef ParallelReductionVectorRef<VectorRef> ParallelNumericRange;
 
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments)
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE
     {
         ss << "\ndouble " << sSymName;
         ss << "_"<< BinFuncName() <<"(";
@@ -1312,8 +1312,8 @@ public:
         ss << ";\n}";
     }
     virtual bool isAverage() const { return false; }
-    virtual bool takeString() const { return false; }
-    virtual bool takeNumeric() const { return true; }
+    virtual bool takeString() const SAL_OVERRIDE { return false; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 
 // Strictly binary operators
@@ -1321,7 +1321,7 @@ class Binary: public SlidingFunctionBase
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments)
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE
     {
         ss << "\ndouble " << sSymName;
         ss << "_"<< BinFuncName() <<"(";
@@ -1339,15 +1339,15 @@ public:
                 vSubArguments[1]->GenSlidingWindowDeclRef(false)) << ";\n\t";
         ss << "return tmp;\n}";
     }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 
 class SumOfProduct: public SlidingFunctionBase
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments)
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE
     {
         size_t nCurWindowSize = 0;
         FormulaToken *tmpCur = NULL;
@@ -1595,152 +1595,152 @@ public:
 #endif
 
     }
-    virtual bool takeString() const { return false; }
-    virtual bool takeNumeric() const { return true; }
+    virtual bool takeString() const SAL_OVERRIDE { return false; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 
 /// operator traits
 class OpNop: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &) const SAL_OVERRIDE
     {
         return lhs;
     }
-    virtual std::string BinFuncName(void) const { return "nop"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "nop"; }
 };
 
 class OpCount: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "(isNan(" << lhs << ")?"<<rhs<<":"<<rhs<<"+1.0)";
         return ss.str();
     }
-    virtual std::string BinFuncName(void) const { return "fcount"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fcount"; }
 };
 
 class OpEqual: public Binary {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "strequal("<< lhs << "," << rhs <<")";
         return ss.str();
     }
-    virtual std::string BinFuncName(void) const { return "eq"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "eq"; }
 };
 
 class OpLessEqual: public Binary {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "("<< lhs << "<=" << rhs <<")";
         return ss.str();
     }
-    virtual std::string BinFuncName(void) const { return "leq"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "leq"; }
 };
 
 class OpGreater: public Binary {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "("<< lhs << ">" << rhs <<")";
         return ss.str();
     }
-    virtual std::string BinFuncName(void) const { return "gt"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "gt"; }
 };
 
 class OpSum: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "((" << lhs <<")+("<< rhs<<"))";
         return ss.str();
     }
-    virtual std::string BinFuncName(void) const { return "fsum"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fsum"; }
 };
 
 class OpAverage: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         std::stringstream ss;
         ss << "fsum_count(" << lhs <<","<< rhs<<", &nCount)";
         return ss.str();
     }
-    virtual std::string BinFuncName(void) const { return "fsum"; }
-    virtual bool isAverage() const { return true; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fsum"; }
+    virtual bool isAverage() const SAL_OVERRIDE { return true; }
 };
 
 class OpSub: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         return lhs + "-" + rhs;
     }
-    virtual std::string BinFuncName(void) const { return "fsub"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fsub"; }
 };
 
 class OpMul: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "1"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "1"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         return lhs + "*" + rhs;
     }
-    virtual std::string BinFuncName(void) const { return "fmul"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fmul"; }
 };
 
 /// Technically not a reduction, but fits the framework.
 class OpDiv: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "1.0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "1.0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         return "(" + lhs + "/" + rhs + ")";
     }
-    virtual std::string BinFuncName(void) const { return "fdiv"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fdiv"; }
 };
 
 class OpMin: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "MAXFLOAT"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "MAXFLOAT"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         return "mcw_fmin("+lhs + "," + rhs +")";
     }
-    virtual std::string BinFuncName(void) const { return "min"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "min"; }
 };
 
 class OpMax: public Reduction {
 public:
-    virtual std::string GetBottom(void) { return "-MAXFLOAT"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "-MAXFLOAT"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         return "mcw_fmax("+lhs + "," + rhs +")";
     }
-    virtual std::string BinFuncName(void) const { return "max"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "max"; }
 };
 class OpSumProduct: public SumOfProduct {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string Gen2(const std::string &lhs, const std::string &rhs) const SAL_OVERRIDE
     {
         return lhs + "*" + rhs;
     }
-    virtual std::string BinFuncName(void) const { return "fsop"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fsop"; }
 };
 namespace {
 struct SumIfsArgs {
@@ -1761,7 +1761,7 @@ public:
         const std::string &s, const FormulaTreeNodeRef& ft, SlidingFunctionBase* pCodeGen);
 
     /// Create buffer and pass the buffer to a given kernel
-    virtual size_t Marshal(cl_kernel k, int argno, int nVectorWidth, cl_program pProgram)
+    virtual size_t Marshal(cl_kernel k, int argno, int nVectorWidth, cl_program pProgram) SAL_OVERRIDE
     {
         unsigned i = 0;
         for (SubArgumentsType::iterator it = mvSubArguments.begin(), e= mvSubArguments.end(); it!=e;
@@ -1905,12 +1905,12 @@ public:
         return i;
     }
 
-    virtual void GenSlidingWindowFunction(std::stringstream &ss) {
+    virtual void GenSlidingWindowFunction(std::stringstream &ss) SAL_OVERRIDE {
         for (unsigned i = 0; i < mvSubArguments.size(); i++)
             mvSubArguments[i]->GenSlidingWindowFunction(ss);
         mpCodeGen->GenSlidingWindowFunction(ss, mSymName, mvSubArguments);
     }
-    virtual void GenDeclRef(std::stringstream &ss) const
+    virtual void GenDeclRef(std::stringstream &ss) const SAL_OVERRIDE
     {
         for (unsigned i = 0; i < mvSubArguments.size(); i++)
         {
@@ -1919,7 +1919,7 @@ public:
             mvSubArguments[i]->GenDeclRef(ss);
         }
     }
-    virtual void GenDecl(std::stringstream &ss) const
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         for (SubArgumentsType::const_iterator it = mvSubArguments.begin(), e= mvSubArguments.end(); it!=e;
             ++it) {
@@ -1929,7 +1929,7 @@ public:
         }
     }
 
-    virtual size_t GetWindowSize(void) const
+    virtual size_t GetWindowSize(void) const SAL_OVERRIDE
     {
         size_t nCurWindowSize = 0;
         for (unsigned i = 0; i < mvSubArguments.size(); i++)
@@ -1942,7 +1942,7 @@ public:
     }
 
     /// When declared as input to a sliding window function
-    virtual void GenSlidingWindowDecl(std::stringstream &ss) const
+    virtual void GenSlidingWindowDecl(std::stringstream &ss) const SAL_OVERRIDE
     {
         for (SubArgumentsType::const_iterator it = mvSubArguments.begin(), e= mvSubArguments.end(); it!=e;
             ++it)
@@ -1954,7 +1954,7 @@ public:
     }
     /// Generate either a function call to each children
     /// or direclty inline it if we are already inside a loop
-    virtual std::string GenSlidingWindowDeclRef(bool nested=false) const
+    virtual std::string GenSlidingWindowDeclRef(bool nested=false) const SAL_OVERRIDE
     {
         std::stringstream ss;
         if (!nested)
@@ -1975,7 +1975,7 @@ public:
         }
         return ss.str();
     }
-    virtual std::string DumpOpName(void) const
+    virtual std::string DumpOpName(void) const SAL_OVERRIDE
     {
         std::string t = "_" + mpCodeGen->BinFuncName();
         for (unsigned i = 0; i < mvSubArguments.size(); i++)
@@ -1983,7 +1983,7 @@ public:
         return t;
     }
     virtual void DumpInlineFun(std::set<std::string>& decls,
-                                std::set<std::string>& funs) const
+                                std::set<std::string>& funs) const SAL_OVERRIDE
     {
         mpCodeGen->BinInlineFun(decls,funs);
         for (unsigned i = 0; i < mvSubArguments.size(); i++)
diff --git a/sc/source/core/opencl/op_addin.hxx b/sc/source/core/opencl/op_addin.hxx
index 69936605b768..6ed46a9c78ec 100644
--- a/sc/source/core/opencl/op_addin.hxx
+++ b/sc/source/core/opencl/op_addin.hxx
@@ -18,8 +18,8 @@ class OpBesselj: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Besselj"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Besselj"; }
 };
 
 }}
diff --git a/sc/source/core/opencl/op_array.hxx b/sc/source/core/opencl/op_array.hxx
index 5e74ebbed592..57fa7e6cbef5 100644
--- a/sc/source/core/opencl/op_array.hxx
+++ b/sc/source/core/opencl/op_array.hxx
@@ -18,24 +18,24 @@ class OpSumX2MY2: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "SumX2MY2"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SumX2MY2"; }
 };
 
 class OpSumX2PY2: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "SumX2PY2"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SumX2PY2"; }
 };
 
 class OpSumXMY2: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "SumXMY2"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SumXMY2"; }
 };
 }}
 
diff --git a/sc/source/core/opencl/op_database.hxx b/sc/source/core/opencl/op_database.hxx
index 27852c8c2d1d..cf9706212514 100644
--- a/sc/source/core/opencl/op_database.hxx
+++ b/sc/source/core/opencl/op_database.hxx
@@ -19,88 +19,88 @@ class OpDmax: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dmax"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dmax"; }
 };
 
 class OpDmin: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dmin"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dmin"; }
 };
 
 class OpDproduct: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dproduct"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dproduct"; }
 };
 
 class OpDaverage: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Daverage"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Daverage"; }
 };
 
 class OpDstdev: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dstdev"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dstdev"; }
 };
 
 class OpDstdevp: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dstdevp"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dstdevp"; }
 };
 
 class OpDsum: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dsum"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dsum"; }
 };
 
 class OpDvar: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dvar"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dvar"; }
 };
 
 class OpDvarp: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dvarp"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dvarp"; }
 };
 
 class OpDcount: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dcount"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dcount"; }
 };
 
 class OpDcount2: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-             const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Dcount2"; }
+             const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dcount2"; }
 };
 
 
diff --git a/sc/source/core/opencl/op_financial.hxx b/sc/source/core/opencl/op_financial.hxx
index 2ddfa051f453..fae06a6553a1 100644
--- a/sc/source/core/opencl/op_financial.hxx
+++ b/sc/source/core/opencl/op_financial.hxx
@@ -18,232 +18,232 @@ class RRI: public SlidingFunctionBase
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual bool takeString() const { return false; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual bool takeString() const SAL_OVERRIDE { return false; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 
 class OpRRI:public RRI
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "RRI"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "RRI"; }
 };
 
 class OpNominal: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "NOMINAL_ADD"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "NOMINAL_ADD"; }
 };
 
 class OpDollarde:public Normal
 {
 public:
-        virtual std::string GetBottom(void) { return "0"; }
+        virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
         virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-        virtual std::string BinFuncName(void) const { return "Dollarde"; }
+        virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dollarde"; }
 
 };
 
 class OpDollarfr:public Normal
 {
 public:
-        virtual std::string GetBottom(void) { return "0"; }
+        virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
         virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-        virtual std::string BinFuncName(void) const { return "Dollarfr"; }
+        virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Dollarfr"; }
 
 };
 
 class OpDISC: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "DISC"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "DISC"; }
 };
 
 class OpINTRATE: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "INTRATE"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "INTRATE"; }
 };
 
 class OpFV: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-        std::set<std::string>& );
+        std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const {
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE {
         return "FV"; }
 };
 
 class OpIPMT: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-        std::set<std::string>& );
+        std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const {
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE {
         return "IPMT"; }
 };
 
 class OpISPMT: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "ISPMT"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ISPMT"; }
 };
 
 class OpDuration: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Duration"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Duration"; }
 };
 
 class OpDuration_ADD: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-                                     std::set<std::string>& );
+                                     std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const {
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE {
         return "Duration_ADD"; }
 };
 class OpMDuration: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-        std::set<std::string>& );
+        std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const {return "MDuration"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE {return "MDuration"; }
 };
 
 class Fvschedule: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 };
 
 class Cumipmt: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class IRR: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 };
 
 class OpIRR: public IRR
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "IRR"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "IRR"; }
 };
 
 class XNPV: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 };
 
 class PriceMat: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 class OpSYD: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-     virtual std::string BinFuncName(void) const { return "SYD"; }
+     virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SYD"; }
 };
 
 class MIRR: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 };
 
 class OpEffective:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Effect_Add"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Effect_Add"; }
 };
 
 class OpCumipmt: public Cumipmt
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "Cumipmt"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Cumipmt"; }
 };
 
 class OpXNPV: public XNPV
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "XNPV"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "XNPV"; }
 
 };
 
@@ -251,47 +251,47 @@ class OpTbilleq: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "fTbilleq"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fTbilleq"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpCumprinc: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "cumprinc"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "cumprinc"; }
 };
 
 class OpAccrintm: public Normal
 {
  public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Accrintm"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Accrintm"; }
 };
 class OpAccrint: public Normal
 {
  public:
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Accrint"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Accrint"; }
 };
 
 class OpYield: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Yield"; }
-     virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Yield"; }
+     virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 
@@ -299,123 +299,123 @@ class OpSLN: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "SLN"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SLN"; }
 };
 
 class OpFvschedule: public Fvschedule
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "Fvschedule"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Fvschedule"; }
 };
 
 class OpYieldmat: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Yieldmat"; }
-     virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Yieldmat"; }
+     virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpPMT: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "PMT"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "PMT"; }
 };
 class OpNPV: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "NPV"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "NPV"; }
 };
 
 class OpPrice: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Price"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Price"; }
 };
 
 class OpNper: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "NPER"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "NPER"; }
 };
 class OpOddlprice: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>&,
-        std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Oddlprice"; }
+        std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Oddlprice"; }
 };
 class OpOddlyield: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-        std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Oddlyield"; }
+        std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Oddlyield"; }
 };
 class OpPriceDisc: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>&,
-        std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "PriceDisc"; }
+        std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "PriceDisc"; }
 };
 class OpPPMT: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "PPMT"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "PPMT"; }
 };
 
 class OpCoupdaybs:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0";}
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0";}
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Coupdaybs"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Coupdaybs"; }
 
 };
 
 class OpCoupdays:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0";}
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0";}
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Coupdays";}
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Coupdays";}
 
 };
 
 class OpCoupdaysnc:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0";}
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0";}
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Coupdaysnc"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Coupdaysnc"; }
 
 };
 
@@ -423,9 +423,9 @@ class OpCouppcd:public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Couppcd"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Couppcd"; }
 
 };
 
@@ -433,147 +433,147 @@ class OpCoupncd:public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "Coupncd"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Coupncd"; }
 
 };
 
 class OpCoupnum:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0";}
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0";}
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "Coupnum"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Coupnum"; }
 
 };
 class OpDDB:public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-     virtual std::string BinFuncName(void) const { return "DDB"; }
+     virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "DDB"; }
 };
 class OpDB:public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-     virtual std::string BinFuncName(void) const { return "DB"; }
+     virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "DB"; }
 };
 class OpAmordegrc:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0";}
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0";}
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-        const std::string &sSymName, SubArguments& vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "Amordegrc"; }
+        const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Amordegrc"; }
 };
 class OpAmorlinc:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0";}
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0";}
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-        const std::string &sSymName, SubArguments& vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "Amorlinc"; }
+        const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Amorlinc"; }
 };
 
 class OpReceived:public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Received"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Received"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpYielddisc: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Yielddisc"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Yielddisc"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpTbillprice: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "fTbillprice"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fTbillprice"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpPriceMat:public PriceMat
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "PriceMat"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "PriceMat"; }
 };
 
 class RATE: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 class OpIntrate: public RATE {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "rate"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "rate"; }
 };
 
 class OpTbillyield: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "fTbillyield"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "fTbillyield"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpMIRR: public MIRR
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
-    virtual std::string BinFuncName(void) const { return "MIRR"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "MIRR"; }
 };
 
 class OpPV: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-                const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "PV"; }
+                const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "PV"; }
 };
 
 class OpVDB: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "VDB"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "VDB"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpXirr: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Xirr"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Xirr"; }
 };
 
 }}
diff --git a/sc/source/core/opencl/op_logical.hxx b/sc/source/core/opencl/op_logical.hxx
index b121723c030c..ff548e13bfb0 100644
--- a/sc/source/core/opencl/op_logical.hxx
+++ b/sc/source/core/opencl/op_logical.hxx
@@ -19,30 +19,30 @@ class OpAnd: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "And"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "And"; }
 };
 
 class OpOr: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Or"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Or"; }
 };
 class OpNot: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Not"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Not"; }
 };
 class OpXor: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Xor"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Xor"; }
 };
 
 }}
diff --git a/sc/source/core/opencl/op_math.hxx b/sc/source/core/opencl/op_math.hxx
index a8d3d7f892c9..51a0379eed18 100644
--- a/sc/source/core/opencl/op_math.hxx
+++ b/sc/source/core/opencl/op_math.hxx
@@ -18,33 +18,33 @@ class OpCos: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Cos"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Cos"; }
 };
 class OpSec: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Sec"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Sec"; }
 };
 class OpSecH: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "SecH"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SecH"; }
 };
 class OpMROUND: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "MROUND"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "MROUND"; }
 };
 
 
@@ -52,16 +52,16 @@ class OpCsc: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Csc"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Csc"; }
 };
 class OpSumIfs: public CheckVariables
 {
 public:
     OpSumIfs(void): CheckVariables(), mNeedReductionKernel(false) {}
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "SumIfs"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SumIfs"; }
     bool NeedReductionKernel(void) const { return mNeedReductionKernel; }
 protected:
     bool mNeedReductionKernel;
@@ -70,429 +70,429 @@ class OpCosh: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Cosh"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Cosh"; }
 };
 class OpSinh: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Sinh"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Sinh"; }
 };
 class OpSin: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Sin"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Sin"; }
 };
 class OpAbs:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScAbs"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScAbs"; }
 };
 class OpArcCos:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScACos"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScACos"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
 };
 class OpArcCosHyp:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "1.0"; }
-    virtual std::string BinFuncName(void) const { return "ScACosH"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "1.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScACosH"; }
 };
 class OpTan: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Tan"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Tan"; }
 };
 class OpTanH: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "TanH"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "TanH"; }
 };
 class OpSqrt: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Sqrt"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Sqrt"; }
 };
 class OpArcCot:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScACot"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScACot"; }
 };
 class OpArcCotHyp:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "2.0"; }
-    virtual std::string BinFuncName(void) const { return "ScACotH"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "2.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScACotH"; }
 };
 class OpArcSin:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScASin"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScASin"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
 };
 class OpArcSinHyp:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScASinH"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScASinH"; }
 };
 class OpTrunc: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Trunc"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Trunc"; }
 };
 class OpArcTan2:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScATan2"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScATan2"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
 };
 class OpArcTan:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScATan"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScATan"; }
 };
 class OpArcTanH:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScATanH"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScATanH"; }
 };
 class OpBitAnd:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-        virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScBitAnd"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+        virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScBitAnd"; }
 };
 class OpBitOr:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScBitOr"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScBitOr"; }
 };
 class OpBitXor:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScBitXor"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScBitXor"; }
 };
 class OpBitLshift:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScBitLshift"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScBitLshift"; }
 };
 class OpBitRshift:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScBitRshift"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScBitRshift"; }
 };
 class OpLn: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Ln"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Ln"; }
 };
 class OpRound: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Round"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Round"; }
 };
 class OpRoundUp: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "RoundUp"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "RoundUp"; }
 };
 class OpRoundDown: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "RoundDown"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "RoundDown"; }
 };
 class OpInt: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Int"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Int"; }
 };
 class OpRadians: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Radians"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Radians"; }
 };
 class OpIsEven: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "IsEven"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "IsEven"; }
 };
 class OpIsOdd: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "IsOdd"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "IsOdd"; }
 };
 class OpCot: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Cot"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Cot"; }
 };
 class OpSumSQ: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "SumSQ"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SumSQ"; }
 };
 class OpCoth: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-            std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Coth"; }
+            std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Coth"; }
 };
 class OpPower: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Power"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Power"; }
 };
 class OpOdd: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Odd"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Odd"; }
 };
 class OpFloor: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Floor"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Floor"; }
 };
 class OpCscH: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "CscH"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "CscH"; }
 };
 class OpCeil:public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScCeil"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScCeil"; }
 };
 class OpExp: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Exp"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Exp"; }
 };
 class OpLog10: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Log10"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Log10"; }
 };
 class OpConvert: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Convert"; }
-    virtual bool takeString() const { return true; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Convert"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
 
 };
 class OpEven: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Even"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Even"; }
 };
 class OpAverageIfs: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "AverageIfs"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "AverageIfs"; }
 };
 class OpCountIfs: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "CountIfs"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "CountIfs"; }
 };
 class OpMod: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Mod"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Mod"; }
 };
 class OpProduct: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Product"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Product"; }
 };
 class OpSqrtPi: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "SqrtPi"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SqrtPi"; }
 };
 
 class OpCombina: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Combina"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Combina"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 class OpLog: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Log"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Log"; }
 };
 class OpKombin: public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "ScKombin"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ScKombin"; }
 };
 class OpAverageIf: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "AverageIf"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "AverageIf"; }
 };
 class OpDeg: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Degrees"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Degrees"; }
 };
 class OpCountIf: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Countif"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Countif"; }
 };
 class OpFact: public Normal{
 public:
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-        const std::string &sSymName, SubArguments& vSubArguments);
-    virtual std::string GetBottom(void) { return "0.0"; }
-    virtual std::string BinFuncName(void) const { return "Fact"; }
+        const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0.0"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Fact"; }
 };
 class OpSeriesSum: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "SeriesSum"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SeriesSum"; }
 };
 class OpSumIf: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "SumIf"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "SumIf"; }
 };
 class OpQuotient: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Quotient"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Quotient"; }
 };
 class OpNegSub: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "NegSub"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "NegSub"; }
 };
 
 }}
diff --git a/sc/source/core/opencl/op_spreadsheet.hxx b/sc/source/core/opencl/op_spreadsheet.hxx
index 73ca7336a5ee..3f1f43c6e791 100644
--- a/sc/source/core/opencl/op_spreadsheet.hxx
+++ b/sc/source/core/opencl/op_spreadsheet.hxx
@@ -18,8 +18,8 @@ class OpVLookup: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "VLookup"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "VLookup"; }
 };
 
 }}
diff --git a/sc/source/core/opencl/op_statistical.hxx b/sc/source/core/opencl/op_statistical.hxx
index 570994607566..24c598906c83 100644
--- a/sc/source/core/opencl/op_statistical.hxx
+++ b/sc/source/core/opencl/op_statistical.hxx
@@ -18,184 +18,184 @@ class OpStandard: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Standard"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Standard"; }
 };
 class OpExponDist: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "ExponDist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ExponDist"; }
 };
 class OpVar: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Var"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Var"; }
 };
 class OpSTEYX: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "STEYX"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "STEYX"; }
 };
 class OpVarP: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "VarP"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "VarP"; }
 };
 class OpZTest: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "ZTest"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ZTest"; }
 };
 class OpStDevP: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "StDevP"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "StDevP"; }
 };
 
 class OpStDev: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "StDev"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "StDev"; }
 };
 class OpSkewp: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Skewp"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Skewp"; }
 };
 class OpSlope: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Slope"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Slope"; }
 };
 class OpWeibull: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Weibull"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Weibull"; }
 };
 class OpFdist: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "Fdist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Fdist"; }
 };
 class OpTDist: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "TDist"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "TDist"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
 };
 class OpTInv: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "TInv"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "TInv"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
 };
 class OpTTest: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "TTest"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "TTest"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
 };
 class OpSkew: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Skew"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Skew"; }
 };
 class OpFisher: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Fisher"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Fisher"; }
 };
 
 class OpFisherInv: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "FisherInv"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "FisherInv"; }
 };
 
 class OpGamma: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Gamma"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Gamma"; }
 };
 
 class OpCorrel: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-        const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Correl"; }
+        const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Correl"; }
 };
 
 class OpNegbinomdist: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpNegbinomdist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpNegbinomdist"; }
 };
 
 class OpPearson: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpPearson"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpPearson"; }
 };
 
 class OpGammaLn: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "GammaLn"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "GammaLn"; }
 };
 
 class OpGauss: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
        virtual void BinInlineFun(std::set<std::string>& ,
-        std::set<std::string>& );
-    virtual std::string BinFuncName(void) const { return "Gauss"; }
+        std::set<std::string>& ) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Gauss"; }
 };
 
 class OpGeoMean: public CheckVariables
@@ -203,8 +203,8 @@ class OpGeoMean: public CheckVariables
 public:
     OpGeoMean(void): CheckVariables(), mNeedReductionKernel(true) {}
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "GeoMean"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "GeoMean"; }
     bool NeedReductionKernel(void) const { return mNeedReductionKernel; }
 protected:
     bool mNeedReductionKernel;
@@ -214,331 +214,331 @@ class OpHarMean: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "HarMean"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "HarMean"; }
 };
 
 class OpRsq: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpRsq"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpRsq"; }
 };
 class OpNormdist:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpNormdist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpNormdist"; }
 };
 class OpMedian:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpMedian"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpMedian"; }
 };
 class OpNormsdist:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "OpNormsdist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpNormsdist"; }
 };
 class OpNorminv:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-     virtual std::string BinFuncName(void) const { return "OpNorminv"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+     virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpNorminv"; }
 };
 class OpNormsinv:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-     virtual std::string BinFuncName(void) const { return "OpNormsinv"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+     virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpNormsinv"; }
 };
 class OpPhi:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpPhi"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpPhi"; }
 };
 class OpKurt: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Kurt"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Kurt"; }
 };
 class OpCovar: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Covar"; }
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Covar"; }
 };
 
 class OpVariationen:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpVariationen"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpVariationen"; }
 };
 class OpVariationen2:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpVariationen2";}
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpVariationen2";}
 };
 
 class OpConfidence: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-        std::set<std::string>& );
+        std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "Confidence"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Confidence"; }
 };
 class OpIntercept: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Intercept"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Intercept"; }
 };
 class OpLogInv: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "LogInv"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "LogInv"; }
 };
 class OpCritBinom: public Normal
 {
 public:
-    virtual std::string GetBottom(void) { return "0"; }
+    virtual std::string GetBottom(void) SAL_OVERRIDE { return "0"; }
 
     virtual void GenSlidingWindowFunction(std::stringstream& ss,
-            const std::string &sSymName, SubArguments& vSubArguments);
+            const std::string &sSymName, SubArguments& vSubArguments) SAL_OVERRIDE;
     virtual void BinInlineFun(std::set<std::string>& ,
-        std::set<std::string>& );
+        std::set<std::string>& ) SAL_OVERRIDE;
 
-    virtual std::string BinFuncName(void) const { return "CritBinom"; }
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "CritBinom"; }
 };
 class OpForecast: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "Forecast"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "Forecast"; }
 };
 class OpLogNormDist: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "LogNormdist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "LogNormdist"; }
 };
 class OpGammaDist: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs);
-    virtual std::string BinFuncName(void) const { return "GammaDist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "GammaDist"; }
 };
 class OpHypGeomDist:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpHypGeomDist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpHypGeomDist"; }
 };
 class OpChiDist:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "OpChiDist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpChiDist"; }
 };
 class OpBinomdist:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "OpBinomdist"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpBinomdist"; }
 };
 class OpChiSqDist: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "ChiSqDist"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ChiSqDist"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 
 class OpChiSqInv: public CheckVariables
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "ChiSqInv"; }
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& );
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "ChiSqInv"; }
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>& ) SAL_OVERRIDE;
 };
 class OpChiInv:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "OpChiInv"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpChiInv"; }
 };
 class OpPoisson:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "OpPoisson"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpPoisson"; }
 };
 
 class OpGammaInv: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs
-);
-    virtual std::string BinFuncName(void) const { return "GammaInv"; }
+) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "GammaInv"; }
 };
 class OpFInv: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs
-);
-    virtual std::string BinFuncName(void) const { return "FInv"; }
+) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "FInv"; }
 };
 class OpFTest: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs
-);
-    virtual std::string BinFuncName(void) const { return "FTest"; }
+) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "FTest"; }
 };
 class OpDevSq: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "DevSq"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "DevSq"; }
 };
 class OpB: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs
-);
-    virtual std::string BinFuncName(void) const { return "B"; }
+) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "B"; }
 };
 class OpBetaDist: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
     void BinInlineFun(std::set<std::string>& decls,std::set<std::string>& funs
-);
-    virtual std::string BinFuncName(void) const { return "BetaDist"; }
+) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "BetaDist"; }
 };
 class OpBetainv:public Normal{
     public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&);
-    virtual std::string BinFuncName(void) const { return "OpBetainv"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual void BinInlineFun(std::set<std::string>& ,std::set<std::string>&) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpBetainv"; }
 };
 class OpMinA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpMinA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpMinA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpCountA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpCountA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpCountA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpMaxA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpMaxA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpMaxA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpVarA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpVarA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpVarA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpVarPA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpVarPA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpVarPA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpStDevPA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpStDevPA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpStDevPA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpAverageA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpAverageA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpAverageA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpStDevA: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "OpStDevA"; }
-    virtual bool takeString() const { return true; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "OpStDevA"; }
+    virtual bool takeString() const SAL_OVERRIDE { return true; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 class OpAveDev: public Normal
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual std::string BinFuncName(void) const { return "AveDev"; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual std::string BinFuncName(void) const SAL_OVERRIDE { return "AveDev"; }
 };
 
 }}
diff --git a/sc/source/core/opencl/opbase.hxx b/sc/source/core/opencl/opbase.hxx
index a75e160cefa1..8a15c136523b 100644
--- a/sc/source/core/opencl/opbase.hxx
+++ b/sc/source/core/opencl/opbase.hxx
@@ -200,27 +200,27 @@ public:
 
     const std::string &GetNameAsString(void) const { return mSymName; }
     /// Generate declaration
-    virtual void GenDecl(std::stringstream &ss) const;
+    virtual void GenDecl(std::stringstream &ss) const SAL_OVERRIDE;
     /// When declared as input to a sliding window function
-    virtual void GenSlidingWindowDecl(std::stringstream &ss) const;
+    virtual void GenSlidingWindowDecl(std::stringstream &ss) const SAL_OVERRIDE;
 
     /// When referenced in a sliding window function
-    virtual std::string GenSlidingWindowDeclRef(bool=false) const;
+    virtual std::string GenSlidingWindowDeclRef(bool=false) const SAL_OVERRIDE;
 
     /// Create buffer and pass the buffer to a given kernel
-    virtual size_t Marshal(cl_kernel, int, int, cl_program);
+    virtual size_t Marshal(cl_kernel, int, int, cl_program) SAL_OVERRIDE;
 
     virtual ~VectorRef();
 
-    virtual void GenSlidingWindowFunction(std::stringstream &) {}
+    virtual void GenSlidingWindowFunction(std::stringstream &) SAL_OVERRIDE {}
     const std::string &GetSymName(void) const { return mSymName; }
-    virtual size_t GetWindowSize(void) const;
-    virtual std::string DumpOpName(void) const { return std::string(""); }
+    virtual size_t GetWindowSize(void) const SAL_OVERRIDE;
+    virtual std::string DumpOpName(void) const SAL_OVERRIDE { return std::string(""); }
     virtual void DumpInlineFun(std::set<std::string>& ,
-        std::set<std::string>& ) const {}
+        std::set<std::string>& ) const SAL_OVERRIDE {}
     const std::string& GetName(void) const { return mSymName; }
     virtual cl_mem GetCLBuffer(void) const { return mpClmem; }
-    virtual bool NeedParallelReduction(void) const { return false; }
+    virtual bool NeedParallelReduction(void) const SAL_OVERRIDE { return false; }
 
 protected:
     // Used by marshaling
@@ -261,9 +261,9 @@ class Normal: public SlidingFunctionBase
 {
 public:
     virtual void GenSlidingWindowFunction(std::stringstream &ss,
-            const std::string &sSymName, SubArguments &vSubArguments);
-    virtual bool takeString() const { return false; }
-    virtual bool takeNumeric() const { return true; }
+            const std::string &sSymName, SubArguments &vSubArguments) SAL_OVERRIDE;
+    virtual bool takeString() const SAL_OVERRIDE { return false; }
+    virtual bool takeNumeric() const SAL_OVERRIDE { return true; }
 };
 
 class CheckVariables:public Normal