docs: @Override
      public String interpreterCall(
          boolean isTagFile,
          String expression,
          Class expectedType,
          String fnmapvar,
          boolean XmlEscape,
          String pageContextVar) {  //PK65013
              
          /*
           * Determine which context object to use.
           */
          String jspCtxt = null;
          if (isTagFile)
              jspCtxt = "getJspContext()";
          else
              jspCtxt = pageContextVar;
  
          /*
               * Determine whether to use the expected type's textual name
           * or, if it's a primitive, the name of its correspondent boxed
           * type.
               */
          String returnType = GeneratorUtils.getClassType(expectedType); //PI59436
          String primitiveConverterMethod = GeneratorUtils.getPrimitiveConverterMethod(expectedType);
          /*
           * PI59436: Use targetType to as the expected type argument of PageContextImpl.proprietaryEvaluate(final String expression,
           * final Class expectedType, final PageContext pageContext,
           * final ProtectedFunctionMapper functionMap, final boolean escape)
           * This will ensure that if the expected value of an expression is a primitive type,
           * we will get the corresponding value according to EL 3.0 spec.
           * This will prevent using primitive wrapper class types as the expected type;
           * this is problematic in EL 3.0 because non-primitive classes, when are not set
           * will produce null as result. Section 1.23.1 of EL 3.0 spec.:
           * If X is null and Y is not a primitive type and also not a String, return null.
           */
          String targetType = GeneratorUtils.toJavaSourceType(expectedType.getName());
          
          if (primitiveConverterMethod != null) {
              XmlEscape = false;
          }
  
          /*
               * Build up the base call to the interpreter.
               */
          // XXX - We use a proprietary call to the interpreter for now
          // as the current standard machinery is inefficient and requires
          // lots of wrappers and adapters.  This should all clear up once
          // the EL interpreter moves out of JSTL and into its own project.
          // In the future, this should be replaced by code that calls
          // ExpressionEvaluator.parseExpression() and then cache the resulting
          // expression objects.  The interpreterCall would simply select
          // one of the pre-cached expressions and evaluate it.
          // Note that PageContextImpl implements VariableResolver and
          // the generated Servlet/SimpleTag implements FunctionMapper, so
          // that machinery is already in place (mroth).
          StringBuffer call =
              new StringBuffer(
                  "("
                      + returnType //PI59436
                      + ") "
                      + "org.apache.jasper.runtime.PageContextImpl.proprietaryEvaluate"
                      + "("
                      + GeneratorUtils.handleEscapes(GeneratorUtils.quote(expression))
                      + ", "
                      + targetType
                      + ".class, "
                      + "(PageContext)"
                      + jspCtxt
                      + ", "
                      + fnmapvar
                      + ", "
                      + XmlEscape
                      + ")");
  
          /*
               * Add the primitive converter method if we need to.
               */
          if (primitiveConverterMethod != null) {
              call.insert(0, "(");
              call.append(")." + primitiveConverterMethod + "()");
          }
  
          return call.toString();
      }