docs: static byte[] generateClassBytes(String proxyClassName,
                                       Class proxyInterface,
                                       Method[] proxyMethods,
                                       EJBMethodInfoImpl[] methodInfos,
                                       String ejbClassName,
                                       String beanName)
                      throws EJBConfigurationException
      {
          // ASM uses 'internal' java class names (like JNI) where '/' is
          // used instead of '.', so convert the parameters to 'internal' format.
          String internalClassName = convertClassName(proxyClassName);
          String internalInterfaceName = convertClassName(proxyInterface);
          String internalEJBClassName = convertClassName(ejbClassName);
          String internalParentName = "com/ibm/ejs/container/WSEJBProxy";
          String[] internalImplements = (internalInterfaceName != null)
                          ? (new String[] { internalInterfaceName }) : null;
  
          if (TraceComponent.isAnyTracingEnabled())
          {
              if (tc.isEntryEnabled())
                  Tr.entry(tc, "generateClassBytes");
              if (tc.isDebugEnabled())
              {
                  Tr.debug(tc, INDENT + "className = " + internalClassName);
                  Tr.debug(tc, INDENT + "interface = " + internalInterfaceName);
                  Tr.debug(tc, INDENT + "parent    = " + internalParentName);
                  Tr.debug(tc, INDENT + "ejb       = " + internalEJBClassName);
              }
          }
  
          // Create the ASM Class Writer to write out a proxy
          ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); //F743-11995
  
          // Define the proxy Class object
          cw.visit(V1_2, ACC_PUBLIC + ACC_SUPER,
                   internalClassName,
                   null,
                   internalParentName,
                   internalImplements);
  
          // Define the source code file and debug settings
          String sourceFileName = proxyClassName.substring(proxyClassName.lastIndexOf(".") + 1) + ".java";
          cw.visitSource(sourceFileName, null);
  
          // Add the public no parameter proxy constructor
          addCtor(cw, internalParentName);
  
          // Add all of the methods to the proxy, based on the reflected
          // Method objects from the interface.
          int methodId = -1;
          for (int i = 0; i < proxyMethods.length; ++i)
          {
              Method method = proxyMethods[i];
              String implMethodName = method.getName();
  
              // Business methods must not start with "ejb", per spec.
              if (implMethodName.startsWith("ejb"))
              {
                  String interfaceName = ((proxyInterface != null) ? proxyInterface.getName()
                                  : "WebService Endpoint");
                  // Log the error and throw meaningful exception.
                  Tr.error(tc, "JIT_INVALID_MTHD_PREFIX_CNTR5010E",
                           new Object[] { beanName,
                                         interfaceName,
                                         implMethodName });
                  throw new EJBConfigurationException("EJB business method " + implMethodName +
                                                      " on interface " + interfaceName +
                                                      " must not start with 'ejb'.");
              }
  
              // Determine the Method Id that will be hard coded into the
              // proxy to allow preInvoke to quickly find the correct method.
              methodId = getMethodId(method, proxyMethods, ++methodId);
  
              // Determine if interceptors are called from methodinfo.
              EJBMethodInfoImpl methodInfo = methodInfos[methodId];
              boolean aroundInvoke =
                              (methodInfo.getAroundInterceptorProxies() != null); // F743-17763.1
  
              // When 'generics' are used, like for the Provider interface, the
              // signature of the method on the bean implemenation will be different
              // from that of the interface. Since WebServices will be calling using
              // the signature of the implementation, generate the methods using
              // the ejb method (taken from methodInfo).  The 'interface' method
              // would exist on the ejb, but as a 'bridge' method, and may not be
              // needed on the proxy.                                         d540438
              Method ejbMethod = methodInfo.getMethod();
  
              if (aroundInvoke)
              {
                  addEJBInterceptorMethod(cw,
                                          internalClassName,
                                          internalEJBClassName,
                                          ejbMethod);
              }
              else
              {
                  addEJBMethod(cw,
                               internalClassName,
                               internalEJBClassName,
                               ejbMethod);
              }
  
              // If the Prxoy implements an interface, then the 'bridge' method
              // is also needed (if there is one).  This method will not be added
              // as a 'bridge' method, but just as a normal method, because although
              // the customer may have used generics to define the EJB, generics
              // are NOT usd when defining the Proxy.                         d540438
              if (proxyInterface != null)
              {
                  Method bridgeMethod = methodInfo.getBridgeMethod();
                  if (bridgeMethod != null)
                  {
                      if (aroundInvoke)
                      {
                          addEJBInterceptorMethod(cw,
                                                  internalClassName,
                                                  internalEJBClassName,
                                                  bridgeMethod);
                      }
                      else
                      {
                          addEJBMethod(cw,
                                       internalClassName,
                                       internalEJBClassName,
                                       bridgeMethod);
                      }
                  } // end if bridgeMethod
              } // end if proxyInterface
  
          } // end proxyMethods loop
  
          // Mark the end of the generated proxy class
          cw.visitEnd();
  
          // Dump the class bytes out to a byte array.
          byte[] classBytes = cw.toByteArray();
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              writeToClassFile(internalClassName, classBytes);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              Tr.exit(tc, "generateClassBytes: " + classBytes.length + " bytes");
  
          return classBytes;
      }