Merge pull request #13328 from ghalliday/issue23496

HPCC-23496 Remove unused legacy ITemplateContext

Reviewed-By: Shamser Ahmed <shamser.ahmed@lexisnexis.co.uk>
Reviewed-By: Richard Chapman <rchapman@hpccsystems.com>

common/fileview2/fvtransform.cpp

@@ -244,7 +244,7 @@ void ViewFieldECLTransformer::transform(unsigned & lenTarget, char * & target, u
     Owned<IErrorReceiver> errorReporter = createThrowingErrorReceiver();
     OwnedHqlExpr call = createBoundFunction(errorReporter, function, actuals, NULL, true);
     OwnedHqlExpr castValue = ensureExprType(call, utf8Type);
-    OwnedHqlExpr folded = quickFoldExpression(castValue, NULL, 0);
+    OwnedHqlExpr folded = quickFoldExpression(castValue, 0);
     IValue * foldedValue = folded->queryValue();
     assertex(foldedValue);
     unsigned len = foldedValue->queryType()->getStringLen();

ecl/eclcc/eclcc.cpp

@@ -1028,7 +1028,7 @@ void EclCC::evaluateResult(EclCompileInstance & instance)
         query = query->queryChild(0);
     if (query->getOperator()==no_createdictionary)
         query = query->queryChild(0);
-    OwnedHqlExpr folded = foldHqlExpression(instance.queryErrorProcessor(), query, NULL, HFOthrowerror|HFOloseannotations|HFOforcefold|HFOfoldfilterproject|HFOconstantdatasets);
+    OwnedHqlExpr folded = foldHqlExpression(instance.queryErrorProcessor(), query, HFOthrowerror|HFOloseannotations|HFOforcefold|HFOfoldfilterproject|HFOconstantdatasets);
     StringBuffer out;
     IValue *result = folded->queryValue();
     if (result)

ecl/hql/hqlfold.cpp

@@ -675,7 +675,7 @@ bool checkExternFoldable(IHqlExpression* expr, unsigned foldOptions, StringBuffe
     return true;
 }
 
-void *loadExternalEntryPoint(IHqlExpression* expr, unsigned foldOptions, ITemplateContext *templateContext, const char *library, const char *entrypoint, HINSTANCE &hDLL)
+void *loadExternalEntryPoint(IHqlExpression* expr, unsigned foldOptions, const char *library, const char *entrypoint, HINSTANCE &hDLL)
 {
     IHqlExpression * funcdef = expr->queryExternalDefinition();
     IHqlExpression *body = funcdef->queryChild(0);
@@ -709,7 +709,7 @@ void *loadExternalEntryPoint(IHqlExpression* expr, unsigned foldOptions, ITempla
 extern __int64 foldExternalCallStub(void * fh, double * doubleresult, size_t len, void * params);
 #endif
 
-IValue * doFoldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplateContext *templateContext, const char *library, const char *entrypoint, void *fh)
+IValue * doFoldExternalCall(IHqlExpression* expr, unsigned foldOptions, const char *library, const char *entrypoint, void *fh)
 {
     // NOTE - on OSX there are compiler bugs that prevent exceptions thrown from within this function from properly unwinding.
     // Hence anything that can throw an exception should be pre-checked in one of the functions above.
@@ -721,9 +721,6 @@ IValue * doFoldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplat
     // the called function
     FuncCallStack fstack(getBoolAttribute(body, passParameterMetaAtom, false), DEFAULTSTACKSIZE);
     
-    if(body->hasAttribute(templateAtom))
-        fstack.pushPtr(templateContext);
-
     //if these were allowed to be optional - then the following code would be needed
     if(body->hasAttribute(contextAtom) || body->hasAttribute(globalContextAtom))
         fstack.pushPtr(NULL);
@@ -1345,7 +1342,7 @@ IValue * doFoldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplat
     return result;
 }
 
-IValue * foldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplateContext *templateContext)
+IValue * foldExternalCall(IHqlExpression* expr, unsigned foldOptions)
 {
     StringBuffer library;
     StringBuffer entry;
@@ -1353,13 +1350,13 @@ IValue * foldExternalCall(IHqlExpression* expr, unsigned foldOptions, ITemplateC
         return NULL;
     // NOTE - we do not call FreeSharedObject(hDLL) - the embedded language folding requires that the dll stay loaded, and it's also more efficient for other cases
     HINSTANCE hDll;
-    void *funcptr = loadExternalEntryPoint(expr, foldOptions, templateContext, library.str(), entry.str(), hDll);
+    void *funcptr = loadExternalEntryPoint(expr, foldOptions, library.str(), entry.str(), hDll);
     if (!funcptr)
     {
         UERRLOG("Failed to load function %s", entry.str());
         return NULL;
     }
-    return doFoldExternalCall(expr, foldOptions, templateContext, library.str(), entry.str(), funcptr);
+    return doFoldExternalCall(expr, foldOptions, library.str(), entry.str(), funcptr);
 }
 
 //------------------------------------------------------------------------------------------
@@ -1609,7 +1606,7 @@ IHqlExpression *deserializeConstantSet(ITypeInfo *type, bool isAll, size32_t len
     }
 }
 
-IHqlExpression * foldEmbeddedCall(IHqlExpression* expr, unsigned foldOptions, ITemplateContext *templateContext)
+IHqlExpression * foldEmbeddedCall(IHqlExpression* expr, unsigned foldOptions)
 {
     if (!checkEmbeddedFoldable(expr, foldOptions))
         return NULL;
@@ -1649,7 +1646,7 @@ IHqlExpression * foldEmbeddedCall(IHqlExpression* expr, unsigned foldOptions, IT
     IHqlExpression *languageAttr = body->queryAttribute(languageAtom);
     HqlExprArray noParams;
     OwnedHqlExpr langLoadCall = createTranslatedExternalCall(NULL, languageAttr->queryChild(0), noParams);
-    Owned<IValue> plugin = foldExternalCall(langLoadCall, foldOptions, templateContext);
+    Owned<IValue> plugin = foldExternalCall(langLoadCall, foldOptions);
     if (plugin == nullptr)
         return NULL;
     // Slightly odd code - the getEmbedContext function returns a linked object or a singleton depending on a flag
@@ -2419,7 +2416,7 @@ static IHqlExpression * foldHashXX(IHqlExpression * expr)
 
 //---------------------------------------------------------------------------
 
-IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOptions, ITemplateContext * templateContext)
+IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOptions)
 {
     DBZaction onZero = (foldOptions & HFOforcefold) ? DBZfail : DBZnone;
     node_operator op = expr->getOperator();
@@ -3783,7 +3780,7 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
         }
     case no_externalcall:
         {   //external function folding. 
-            IValue * result = foldExternalCall(expr, foldOptions, templateContext);
+            IValue * result = foldExternalCall(expr, foldOptions);
             if (result) 
                 return createConstant(result);
             break;
@@ -3799,7 +3796,7 @@ IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned foldOption
             IHqlExpression * body = def->queryChild(0);
             if (body->getOperator() == no_outofline && body->queryChild(0)->getOperator()==no_embedbody)
             {
-                IHqlExpression * result = foldEmbeddedCall(expr, foldOptions, templateContext);
+                IHqlExpression * result = foldEmbeddedCall(expr, foldOptions);
                 if (result)
                     return result;
                 break;
@@ -5382,7 +5379,7 @@ IHqlExpression * CExprFolderTransformer::doFoldTransformed(IHqlExpression * unfo
     if ((unfolded != body) && !expr->isAnnotation() && !expr->queryValue())
         expr.setown(unfolded->cloneAllAnnotations(expr));
 #else
-    OwnedHqlExpr expr = foldConstantOperator(unfolded, foldOptions, templateContext);
+    OwnedHqlExpr expr = foldConstantOperator(unfolded, foldOptions);
 #endif
 
     node_operator op = expr->getOperator();
@@ -5897,8 +5894,8 @@ FolderTransformInfo::~FolderTransformInfo()
 }
 
 static HqlTransformerInfo cExprFolderTransformerInfo("CExprFolderTransformer");
-CExprFolderTransformer::CExprFolderTransformer(IErrorReceiver & _errorProcessor, ITemplateContext * _templateContext, unsigned _options)
-: NewHqlTransformer(cExprFolderTransformerInfo), templateContext(_templateContext), errorProcessor(_errorProcessor)
+CExprFolderTransformer::CExprFolderTransformer(IErrorReceiver & _errorProcessor, unsigned _options)
+: NewHqlTransformer(cExprFolderTransformerInfo), errorProcessor(_errorProcessor)
 {
     foldOptions = _options;
 }
@@ -7082,7 +7079,7 @@ IHqlExpression * foldHqlExpression(IHqlExpression * expr)
     return foldHqlExpression(errorProcessor, expr);
 }
 
-IHqlExpression * foldHqlExpression(IErrorReceiver & errorProcessor, IHqlExpression * expr, ITemplateContext *templateContext, unsigned foldOptions)
+IHqlExpression * foldHqlExpression(IErrorReceiver & errorProcessor, IHqlExpression * expr, unsigned foldOptions)
 {
     if (!expr)
         return NULL;
@@ -7103,7 +7100,7 @@ IHqlExpression * foldHqlExpression(IErrorReceiver & errorProcessor, IHqlExpressi
         break;
     }
 
-    CExprFolderTransformer folder(errorProcessor, templateContext, foldOptions);
+    CExprFolderTransformer folder(errorProcessor, foldOptions);
 
 #if 0
     dbglogExpr(expr);
@@ -7123,7 +7120,7 @@ IHqlExpression * foldScopedHqlExpression(IErrorReceiver & errorProcessor, IHqlEx
     if (!expr)
         return NULL;
 
-    CExprFolderTransformer folder(errorProcessor, NULL, foldOptions);
+    CExprFolderTransformer folder(errorProcessor, foldOptions);
 
     if (dataset)
         folder.setScope(dataset);
@@ -7136,7 +7133,7 @@ IHqlExpression * foldScopedHqlExpression(IErrorReceiver & errorProcessor, IHqlEx
 
 void foldHqlExpression(IErrorReceiver & errorProcessor, HqlExprArray & tgt, HqlExprArray & src, unsigned foldOptions)
 {
-    CExprFolderTransformer folder(errorProcessor, NULL, foldOptions);
+    CExprFolderTransformer folder(errorProcessor, foldOptions);
     folder.transformRoot(src, tgt);
 }
 
@@ -7241,8 +7238,8 @@ static HqlTransformerInfo quickConstantTransformerInfo("QuickConstantTransformer
 class QuickConstantTransformer : public QuickHqlTransformer
 {
 public:
-    QuickConstantTransformer(ITemplateContext * _templateContext, unsigned _foldOptions) : 
-      QuickHqlTransformer(quickConstantTransformerInfo, NULL), templateContext(_templateContext), foldOptions(_foldOptions) {}
+    QuickConstantTransformer(unsigned _foldOptions) :
+      QuickHqlTransformer(quickConstantTransformerInfo, NULL), foldOptions(_foldOptions) {}
 
     virtual IHqlExpression * createTransformedBody(IHqlExpression * expr)
     {
@@ -7295,23 +7292,22 @@ public:
         }
 
         OwnedHqlExpr transformed = QuickHqlTransformer::createTransformedBody(expr);
-        return foldConstantOperator(transformed, foldOptions, templateContext);
+        return foldConstantOperator(transformed, foldOptions);
     }
 
 protected:
-    ITemplateContext *templateContext;
     unsigned foldOptions;
 };
 
-extern HQLFOLD_API IHqlExpression * quickFoldExpression(IHqlExpression * expr, ITemplateContext *context, unsigned options)
+extern HQLFOLD_API IHqlExpression * quickFoldExpression(IHqlExpression * expr, unsigned options)
 {
-    QuickConstantTransformer transformer(context, options);
+    QuickConstantTransformer transformer(options);
     return transformer.transform(expr);
 }
 
-extern HQLFOLD_API void quickFoldExpressions(HqlExprArray & target, const HqlExprArray & source, ITemplateContext *context, unsigned options)
+extern HQLFOLD_API void quickFoldExpressions(HqlExprArray & target, const HqlExprArray & source, unsigned options)
 {
-    QuickConstantTransformer transformer(context, options);
+    QuickConstantTransformer transformer(options);
     ForEachItemIn(i, source)
         target.append(*transformer.transform(&source.item(i)));
 }

ecl/hql/hqlfold.hpp

@@ -27,8 +27,6 @@
 #include "hqlexpr.hpp"
 #include "hqlstack.hpp"
 
-interface ITemplateContext;
-
 //Options for the constant folding...
 enum { 
     HFOx_op_not_x       = 0x0001,                       // constant fold X AND NOT X => false, X OR NOT X => true
@@ -45,14 +43,14 @@ enum {
 
 
 /* Fold a single IHqlExpression * node */
-extern HQLFOLD_API IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned options, ITemplateContext *context);
+extern HQLFOLD_API IHqlExpression * foldConstantOperator(IHqlExpression * expr, unsigned options);
 
 /* Fold an expression tree, but does not do anything with no_select/transform, so valid on non-normalized trees */
-extern HQLFOLD_API IHqlExpression * quickFoldExpression(IHqlExpression * expr, ITemplateContext *context=NULL, unsigned options=0);
-extern HQLFOLD_API void quickFoldExpressions(HqlExprArray & target, const HqlExprArray & source, ITemplateContext *context, unsigned options);
+extern HQLFOLD_API IHqlExpression * quickFoldExpression(IHqlExpression * expr, unsigned options=0);
+extern HQLFOLD_API void quickFoldExpressions(HqlExprArray & target, const HqlExprArray & source, unsigned options);
 
 extern HQLFOLD_API IHqlExpression * foldHqlExpression(IHqlExpression * expr); // No errors reported.
-extern HQLFOLD_API IHqlExpression * foldHqlExpression(IErrorReceiver & errorProcessor, IHqlExpression * expr, ITemplateContext *context=NULL, unsigned options=0);
+extern HQLFOLD_API IHqlExpression * foldHqlExpression(IErrorReceiver & errorProcessor, IHqlExpression * expr, unsigned options=0);
 extern HQLFOLD_API IHqlExpression * foldScopedHqlExpression(IErrorReceiver & errorProcessor, IHqlExpression * dataset, IHqlExpression * expr, unsigned options=0);
 extern HQLFOLD_API void foldHqlExpression(IErrorReceiver & errorProcessor, HqlExprArray & tgt, HqlExprArray & src, unsigned options=0);
 extern HQLFOLD_API IHqlExpression * getLowerCaseConstantExpr(IHqlExpression * expr);

ecl/hql/hqlfold.ipp

@@ -21,7 +21,6 @@
 #include "hqltrans.ipp"
 #include "hqlutil.hpp"
 
-interface ITemplateContext;
 typedef IValue * (*binaryFoldFunc)(IValue * left, IValue * right);
 
 #define FOLD_PARENT         NewHqlTransformer
@@ -67,7 +66,7 @@ class CExprFolderTransformer : public FOLD_PARENT, public NullFolderMixin
 {
     typedef FOLD_PARENT PARENT;
 public:
-    CExprFolderTransformer(IErrorReceiver & _errorProcessor, ITemplateContext *templateContext, unsigned _options);
+    CExprFolderTransformer(IErrorReceiver & _errorProcessor, unsigned _options);
 
     void setScope(IHqlExpression * expr)                { stopDatasetTransform(expr); }
 
@@ -111,7 +110,6 @@ private:
     virtual IHqlExpression * transformExpanded(IHqlExpression * expr);              
 
 protected:
-    ITemplateContext *templateContext;
     IErrorReceiver & errorProcessor;
     unsigned foldOptions;
     StringBuffer nodeText[2];

ecl/hql/hqlparse.cpp

@@ -80,64 +80,6 @@ public:
     }
 };
 
-// =========================== CTemplateContext =========================================
-
-class CTemplateContext : implements ITemplateContext, public CInterface
-{
-    HqlLex * lexer;
-    IXmlScope* m_xmlScope;
-    HqlLookupContext & m_lookupContext;
-    int m_startLine,m_startCol;
-
-public:
-    IMPLEMENT_IINTERFACE;
-
-    CTemplateContext(HqlLex * _lexer, HqlLookupContext & lookupContext, IXmlScope* xmlScope, int startLine,int startCol)
-     : lexer(_lexer), m_xmlScope(xmlScope), m_lookupContext(lookupContext),
-       m_startLine(startLine), m_startCol(startCol) {}
-
-    virtual IXmlScope* queryXmlScope()  { return m_xmlScope; }
-    virtual IEclRepository* queryDataServer()  { return m_lookupContext.queryRepository(); }
-
-    // convenient functions
-    virtual bool isInModule(const char* moduleName, const char* attrName) { return ::isInModule(m_lookupContext, moduleName,attrName); }
-    virtual StringBuffer& getDataType(const char* field, StringBuffer& tgt) { return lexer->doGetDataType(tgt, field, m_startLine, m_startCol); }
-
-    virtual StringBuffer& mangle(const char* src, StringBuffer& mangled) { return ::mangle(m_lookupContext.errs,src,mangled,false); }
-    virtual StringBuffer& demangle(const char* mangled, StringBuffer& demangled) { return ::mangle(m_lookupContext.errs,mangled,demangled,true); }
-
-    virtual void reportError(int errNo,const char* format,...)  __attribute__((format(printf,3,4)));
-    virtual void reportWarning(int warnNo,const char* format,...) __attribute__((format(printf,3,4)));;
-};
-
-void CTemplateContext::reportError(int errNo,const char* format,...)
-{
-    if (m_lookupContext.errs)
-    {
-        va_list args;
-        va_start(args, format);
-        StringBuffer msg;
-        msg.valist_appendf(format,args);
-        m_lookupContext.errs->reportError(errNo,msg.str(),NULL,m_startLine,m_startCol,0);
-        va_end(args);
-    }
-}
-
-void CTemplateContext::reportWarning(int warnNo,const char* format,...)
-{
-    if (m_lookupContext.errs)
-    {
-        va_list args;
-        va_start(args, format);
-        StringBuffer msg;
-        msg.valist_appendf(format,args);
-        WarnErrorCategory category = CategoryUnusual; // a reasonable default
-        m_lookupContext.errs->reportWarning(category, warnNo,msg.str(),NULL,m_startLine,m_startCol,0);
-        va_end(args);
-    }
-}
-
-
 // ===================================== HqlLex ============================================
 
 class CHqlParserPseduoScope : public CHqlScope
@@ -1865,8 +1807,7 @@ IValue *HqlLex::foldConstExpression(const attribute & errpos, IHqlExpression * e
     {
         try
         {
-            CTemplateContext context(this, yyParser->lookupCtx, xmlScope, startLine, startCol);
-            OwnedHqlExpr folded = foldHqlExpression(*yyParser, expr, &context, HFOthrowerror|HFOfoldimpure|HFOforcefold);
+            OwnedHqlExpr folded = foldHqlExpression(*yyParser, expr, HFOthrowerror|HFOfoldimpure|HFOforcefold);
             if (folded)
             {
                 if (folded->queryValue())
@@ -1943,8 +1884,7 @@ void HqlLex::doApply(attribute & returnToken)
     OwnedHqlExpr actions = parseECL(curParam, queryTopXmlScope(), line, col);
     if (actions)
     {
-        CTemplateContext context(this, yyParser->lookupCtx, xmlScope,line,col);
-        OwnedHqlExpr folded = foldHqlExpression(*yyParser, actions, &context, HFOthrowerror|HFOfoldimpure|HFOforcefold);
+        OwnedHqlExpr folded = foldHqlExpression(*yyParser, actions, HFOthrowerror|HFOfoldimpure|HFOforcefold);
     }
     else
         reportError(returnToken, ERR_EXPECTED_CONST, "Constant expression expected");

ecl/hql/hqlutil.cpp

@@ -1560,7 +1560,7 @@ IHqlExpression * createImpureOwn(IHqlExpression * expr)
 IHqlExpression * getNormalizedFilename(IHqlExpression * filename)
 {
     NullErrorReceiver errorProcessor;
-    OwnedHqlExpr folded = foldHqlExpression(errorProcessor, filename, NULL, HFOloseannotations);
+    OwnedHqlExpr folded = foldHqlExpression(errorProcessor, filename, HFOloseannotations);
     return normalizeFilenameExpr(folded);
 }
 
@@ -6805,7 +6805,7 @@ void TempTableTransformer::createTempTableAssign(HqlExprArray & assigns, IHqlExp
         {
             OwnedHqlExpr cond = replaceSelfRefSelector(expr->queryChild(0), selector);
             OwnedHqlExpr mapped = mapper.transformRoot(cond);
-            mapped.setown(foldHqlExpression(errorProcessor, mapped, NULL, HFOfoldimpure|HFOforcefold));
+            mapped.setown(foldHqlExpression(errorProcessor, mapped, HFOfoldimpure|HFOforcefold));
             IValue * mappedValue = mapped->queryValue();
 
             if (included)

ecl/hql/hqlxmldb.hpp

@@ -46,49 +46,6 @@ interface IXmlScope : public IInterface
 
 interface IEclRepository;
 
-interface ITemplateContext : public IInterface
-{
-    // context variables
-    virtual IXmlScope* queryXmlScope() = 0;
-
-    // convenient functions
-    virtual bool isInModule(const char* module_name, const char* attr_name) = 0;
-    virtual StringBuffer& getDataType(const char* field, StringBuffer& tgt) = 0;
-    
-    virtual StringBuffer& mangle(const char* src, StringBuffer& mangled) = 0;
-    virtual StringBuffer& demangle(const char* mangled, StringBuffer& demangled) = 0;
-
-    virtual void reportError(int errNo,const char* format,...) __attribute__((format(printf, 3, 4))) = 0;
-    virtual void reportWarning(int warnNo,const char* format,...) __attribute__((format(printf, 3, 4))) = 0;
-
-    // Ideally, the user has no need to use this.
-    virtual IEclRepository* queryDataServer() = 0;
-};
-
-class EclTemplateBase
-{
-protected:
-    StringBuffer& m_result;
-    ITemplateContext* m_templateContext;
-
-public:
-    // constructor
-    EclTemplateBase(ITemplateContext* context, StringBuffer& result) 
-        : m_result(result), m_templateContext(context) { }
-
-    // convenient methods
-    IXmlScope* queryRootScope() { return m_templateContext->queryXmlScope(); }
-    ITemplateContext* queryContext() { return m_templateContext; }
-
-    bool isInModule(const char* moduleName, const char* attrName) { return m_templateContext->isInModule(moduleName,attrName); }
-    StringBuffer& mangle(const char* src, StringBuffer& mangled) { return m_templateContext->mangle(src,mangled); }
-    StringBuffer& demangle(const char* src, StringBuffer& mangled) { return m_templateContext->demangle(src,mangled); }
-    StringBuffer& getDataType(const char* field,StringBuffer& tgt) { return m_templateContext->getDataType(field,tgt); }
-
-    // action
-    virtual void doExpand() = 0;
-};
-
 #define HashFor(sub,scope)  \
     IIterator*  sub##Itr = scope->getScopes(#sub, false); \
     ForEach(*sub##Itr) \

ecl/hqlcpp/hqlcpputil.cpp

@@ -296,7 +296,7 @@ static void expandFieldNames(IErrorReceiver & errorProcessor, StringBuffer & out
                     HqlExprArray args;
                     args.append(*createConstant(lowerName.str()));
                     OwnedHqlExpr bound = createBoundFunction(NULL, formatFunc, args, NULL, true);
-                    OwnedHqlExpr folded = foldHqlExpression(errorProcessor, bound, NULL, HFOthrowerror|HFOfoldimpure|HFOforcefold);
+                    OwnedHqlExpr folded = foldHqlExpression(errorProcessor, bound, HFOthrowerror|HFOfoldimpure|HFOforcefold);
                     assertex(folded->queryValue());
                     lowerName.clear();
                     getStringValue(lowerName, folded);

ecl/hqlcpp/hqlttcpp.cpp

@@ -9169,7 +9169,7 @@ IHqlExpression * DFSLayoutTransformer::createTransformed(IHqlExpression * expr)
     if (translate)
     {
         ECLlocation where(ds);
-        OwnedHqlExpr folded  = foldHqlExpression(errs, filename, nullptr, HFOforcefold);
+        OwnedHqlExpr folded  = foldHqlExpression(errs, filename, HFOforcefold);
         StringBuffer fileNameText;
         getStringValue(fileNameText, folded);
         if (fileNameText.length())   // PIPE creates a no_table with a blank filename, it seems
@@ -12049,11 +12049,11 @@ IHqlExpression * HqlTreeNormalizer::transformCaseToIfs(IHqlExpression * expr)
 
         OwnedHqlExpr test = createBoolExpr(no_eq, ensureExprType(testVar, type), transform(castCurValue));
         if (options.constantFoldNormalize)
-            test.setown(foldConstantOperator(test, 0, NULL));
+            test.setown(foldConstantOperator(test, 0));
         OwnedHqlExpr trueExpr = transform(cur->queryChild(1));
         elseExpr.setown(createIf(test.getClear(), trueExpr.getClear(), elseExpr.getClear()));
         if (options.constantFoldNormalize)
-            elseExpr.setown(foldConstantOperator(elseExpr, 0, NULL));
+            elseExpr.setown(foldConstantOperator(elseExpr, 0));
     }
     return elseExpr.getClear();
 }
@@ -12180,7 +12180,7 @@ IHqlExpression * HqlTreeNormalizer::transformMap(IHqlExpression * expr)
         IHqlExpression * cur = expr->queryChild(idx);
         elseExpr.setown(createIf(transform(cur->queryChild(0)), transform(cur->queryChild(1)), elseExpr.getClear()));
         if (options.constantFoldNormalize)
-            elseExpr.setown(foldConstantOperator(elseExpr, 0, NULL));
+            elseExpr.setown(foldConstantOperator(elseExpr, 0));
     }
     return elseExpr.getClear();
 }
@@ -12908,7 +12908,7 @@ IHqlExpression * HqlTreeNormalizer::createTransformed(IHqlExpression * expr)
         break;
     }
     OwnedHqlExpr transformed = createTransformedBody(expr);
-    return foldConstantOperator(transformed, 0, NULL);
+    return foldConstantOperator(transformed, 0);
 }
 
 IHqlExpression * HqlTreeNormalizer::createTransformedBody(IHqlExpression * expr)
@@ -13351,7 +13351,7 @@ IHqlExpression * HqlTreeNormalizer::createTransformedBody(IHqlExpression * expr)
         {
             IHqlExpression * child = expr->queryChild(0);
             OwnedHqlExpr ret = transform(child);
-            OwnedHqlExpr folded  = foldHqlExpression(translator.queryErrorProcessor(), ret, NULL, HFOforcefold);
+            OwnedHqlExpr folded  = foldHqlExpression(translator.queryErrorProcessor(), ret, HFOforcefold);
             if (!folded->isConstant())
             {
                 StringBuffer s;
@@ -13746,7 +13746,7 @@ void normalizeHqlTree(HqlCppTranslator & translator, HqlExprArray & exprs)
     if (translator.queryOptions().constantFoldPostNormalize)
     {
         HqlExprArray transformed;
-        quickFoldExpressions(transformed, exprs, NULL, 0);
+        quickFoldExpressions(transformed, exprs, 0);
         replaceArray(exprs, transformed);
     }