import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
static Bindable getBindable(ClassDeclaration expr, String s, int fieldCount)
    throws CompileException, IOException {
  ICompilerFactory compilerFactory;
  try {
    compilerFactory = CompilerFactoryFactory.getDefaultCompilerFactory();
  } catch (Exception e) {
    throw new IllegalStateException(
        "Unable to instantiate java compiler", e);
  }
  IClassBodyEvaluator cbe = compilerFactory.newClassBodyEvaluator();
  cbe.setClassName(expr.name);
  cbe.setExtendedClass(Utilities.class);
  cbe.setImplementedInterfaces(
      fieldCount == 1
          ? new Class[] {Bindable.class, Typed.class}
          : new Class[] {ArrayBindable.class});
  cbe.setParentClassLoader(EnumerableInterpretable.class.getClassLoader());
  if (CalcitePrepareImpl.DEBUG) {
    // Add line numbers to the generated janino class
    cbe.setDebuggingInformation(true, true, true);
  }
  return (Bindable) cbe.createInstance(new StringReader(s));
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
static Scalar getScalar(ClassDeclaration expr, String s)
    throws CompileException, IOException {
  ICompilerFactory compilerFactory;
  try {
    compilerFactory = CompilerFactoryFactory.getDefaultCompilerFactory();
  } catch (Exception e) {
    throw new IllegalStateException(
        "Unable to instantiate java compiler", e);
  }
  IClassBodyEvaluator cbe = compilerFactory.newClassBodyEvaluator();
  cbe.setClassName(expr.name);
  cbe.setImplementedInterfaces(new Class[]{Scalar.class});
  cbe.setParentClassLoader(JaninoRexCompiler.class.getClassLoader());
  if (CalcitePrepareImpl.DEBUG) {
    // Add line numbers to the generated janino class
    cbe.setDebuggingInformation(true, true, true);
  }
  return (Scalar) cbe.createInstance(new StringReader(s));
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
@Override
public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
  if (diagnostic.getKind() == javax.tools.Diagnostic.Kind.ERROR) {
    String message = diagnostic.toString() + " (" + diagnostic.getCode() + ")";
    logger.error(message);
    Location loc = new Location( //
        diagnostic.getSource().toString(), //
        (short) diagnostic.getLineNumber(), //
        (short) diagnostic.getColumnNumber() //
    );
    // Wrap the exception in a RuntimeException, because "report()"
    // does not declare checked exceptions.
    throw new RuntimeException(new CompileException(message, loc));
  } else if (logger.isTraceEnabled()) {
    logger.trace(diagnostic.toString() + " (" + diagnostic.getCode() + ")");
  }
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
private byte[][] getClassByteCode(ClassNames className, String sourceCode)
    throws CompileException, ClassNotFoundException, ClassTransformationException, IOException {
  AbstractClassCompiler classCompiler;
  if (jdkClassCompiler != null &&
      (policy == CompilerPolicy.JDK || (policy == CompilerPolicy.DEFAULT && sourceCode.length() > janinoThreshold))) {
    classCompiler = jdkClassCompiler;
  } else {
    classCompiler = janinoClassCompiler;
  }

  byte[][] bc = classCompiler.getClassByteCode(className, sourceCode);
  /*
   * final String baseDir = System.getProperty("java.io.tmpdir") + File.separator + classCompiler.getClass().getSimpleName();
   * File classFile = new File(baseDir + className.clazz);
   * classFile.getParentFile().mkdirs();
   * BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(classFile));
   * out.write(bc[0]);
   * out.close();
   */
  return bc;
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
public byte[][] getClassByteCode(ClassNames className, String sourceCode)
      throws CompileException, IOException, ClassNotFoundException, ClassTransformationException {
    if (getLogger().isDebugEnabled()) {
      getLogger().debug("Compiling (source size={}):\n{}", DrillStringUtils.readable(sourceCode.length()), prefixLineNumbers(sourceCode));

/* uncomment this to get a dump of the generated source in /tmp
      // This can be used to write out the generated operator classes for debugging purposes
      // TODO: should these be put into a directory named with the query id and/or fragment id
      final int lastSlash = className.slash.lastIndexOf('/');
      final File dir = new File("/tmp", className.slash.substring(0, lastSlash));
      dir.mkdirs();
      final File file = new File(dir, className.slash.substring(lastSlash + 1) + ".java");
      final FileWriter writer = new FileWriter(file);
      writer.write(sourceCode);
      writer.close();
*/
    }
    return getByteCode(className, sourceCode);
  }
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
private String getClassBody(Class<?> c) throws CompileException, IOException{
  String path = c.getName();
  path = path.replaceFirst("\\$.*", "");
  path = path.replace(".", FileUtils.separator);
  path = "/" + path + ".java";
  URL u = Resources.getResource(c, path);
  InputSupplier<InputStream> supplier = Resources.newInputStreamSupplier(u);
  try (InputStream is = supplier.getInput()) {
    if (is == null) {
      throw new IOException(String.format("Failure trying to located source code for Class %s, tried to read on classpath location %s", c.getName(), path));
    }
    String body = IO.toString(is);

    //TODO: Hack to remove annotations so Janino doesn't choke.  Need to reconsider this problem...
    //return body.replaceAll("@(?:Output|Param|Workspace|Override|SuppressWarnings\\([^\\\\]*?\\)|FunctionTemplate\\([^\\\\]*?\\))", "");
    return body.replaceAll("@(?:\\([^\\\\]*?\\))?", "");
  }

}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
@Override
protected ClassBytes[] getByteCode(final ClassNames className, final String sourcecode, boolean debug)
    throws CompileException, IOException, ClassNotFoundException, ClassTransformationException {
  StringReader reader = new StringReader(sourcecode);
  Scanner scanner = new Scanner((String) null, reader);
  Java.CompilationUnit compilationUnit = new Parser(scanner).parseCompilationUnit();
  ClassFile[] classFiles = new UnitCompiler(compilationUnit, compilationClassLoader)
                                .compileUnit(debug, debug, debug);

  ClassBytes[] byteCodes = new ClassBytes[classFiles.length];
  for(int i = 0; i < classFiles.length; i++){
    ClassFile file = classFiles[i];
    byteCodes[i] = new ClassBytes(file.getThisClassName(), file.toByteArray());
  }
  return byteCodes;
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
@Override
  public ClassBytes[] getClassByteCode(ClassNames className, String sourceCode, boolean debug)
      throws CompileException, IOException, ClassNotFoundException, ClassTransformationException {
    if (getLogger().isDebugEnabled()) {
      getLogger().debug("Compiling (source size={}):\n{}", DremioStringUtils.readable(sourceCode.length()),
          debug ? prefixLineNumbers(sourceCode) : debug);

/* uncomment this to get a dump of the generated source in /tmp
      // This can be used to write out the generated operator classes for debugging purposes
      // TODO: should these be put into a directory named with the query id and/or fragment id
      final int lastSlash = className.slash.lastIndexOf('/');
      final File dir = new File("/tmp", className.slash.substring(0, lastSlash));
      dir.mkdirs();
      final File file = new File(dir, className.slash.substring(lastSlash + 1) + ".java");
      final FileWriter writer = new FileWriter(file);
      writer.write(sourceCode);
      writer.close();
*/
    }
    return getByteCode(className, sourceCode, debug);
  }
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
private CompilationUnit get(Class<?> c) throws IOException {
    URL u = getSourceURL(c);
    try (Reader reader = Resources.asCharSource(u, UTF_8).openStream()) {
      String body = CharStreams.toString(reader);

      // TODO: Hack to remove annotations so Janino doesn't choke. Need to reconsider this problem...
      body = body.replaceAll("@\\w+(?:\\([^\\\\]*?\\))?", "");
      for(Replacement r : REPLACERS){
        body = r.apply(body);
      }
//       System.out.println("original");
      // System.out.println(body);;
      // System.out.println("decompiled");
      // System.out.println(decompile(c));

      try {
        return new Parser(new Scanner(null, new StringReader(body))).parseCompilationUnit();
      } catch (CompileException e) {
        logger.warn("Failure while parsing function class:\n{}", body, e);
        return null;
      }

    }

  }
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
byte[][] getClassByteCode(ClassNames className, String sourceCode)
      throws CompileException, ClassNotFoundException, ClassTransformationException, IOException {

    byte[][] bc = getCompiler(sourceCode).getClassByteCode(className, sourceCode);

    // Uncomment the following to save the generated byte codes.
    // Use the JDK javap command to view the generated code.
    // This is the code from the compiler before byte code manipulations.
    // For a similar block to display byte codes after manipulation,
    // see QueryClassLoader.

//    final File baseDir = new File( new File( System.getProperty("java.io.tmpdir") ), "classes" );
//    for ( int i = 0;  i < bc.length;  i++ ) {
//      File classFile = new File( baseDir, className.slash + i + ".class" );
//      classFile.getParentFile().mkdirs();
//      try (BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(classFile))) {
//        out.write(bc[i]);
//      }
//    }
//    System.out.println( "Classes saved to: " + baseDir.getAbsolutePath() );

    return bc;
  }
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
public Condition build(String script) throws IllegalAccessException,
        CompileException,
        InstantiationException,
        SecurityException, NoSuchMethodException, IllegalArgumentException,
        InvocationTargetException {

  ClassBodyEvaluator cbe = new ClassBodyEvaluator();
  cbe.setImplementedInterfaces(new Class[]{Condition.class});
  cbe.setExtendedClass(PropertyWrapperForScripts.class);
  cbe.setParentClassLoader(ClassBodyEvaluator.class.getClassLoader());
  cbe.cook(SCRIPT_PREFIX + script + SCRIPT_SUFFIX);

  Class<?> clazz = cbe.getClazz();
  Condition instance = (Condition) clazz.newInstance();
  Method setMapMethod = clazz.getMethod("setPropertyContainers", PropertyContainer.class, PropertyContainer.class);
  setMapMethod.invoke(instance, localPropContainer, context);

  return instance;
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
/**
 * Creates the instance of the class defined in {@link ClassDeclaration}
 * @param expr Interface whose instance needs to be created.
 * @param s The java code that implements the interface which should be used to create the instance.
 * @return The object of the class which implements the interface {@link Expression} with the code that is passed as input.
 * @throws CompileException
 * @throws IOException
 */
static Expression getExpression(ClassDeclaration expr, String s) throws CompileException, IOException {
  ICompilerFactory compilerFactory;
  try {
    compilerFactory = CompilerFactoryFactory.getDefaultCompilerFactory();
  } catch (Exception e) {
    throw new IllegalStateException("Unable to instantiate java compiler", e);
  }
  IClassBodyEvaluator cbe = compilerFactory.newClassBodyEvaluator();
  cbe.setClassName(expr.name);
  cbe.setImplementedInterfaces(expr.implemented.toArray(new Class[expr.implemented.size()]));
  cbe.setParentClassLoader(RexToJavaCompiler.class.getClassLoader());
  cbe.setDebuggingInformation(true, true, true);

  return (org.apache.samza.sql.data.Expression) cbe.createInstance(new StringReader(s));
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
/**
 * This test creates a Janino connection that executes simple valid and invalid scripts.
 */
public void testScript() {
    JaninoConnection c = new JaninoConnection(new ConnectionParameters(new MockConnectionEl(), MockDriverContext.INSTANCE));
    field = 0;
    c.executeScript(new StringResource(JaninoConnectionTest.class.getName() + ".field=1;"), null);
    try {
        c.executeScript(new StringResource(JaninoConnectionTest.class.getName() + ".nosuchfield=1;"), null);
        fail("This script should fail");
    } catch (ProviderException e) {
        Throwable ne = e.getNativeException();
        assertTrue(ne instanceof CompileException);
        //OK
    }
    c.close();
    assertEquals(1, field);
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
private static Function1<DataContext, Object[]> compile(String code,
    Object reason) {
  try {
    final ClassBodyEvaluator cbe = new ClassBodyEvaluator();
    cbe.setClassName(GENERATED_CLASS_NAME);
    cbe.setExtendedClass(Utilities.class);
    cbe.setImplementedInterfaces(new Class[] {Function1.class, Serializable.class});
    cbe.setParentClassLoader(RexExecutable.class.getClassLoader());
    cbe.cook(new Scanner(null, new StringReader(code)));
    Class c = cbe.getClazz();
    //noinspection unchecked
    final Constructor<Function1<DataContext, Object[]>> constructor =
        c.getConstructor();
    return constructor.newInstance();
  } catch (CompileException | IOException | InstantiationException
      | IllegalAccessException | InvocationTargetException
      | NoSuchMethodException e) {
    throw new RuntimeException("While compiling " + reason, e);
  }
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
@Override
protected byte[][] getByteCode(final ClassNames className, final String sourceCode)
    throws CompileException, IOException, ClassNotFoundException {
  try {
    // Create one Java source file in memory, which will be compiled later.
    DrillJavaFileObject compilationUnit = new DrillJavaFileObject(className.dot, sourceCode);

    CompilationTask task = compiler.getTask(null, fileManager, listener, compilerOptions, null, Collections.singleton(compilationUnit));

    // Run the compiler.
    if(!task.call()) {
      throw new CompileException("Compilation failed", null);
    } else if (!compilationUnit.isCompiled()) {
      throw new ClassNotFoundException(className + ": Class file not created by compilation.");
    }
    // all good
    return compilationUnit.getByteCode();
  } catch (RuntimeException rte) {
    // Unwrap the compilation exception and throw it.
    Throwable cause = rte.getCause();
    if (cause != null) {
      cause = cause.getCause();
      if (cause instanceof CompileException) {
        throw (CompileException) cause;
      }
      if (cause instanceof IOException) {
        throw (IOException) cause;
      }
    }
    throw rte;
  }
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
@Override
protected byte[][] getByteCode(final ClassNames className, final String sourcecode)
    throws CompileException, IOException, ClassNotFoundException, ClassTransformationException {
  StringReader reader = new StringReader(sourcecode);
  Scanner scanner = new Scanner((String) null, reader);
  Java.CompilationUnit compilationUnit = new Parser(scanner).parseCompilationUnit();
  ClassFile[] classFiles = new UnitCompiler(compilationUnit, compilationClassLoader)
                                .compileUnit(this.debug, this.debug, this.debug);

  byte[][] byteCodes = new byte[classFiles.length][];
  for(int i = 0; i < classFiles.length; i++){
    byteCodes[i] = classFiles[i].toByteArray();
  }
  return byteCodes;
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
private CompilationUnit get(Class<?> c) throws IOException{
  String path = c.getName();
  path = path.replaceFirst("\\$.*", "");
  path = path.replace(".", FileUtils.separator);
  path = "/" + path + ".java";
  CompilationUnit cu = functionUnits.get(path);
  if(cu != null) {
    return cu;
  }

  URL u = Resources.getResource(c, path);
  InputSupplier<InputStream> supplier = Resources.newInputStreamSupplier(u);
  try (InputStream is = supplier.getInput()) {
    if (is == null) {
      throw new IOException(String.format("Failure trying to located source code for Class %s, tried to read on classpath location %s", c.getName(), path));
    }
    String body = IO.toString(is);

    //TODO: Hack to remove annotations so Janino doesn't choke.  Need to reconsider this problem...
    body = body.replaceAll("@\\w+(?:\\([^\\\\]*?\\))?", "");
    try{
      cu = new Parser(new Scanner(null, new StringReader(body))).parseCompilationUnit();
      functionUnits.put(path, cu);
      return cu;
    } catch (CompileException e) {
      logger.warn("Failure while parsing function class:\n{}", body, e);
      return null;
    }

  }

}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
private Class<?> getExtendedImplementationClass(
    final QueryClassLoader classLoader,
    final TemplateClassDefinition<?> templateDefinition,
    final String entireClass,
    final String materializedClassName) throws ClassTransformationException {

  try {
    final long t1 = System.nanoTime();
    final ClassSet set = new ClassSet(null, templateDefinition.getTemplateClassName(), materializedClassName);
    final ClassBytes[] implementationClasses = classLoader.getClassByteCode(set.generated, entireClass);

    long totalBytecodeSize = 0;
    for (ClassBytes clazz : implementationClasses) {
      totalBytecodeSize += clazz.getBytes().length;
      classLoader.injectByteCode(clazz.getName(), clazz.getBytes());
    }

    Class<?> c = classLoader.findClass(set.generated.dot);
    if (templateDefinition.getExternalInterface().isAssignableFrom(c)) {
      logger.debug("Done compiling (bytecode size={}, time:{} millis).", DremioStringUtils.readable(totalBytecodeSize), (System.nanoTime() - t1) / 1000000);
      return c;
    }

    throw new ClassTransformationException("The requested class did not implement the expected interface.");
  } catch (CompileException | IOException | ClassNotFoundException e) {
    throw new ClassTransformationException(String.format("Failure generating transformation classes for value: \n %s", entireClass), e);
  }
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
@Override
protected ClassBytes[] getByteCode(final ClassNames className, final String sourceCode, boolean debug)
    throws CompileException, IOException, ClassNotFoundException {
  try {
    // Create one Java source file in memory, which will be compiled later.
    DremioJavaFileObject compilationUnit = new DremioJavaFileObject(className.dot, sourceCode);

    Iterable<String> compilerOptions = Iterables.concat(
        ImmutableList.of(debug ? "-g:source,lines,vars" : "-g:none"),
        defaultCompilerOptions
    );
    CompilationTask task = compiler.getTask(null, fileManager, listener, compilerOptions, null, Collections.singleton(compilationUnit));

    // Run the compiler.
    if(!task.call()) {
      throw new CompileException("Compilation failed", null);
    } else if (!compilationUnit.isCompiled()) {
      throw new ClassNotFoundException(className + ": Class file not created by compilation.");
    }
    // all good
    return compilationUnit.getByteCode();
  } catch (RuntimeException rte) {
    // Unwrap the compilation exception and throw it.
    Throwable cause = rte.getCause();
    if (cause != null) {
      cause = cause.getCause();
      if (cause instanceof CompileException) {
        throw (CompileException) cause;
      }
      if (cause instanceof IOException) {
        throw (IOException) cause;
      }
    }
    throw rte;
  }
}
 

import org.codehaus.commons.compiler.CompileException; //导入依赖的package包/类
public ClassBytes[] getClassByteCode(ClassNames className, String sourceCode)
    throws CompileException, ClassNotFoundException, ClassTransformationException, IOException {
  OptionValue value = sessionOptions.getOption(JAVA_COMPILER_OPTION);
  CompilerPolicy policy = (value != null) ? CompilerPolicy.valueOf(value.string_val.toUpperCase()) : defaultPolicy;

  value = sessionOptions.getOption(JAVA_COMPILER_JANINO_MAXSIZE_OPTION);
  long janinoThreshold = (value != null) ? value.num_val : defaultJaninoThreshold;

  value = sessionOptions.getOption(JAVA_COMPILER_DEBUG_OPTION);
  boolean debug = (value != null) ? value.bool_val : defaultDebug;

  ClassCompiler classCompiler;
  if (jdkClassCompiler != null &&
      (policy == CompilerPolicy.JDK || (policy == CompilerPolicy.DEFAULT && sourceCode.length() > janinoThreshold))) {
    classCompiler = jdkClassCompiler;
  } else {
    classCompiler = janinoClassCompiler;
  }

  ClassBytes[] bc = classCompiler.getClassByteCode(className, sourceCode, debug);
  /*
   * final String baseDir = System.getProperty("java.io.tmpdir") + File.separator + classCompiler.getClass().getSimpleName();
   * File classFile = new File(baseDir + className.clazz);
   * classFile.getParentFile().mkdirs();
   * BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(classFile));
   * out.write(bc[0]);
   * out.close();
   */
  return bc;
}