docs: private void processBeanPoolLimits(BeanMetaData bmd) throws EJBConfigurationException {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.entry(tc, "processBeanPoolLimits");
          }
  
          boolean checkAppConfigCustom = bmd.isCheckConfig(); // F743-33178
  
          //------------------------------------------------------------------------
          // The following default values are documented in the info center
          // changing them may affect existing customer applicatioins.
          //
          // Arguments can be made about the following values. No great
          // science was used in determining these numbers.
          //------------------------------------------------------------------------
          int defaultMinPoolSize = 50;
          int defaultMaxPoolSize = 500;
          long defaultMaxCreationTimeout = 300000; // 5 minutes
  
          String minStr = null;
          String maxStr = null;
          String timeoutStr = null;
          String poolSizeSpec = null;
          boolean noEJBPool = false; // d262413 PK20648
  
          //------------------------------------------------------------------------
          // Determine if the noEJBPool or poolSize java system properties have
          // been specified. noEJBPool overrides everything, so the poolSize
          // property is not needed when noEJBPool is enabled.       d262413 PK20648
          // Property access & default now handled by ContainerProperties.    391302
          //------------------------------------------------------------------------
          if (NoEJBPool)
              noEJBPool = true;
          else
              poolSizeSpec = PoolSize; // 121700
  
          if (poolSizeSpec != null) {
              StringTokenizer st = new StringTokenizer(poolSizeSpec, ":");
  
              while (st.hasMoreTokens()) {
                  String token = st.nextToken();
                  int assignmentPivot = token.indexOf('=');
                  if (assignmentPivot > 0) {
                      String lh = token.substring(0, assignmentPivot).trim();
                      // Now Z/OS does not allow "#" in java properties so we also
                      // must allow "%".   If those are used we will switch them to "#" before
                      // proceeding.         //d434795
                      lh = lh.replaceAll("%", "#");
                      if (lh.equals(bmd.j2eeName.toString())) { // d130438
                          String rh = token.substring(assignmentPivot + 1).trim();
                          StringTokenizer sizeTokens = new StringTokenizer(rh, ",");
                          if (sizeTokens.hasMoreTokens()) {
                              // min parm was specified
                              minStr = sizeTokens.nextToken().trim();
                          }
                          if (sizeTokens.hasMoreTokens()) {
                              // max parm was specified
                              maxStr = sizeTokens.nextToken().trim();
                          }
                          if (sizeTokens.hasMoreTokens()) {
                              // timeout parm was specified
                              timeoutStr = sizeTokens.nextToken().trim();
                          }
                      } else if (lh.equals("*") && (minStr == null || maxStr == null || timeoutStr == null)) {
                          String rh = token.substring(assignmentPivot + 1).trim();
                          StringTokenizer sizeTokens = new StringTokenizer(rh, ",");
                          if (sizeTokens.hasMoreTokens()) {
                              // min parm was specified
                              String defaultMinStr = sizeTokens.nextToken();
                              if (minStr == null) {
                                  minStr = defaultMinStr.trim();
                              }
                          }
                          if (sizeTokens.hasMoreTokens()) {
                              // max parm was specified
                              String defaultMaxStr = sizeTokens.nextToken();
                              if (maxStr == null) {
                                  maxStr = defaultMaxStr.trim();
                              }
                          }
                          if (sizeTokens.hasMoreTokens()) {
                              // timeout parm was specified
                              String defaultTimeoutStr = sizeTokens.nextToken();
                              if (timeoutStr == null) {
                                  timeoutStr = defaultTimeoutStr.trim();
                              }
                          }
                      }
                  } else {
                      // Syntax error -- token did not include an equals sign....
                      Tr.warning(tc, "POOLSIZE_MISSING_EQUALS_SIGN_CNTR0062W", new Object[] { token });
                      if (isValidationFailable(checkAppConfigCustom)) {
                          EJBConfigurationException ecex = new EJBConfigurationException("An equals sign was not found in the pool size specification string " +
                                                                                         token + ".");
                          if (isTraceOn && tc.isEntryEnabled())
                              Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                          throw ecex;
                      }
                  }
              } // while loop
          } // poolSizeSpec not null
  
          int tmpMinPoolSize, tmpMaxPoolSize;
          long tmpMaxCreationTimeout;
          boolean setInitialPoolSize = false; // PK20648
          boolean setMaxCreation = false; // PK20648
          if (minStr != null) {
              try {
                  // An H prefix indicates a hard limit (pre-load pool).       PK20648
                  if (minStr.startsWith("H")) {
                      setInitialPoolSize = true;
                      minStr = minStr.substring(1);
                  }
                  tmpMinPoolSize = Integer.parseInt(minStr);
                  if (tmpMinPoolSize < 1) {
                      Tr.warning(tc, "INVALID_MIN_POOLSIZE_CNTR0057W", new Object[] { (bmd.j2eeName).toString(), Integer.toString(tmpMinPoolSize) });
                      tmpMinPoolSize = defaultMinPoolSize;
                      if (isValidationFailable(checkAppConfigCustom)) {
                          EJBConfigurationException ecex = new EJBConfigurationException("Minimum pool size specified for bean " + bmd.j2eeName +
                                                                                         " not a valid positive integer: " + tmpMinPoolSize + ".");
                          if (isTraceOn && tc.isEntryEnabled())
                              Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                          throw ecex;
                      }
                  }
              } catch (NumberFormatException e) {
                  FFDCFilter.processException(e, CLASS_NAME + ".processBeanPoolLimits", "2594", this);
                  Tr.warning(tc, "INVALID_MIN_POOLSIZE_CNTR0057W", new Object[] { (bmd.j2eeName).toString(), minStr });
                  tmpMinPoolSize = defaultMinPoolSize;
                  if (isValidationFailable(checkAppConfigCustom)) {
                      EJBConfigurationException ecex = new EJBConfigurationException("Minimum pool size specified for bean " + bmd.j2eeName +
                                                                                     " not a valid integer: " + minStr + ".");
                      if (isTraceOn && tc.isEntryEnabled())
                          Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                      throw ecex;
                  }
              }
          } else {
              tmpMinPoolSize = defaultMinPoolSize;
          }
  
          if (maxStr != null) {
              try {
                  // An H prefix indicates a hard limit (Max Creation).        PK20648
                  if (maxStr.startsWith("H")) {
                      setMaxCreation = true;
                      maxStr = maxStr.substring(1);
                  }
                  tmpMaxPoolSize = Integer.parseInt(maxStr);
                  if (tmpMaxPoolSize < 1) {
                      Tr.warning(tc, "INVALID_MAX_POOLSIZE_CNTR0058W", new Object[] { (bmd.j2eeName).toString(), Integer.toString(tmpMaxPoolSize) });
                      tmpMaxPoolSize = defaultMaxPoolSize;
                      if (isValidationFailable(checkAppConfigCustom)) {
                          EJBConfigurationException ecex = new EJBConfigurationException("Maximum pool size specified for bean " + bmd.j2eeName +
                                                                                         " not a valid positive integer: " + tmpMaxPoolSize + ".");
                          if (isTraceOn && tc.isEntryEnabled())
                              Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                          throw ecex;
                      }
                  }
              } catch (NumberFormatException e) {
                  FFDCFilter.processException(e, CLASS_NAME + ".processBeanPoolLimits", "2616", this);
                  Tr.warning(tc, "INVALID_MAX_POOLSIZE_CNTR0058W", new Object[] { (bmd.j2eeName).toString(), maxStr });
                  tmpMaxPoolSize = defaultMaxPoolSize;
                  if (isValidationFailable(checkAppConfigCustom)) {
                      EJBConfigurationException ecex = new EJBConfigurationException("Maximum pool size specified for bean " + bmd.j2eeName +
                                                                                     " not a valid integer: " + maxStr + ".");
                      if (isTraceOn && tc.isEntryEnabled())
                          Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                      throw ecex;
                  }
              }
          } else {
              tmpMaxPoolSize = defaultMaxPoolSize;
          }
  
          if (setMaxCreation && timeoutStr != null) {
              try {
                  tmpMaxCreationTimeout = Integer.parseInt(timeoutStr) * 1000;
                  if (tmpMaxCreationTimeout < 0) {
                      Tr.warning(tc, "INVALID_MAX_POOLTIMEOUT_CNTR0127W", new Object[] { (bmd.j2eeName).toString(), timeoutStr, "300" });
                      tmpMaxCreationTimeout = defaultMaxCreationTimeout;
                      if (isValidationFailable(checkAppConfigCustom)) {
                          EJBConfigurationException ecex = new EJBConfigurationException("Maximum pool size timeout specified for bean " + bmd.j2eeName +
                                                                                         " not a valid positive integer: " + timeoutStr + ".");
                          if (isTraceOn && tc.isEntryEnabled())
                              Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                          throw ecex;
                      }
                  }
              } catch (NumberFormatException e) {
                  FFDCFilter.processException(e, CLASS_NAME + ".processBeanPoolLimits", "2573", this);
                  Tr.warning(tc, "INVALID_MAX_POOLTIMEOUT_CNTR0127W", new Object[] { (bmd.j2eeName).toString(), timeoutStr, "300" });
                  tmpMaxCreationTimeout = defaultMaxCreationTimeout;
                  if (isValidationFailable(checkAppConfigCustom)) {
                      EJBConfigurationException ecex = new EJBConfigurationException("Maximum pool size timeout specified for bean " + bmd.j2eeName +
                                                                                     " not a valid integer: " + timeoutStr + ".");
                      if (isTraceOn && tc.isEntryEnabled())
                          Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                      throw ecex;
                  }
              }
          } else {
              tmpMaxCreationTimeout = defaultMaxCreationTimeout;
          }
  
          // If the noEJBPool system property has been set to "true", then a
          // no-capacity ejb pool will be created. (This should only be used
          // for development / debug purposes)                    // d262413 PK20648
          if (noEJBPool) {
              bmd.minPoolSize = 0;
              bmd.maxPoolSize = 0;
          }
          // Otherwise, if an invalid min/max pair was specified, then the
          // defaults will be used, and a warning issued.
          else if (tmpMaxPoolSize < tmpMinPoolSize) {
              Tr.warning(tc, "INVALID_POOLSIZE_COMBO_CNTR0059W", new Object[] { (bmd.j2eeName).toString(), Integer.toString(tmpMinPoolSize), Integer.toString(tmpMaxPoolSize) });
              bmd.minPoolSize = defaultMinPoolSize;
              bmd.maxPoolSize = defaultMaxPoolSize;
              if (isValidationFailable(checkAppConfigCustom)) {
                  EJBConfigurationException ecex = new EJBConfigurationException("Minimum pool size specified for bean " + bmd.j2eeName +
                                                                                 " is greater than maximum pool size specified: (" +
                                                                                 tmpMinPoolSize + "," + tmpMaxPoolSize + ")");
                  if (isTraceOn && tc.isEntryEnabled())
                      Tr.exit(tc, "processBeanPoolLimits : " + ecex);
                  throw ecex;
              }
          }
          // And finally, everything looks good, so the configured sizes
          // and pre-load / max creation limit values will be used.
          else {
              bmd.minPoolSize = tmpMinPoolSize;
              bmd.maxPoolSize = tmpMaxPoolSize;
  
              // Set the pre-load and max creation values to the min/max pool
              // size values if 'H' (hard) specified, and the values were
              // otherwise valid.                                             PK20648
              if (setInitialPoolSize)
                  bmd.ivInitialPoolSize = bmd.minPoolSize;
              if (setMaxCreation) {
                  bmd.ivMaxCreation = bmd.maxPoolSize;
                  bmd.ivMaxCreationTimeout = tmpMaxCreationTimeout;
              }
          }
  
          if (poolSizeSpec != null || noEJBPool) {
              // Log an Info message indicating pool min/max values, including
              // whether or not they are 'hard' limits.                       PK20648
              String minPoolSizeStr = Integer.toString(bmd.minPoolSize);
              if (bmd.ivInitialPoolSize > 0)
                  minPoolSizeStr = "H " + minPoolSizeStr;
              String maxPoolSizeStr = Integer.toString(bmd.maxPoolSize);
              if (bmd.ivMaxCreation > 0) {
                  maxPoolSizeStr = "H " + maxPoolSizeStr;
                  String maxPoolTimeoutStr = Long.toString(bmd.ivMaxCreationTimeout / 1000);
                  Tr.info(tc, "POOLSIZE_VALUES_CNTR0128I",
                          new Object[] { minPoolSizeStr, maxPoolSizeStr, maxPoolTimeoutStr, bmd.enterpriseBeanClassName });
              } else {
                  Tr.info(tc, "POOLSIZE_VALUES_CNTR0060I",
                          new Object[] { minPoolSizeStr, maxPoolSizeStr, bmd.enterpriseBeanClassName });
              }
          }
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.exit(tc, "processBeanPoolLimits");
          }
  
      }