code: public static IStandardExpression computeAttributeExpression(
              final ITemplateContext context, final IProcessableElementTag tag, final AttributeName attributeName, final String attributeValue) {
  
          if (!(tag instanceof AbstractProcessableElementTag)) {
              return parseAttributeExpression(context, attributeValue);
          }
  
          final AbstractProcessableElementTag processableElementTag = (AbstractProcessableElementTag)tag;
          final Attribute attribute = (Attribute) processableElementTag.getAttribute(attributeName);
  
          IStandardExpression expression = attribute.getCachedStandardExpression();
          if (expression != null) {
              return expression;
          }
  
          expression = parseAttributeExpression(context, attributeValue);
          // If the expression has been correctly parsed AND it does not contain preprocessing marks (_), nor it is a FragmentExpression, cache it!
          if (expression != null && !(expression instanceof FragmentExpression) && attributeValue.indexOf('_') < 0) {
              attribute.setCachedStandardExpression(expression);
          }
  
          return expression;
  
      }
docs: /*
  The idea behind this method is to cache in the Attribute object itself the IStandardExpression object corresponding
  with the expression to be executed, so that we don't have to hit the expression cache at all