HPCC-24612 Backport change to 7.6.x to avoid stack fault on KEL query

Signed-off-by: Gavin Halliday <gavin.halliday@lexisnexis.com>

ecl/hqlcpp/hqlttcpp.cpp

@@ -448,93 +448,125 @@ bool NewThorStoredReplacer::needToTransform()
     return (foldStored || seenMeta);
 }
 
-
-// This works on unnormalized trees, so based on QuickHqlTransformer
-IHqlExpression * NewThorStoredReplacer::createTransformed(IHqlExpression * expr)
+IHqlExpression * NewThorStoredReplacer::transformColon(IHqlExpression * expr)
 {
-    switch (expr->getOperator())
+    HqlExprArray actions;
+    expr->queryChild(1)->unwindList(actions, no_comma);
+
+    OwnedHqlExpr replacement;
+    OwnedHqlExpr matchedName;
+    bool onlyStored = true;
+    bool forceConstant = foldStored;
+    ForEachItemIn(idx, actions)
     {
-    case no_colon:
+        IHqlExpression & cur = actions.item(idx);
+        switch (cur.getOperator())
         {
-            HqlExprArray actions;
-            expr->queryChild(1)->unwindList(actions, no_comma);
+        case no_stored:
+            {
+                OwnedHqlExpr storedName = getLowerCaseConstantExpr(cur.queryChild(0));
+                IHqlExpression * searchName = storedName->queryBody();
+                unsigned match = storedNames.find(*searchName);
+                if (match != NotFound)
+                {
+                    if (storedIsConstant.item(match))
+                        forceConstant = true;
 
-            OwnedHqlExpr replacement;
-            OwnedHqlExpr matchedName;
-            bool onlyStored = true;
-            bool forceConstant = foldStored;
-            ForEachItemIn(idx, actions)
+                    matchedName.set(searchName);
+                    replacement.set(&storedValues.item(match));
+                }
+                break;
+            }
+        case no_attr:
+        case no_attr_expr:
+            if (cur.queryName() == labeledAtom)
             {
-                IHqlExpression & cur = actions.item(idx);
-                switch (cur.getOperator())
+                OwnedHqlExpr storedName = getLowerCaseConstantExpr(cur.queryChild(0));
+                IHqlExpression * searchName = storedName->queryBody();
+                unsigned match = storedNames.find(*searchName);
+                if (match != NotFound)
                 {
-                case no_stored:
-                    {
-                        OwnedHqlExpr storedName = getLowerCaseConstantExpr(cur.queryChild(0));
-                        IHqlExpression * searchName = storedName->queryBody();
-                        unsigned match = storedNames.find(*searchName);
-                        if (match != NotFound)
-                        {
-                            if (storedIsConstant.item(match))
-                                forceConstant = true;
+                    matchedName.set(searchName);
+                    replacement.set(&storedValues.item(match));
+                }
+                else
+                    replacement.set(expr->queryChild(0));
 
-                            matchedName.set(searchName);
-                            replacement.set(&storedValues.item(match));
-                        }
-                        break;
-                    }
-                case no_attr:
-                case no_attr_expr:
-                    if (cur.queryName() == labeledAtom)
-                    {
-                        OwnedHqlExpr storedName = getLowerCaseConstantExpr(cur.queryChild(0));
-                        IHqlExpression * searchName = storedName->queryBody();
-                        unsigned match = storedNames.find(*searchName);
-                        if (match != NotFound)
-                        {
-                            matchedName.set(searchName);
-                            replacement.set(&storedValues.item(match));
-                        }
-                        else
-                            replacement.set(expr->queryChild(0));
+                forceConstant = true;
+                break;
+            }
+        default:
+            onlyStored = false;
+            break;
+        }
+    }
 
-                        forceConstant = true;
-                        break;
-                    }
-                default:
-                    onlyStored = false;
-                    break;
+    if (matchedName)
+    {
+        unsigned activeMatch = activeReplacements.find(*matchedName);
+        if (activeMatch != NotFound)
+        {
+            StringBuffer nameText;
+            getExprECL(matchedName, nameText);
+            if (activeMatch+1 != activeReplacements.ordinality())
+            {
+                StringBuffer othersText;
+                for (unsigned i=activeMatch+1; i < activeReplacements.ordinality(); i++)
+                {
+                    othersText.append(",");
+                    getExprECL(&activeReplacements.item(i), othersText);
                 }
+                translator.reportError(expr, ECODETEXT(HQLERR_RecursiveStoredOther),  forceConstant ? "CONSTANT" : "STORED", nameText.str(), othersText.str()+1);
             }
+            else
+                translator.reportError(expr, ECODETEXT(HQLERR_RecursiveStored),  forceConstant ? "CONSTANT" : "STORED", nameText.str());
+        }
 
-            if (matchedName)
+        ITypeInfo * exprType = expr->queryType();
+        ITypeInfo * replacementType = replacement->queryType();
+        type_t etc = exprType->getTypeCode();
+        type_t rtc = replacementType->getTypeCode();
+
+        StringBuffer nameText, exprTypeText, replacementTypeText;
+        switch (etc)
+        {
+        case type_groupedtable:
+        case type_table:
+        case type_row:
+        case type_record:
+        case type_transform:
+        case type_void:
             {
-                unsigned activeMatch = activeReplacements.find(*matchedName);
-                if (activeMatch != NotFound)
+                if (etc != rtc)
                 {
-                    StringBuffer nameText;
                     getExprECL(matchedName, nameText);
-                    if (activeMatch+1 != activeReplacements.ordinality())
-                    {
-                        StringBuffer othersText;
-                        for (unsigned i=activeMatch+1; i < activeReplacements.ordinality(); i++)
-                        {
-                            othersText.append(",");
-                            getExprECL(&activeReplacements.item(i), othersText);
-                        }
-                        translator.reportError(expr, ECODETEXT(HQLERR_RecursiveStoredOther),  forceConstant ? "CONSTANT" : "STORED", nameText.str(), othersText.str()+1);
-                    }
-                    else
-                        translator.reportError(expr, ECODETEXT(HQLERR_RecursiveStored),  forceConstant ? "CONSTANT" : "STORED", nameText.str());
+                    getFriendlyTypeStr(exprType, exprTypeText);
+                    getFriendlyTypeStr(replacementType, replacementTypeText);
+                    translator.reportError(expr, ECODETEXT(HQLERR_HashStoredTypeMismatch), nameText.str(), exprTypeText.str(), replacementTypeText.str());
                 }
-
-                ITypeInfo * exprType = expr->queryType();
-                ITypeInfo * replacementType = replacement->queryType();
-                type_t etc = exprType->getTypeCode();
-                type_t rtc = replacementType->getTypeCode();
-
-                StringBuffer nameText, exprTypeText, replacementTypeText;
-                switch (etc)
+                else if (expr->queryRecord() != replacement->queryRecord())
+                {
+                    StringBuffer s;
+                    translator.reportError(expr, ECODETEXT(HQLERR_HashStoredRecordMismatch), getExprECL(matchedName, s).str());
+                }
+            }
+            break;
+        case type_set:
+        case type_array:
+            {
+                if ((rtc != type_set) && (rtc != type_array))
+                {
+                    getExprECL(matchedName, nameText);
+                    getFriendlyTypeStr(exprType, exprTypeText);
+                    getFriendlyTypeStr(replacementType, replacementTypeText);
+                    translator.reportError(expr, ECODETEXT(HQLERR_HashStoredTypeMismatch), nameText.str(), exprTypeText.str(), replacementTypeText.str());
+                }
+                replacement.setown(ensureExprType(replacement, exprType));
+                break;
+            }
+        default:
+            {
+                switch (rtc)
                 {
                 case type_groupedtable:
                 case type_table:
@@ -543,82 +575,53 @@ IHqlExpression * NewThorStoredReplacer::createTransformed(IHqlExpression * expr)
                 case type_transform:
                 case type_void:
                     {
-                        if (etc != rtc)
-                        {
-                            getExprECL(matchedName, nameText);
-                            getFriendlyTypeStr(exprType, exprTypeText);
-                            getFriendlyTypeStr(replacementType, replacementTypeText);
-                            translator.reportError(expr, ECODETEXT(HQLERR_HashStoredTypeMismatch), nameText.str(), exprTypeText.str(), replacementTypeText.str());
-                        }
-                        else if (expr->queryRecord() != replacement->queryRecord())
-                        {
-                            StringBuffer s;
-                            translator.reportError(expr, ECODETEXT(HQLERR_HashStoredRecordMismatch), getExprECL(matchedName, s).str());
-                        }
-                    }
-                    break;
-                case type_set:
-                case type_array:
-                    {
-                        if ((rtc != type_set) && (rtc != type_array))
-                        {
-                            getExprECL(matchedName, nameText);
-                            getFriendlyTypeStr(exprType, exprTypeText);
-                            getFriendlyTypeStr(replacementType, replacementTypeText);
-                            translator.reportError(expr, ECODETEXT(HQLERR_HashStoredTypeMismatch), nameText.str(), exprTypeText.str(), replacementTypeText.str());
-                        }
-                        replacement.setown(ensureExprType(replacement, exprType));
-                        break;
+                        getExprECL(matchedName, nameText);
+                        getFriendlyTypeStr(exprType, exprTypeText);
+                        getFriendlyTypeStr(replacementType, replacementTypeText);
+                        translator.reportError(expr, ECODETEXT(HQLERR_HashStoredTypeMismatch), nameText.str(), exprTypeText.str(), replacementTypeText.str());
                     }
                 default:
-                    {
-                        switch (rtc)
-                        {
-                        case type_groupedtable:
-                        case type_table:
-                        case type_row:
-                        case type_record:
-                        case type_transform:
-                        case type_void:
-                            {
-                                getExprECL(matchedName, nameText);
-                                getFriendlyTypeStr(exprType, exprTypeText);
-                                getFriendlyTypeStr(replacementType, replacementTypeText);
-                                translator.reportError(expr, ECODETEXT(HQLERR_HashStoredTypeMismatch), nameText.str(), exprTypeText.str(), replacementTypeText.str());
-                            }
-                        default:
-                            replacement.setown(ensureExprType(replacement, exprType));
-                        }
-                    }
-                    break;
+                    replacement.setown(ensureExprType(replacement, exprType));
                 }
             }
+            break;
+        }
+    }
 
-            LinkedHqlExpr result;
-            if (matchedName)
-                activeReplacements.append(*matchedName);
+    LinkedHqlExpr result;
+    if (matchedName)
+        activeReplacements.append(*matchedName);
 
-            if (onlyStored)
-            {
-                if (forceConstant && replacement)
-                    result.setown(transform(replacement));
-                else if (foldStored)
-                    result.setown(transform(expr->queryChild(0)));
-            }
-            if (replacement && !result)
-            {
-                HqlExprArray args;
-                args.append(*transform(replacement));
-                result.setown(completeTransform(expr, args));
-            }
+    if (onlyStored)
+    {
+        if (forceConstant && replacement)
+            result.setown(transform(replacement));
+        else if (foldStored)
+            result.setown(transform(expr->queryChild(0)));
+    }
+    if (replacement && !result)
+    {
+        HqlExprArray args;
+        args.append(*transform(replacement));
+        result.setown(completeTransform(expr, args));
+    }
 
-            if (matchedName)
-                activeReplacements.pop();
+    if (matchedName)
+        activeReplacements.pop();
 
-            if (result)
-                return result.getClear();
-            break;
-        }
+    if (result)
+        return result.getClear();
+
+    return QuickHqlTransformer::createTransformed(expr);
+}
+
+// This works on unnormalized trees, so based on QuickHqlTransformer
+IHqlExpression * NewThorStoredReplacer::createTransformed(IHqlExpression * expr)
+{
+    switch (expr->getOperator())
+    {
+    case no_colon:
+        return transformColon(expr);
     case no_comma:
     case no_compound:
         if (expr->queryChild(0)->getOperator() == no_setmeta)

ecl/hqlcpp/hqlttcpp.ipp

@@ -36,6 +36,9 @@ public:
     bool needToTransform();
 
 protected:
+    IHqlExpression * transformColon(IHqlExpression * expr);
+
+protected:
     HqlCppTranslator & translator;
     IWorkUnit * wu;
     ICodegenContextCallback * ctxCallback;