code: public Object parseExpressionString(String pExpressionString)
              throws ELException {
          // See if it's an empty String
          if (pExpressionString.length() == 0) {
              return "";
          }
  
          if (!(mBypassCache) && (sCachedExpressionStrings == null)) {
              createExpressionStringMap();
          }
  
          // See if it's in the cache
          Object ret =
                  mBypassCache ?
                          null :
                          sCachedExpressionStrings.get(pExpressionString);
  
          if (ret == null) {
              // Parse the expression
              Reader r = new StringReader(pExpressionString);
              ELParser parser = new ELParser(r);
              try {
                  ret = parser.ExpressionString();
                  if (!mBypassCache) {
                      sCachedExpressionStrings.put(pExpressionString, ret);
                  }
              }
              catch (ParseException exc) {
                  throw new ELException
                          (formatParseException(pExpressionString,
                                  exc));
              }
              catch (TokenMgrError exc) {
                  // Note - this should never be reached, since the parser is
                  // constructed to tokenize any input (illegal inputs get
                  // parsed to <BADLY_ESCAPED_STRING_LITERAL> or
                  // <ILLEGAL_CHARACTER>
                  throw new ELException(exc.getMessage());
              }
          }
          return ret;
      }
docs: Gets the parsed form of the given expression string.  If the
  parsed form is cached (and caching is not bypassed), return the
  cached form, otherwise parse and cache the value.  Returns either
  a String, Expression, or ExpressionString.