Java Compiler.disableThreads方法代码示例

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
private Compiler createCompiler() {
    try {
        Compiler closureCompiler  = new Compiler(new PrintStream(new DiscardOutputStream(), false, "UTF-8"));
        closureCompiler.disableThreads();
        Compiler.setLoggingLevel(Level.INFO);
        return closureCompiler;
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
public String compile(String code) {
	Compiler compiler = new Compiler();
	compiler.disableThreads();
	
	SourceFile extern = SourceFile.fromCode("externs.js","function alert(x) {}");
	SourceFile input = SourceFile.fromCode("input.js", code);
	
	compiler.compile(extern, input, options);
	return compiler.toSource();
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
  Compiler compiler = new Compiler(System.err);
  compiler.disableThreads(); // Makes errors easier to track down.

  List<SourceFile> inputs = ImmutableList.of(
      SourceFile.fromInputStream("stdin", System.in, StandardCharsets.UTF_8)
  );

  CompilerOptions options = new CompilerOptions();
  Result result = compiler.compile(
      Collections.<SourceFile>emptyList(), inputs, options);
  dump(compiler.getRoot(), 0, System.out);
  System.out.append("\n");
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
private void testPropType(String reactPropType, String typeExpression) {
  Compiler compiler = new Compiler();
  CompilerOptions options = new CompilerOptions();
  // So that source dumps still have JSDoc
  options.preserveTypeAnnotations = true;
  compiler.initOptions(options);
  // Avoid extra "use strict" boilerplate in output.
  options.setEmitUseStrict(false);
  compiler.disableThreads(); // Makes errors easier to track down.
  Node reactPropTypeNode = compiler.parse(
      SourceFile.fromCode("/src/test.js", reactPropType))
      .getFirstChild().getFirstChild();
  assertArrayEquals(new JSError[]{}, compiler.getErrors());

  Node typeNode = PropTypesExtractor.convertPropType(reactPropTypeNode)
      .typeNode;

  // Easiest way to stringify the type node is to print it out as JSDoc.
  JSDocInfoBuilder jsDocInfoBuilder = new JSDocInfoBuilder(true);
  jsDocInfoBuilder.recordType(new JSTypeExpression(
      typeNode, "/src/test.js"));
  Node tempNode = IR.var(IR.name("temp"));
  tempNode.setJSDocInfo(jsDocInfoBuilder.build());
  String tempCode = compiler.toSource(tempNode);

  assertEquals("/** @type {" + typeExpression + "} */ var temp", tempCode);
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
@Override
public String process(File[] srcFiles) throws ProcessException {
    CompilerOptions compilerOptions = new CompilerOptions();
    compilerOptions.setCodingConvention(new ClosureCodingConvention());
    compilerOptions.setOutputCharset("UTF-8");
    compilerOptions.setWarningLevel(DiagnosticGroups.CHECK_VARIABLES, CheckLevel.WARNING);
    compilerOptions.setLanguage(CompilerOptions.LanguageMode.ECMASCRIPT5);
    CompilationLevel.SIMPLE_OPTIMIZATIONS.setOptionsForCompilationLevel(compilerOptions);

    Compiler compiler = new Compiler();
    compiler.disableThreads();
    compiler.initOptions(compilerOptions);

    ArrayList<SourceFile> inputFiles = new ArrayList<SourceFile>();

    for (File srcFile : srcFiles) {
        SourceFile inputFile = SourceFile.fromFile(srcFile);
        inputFiles.add(inputFile);
    }

    Result result = compiler.compile(new ArrayList<SourceFile>(), inputFiles, compilerOptions);

    if (!result.success) {
        throw new ProcessException("Failure when processing javascript files!");
    }

    return compiler.toSource();
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
@Override
public void process(final Reader reader, final Writer writer) throws IOException {
    logger.debug("google closure processing...");
    final String originalJsSourceCode = IOUtils.toString(reader);
    try {
        Compiler.setLoggingLevel(Level.SEVERE);
        final Compiler compiler = new Compiler();
        final CompilerOptions compilerOptions = newCompilerOptions();
        compilationLevel.setOptionsForCompilationLevel(compilerOptions);
        //make it play nice with GAE
        compiler.disableThreads();
        compiler.initOptions(compilerOptions);

        final SourceFile input = SourceFile.fromInputStream("dummy.js", new ByteArrayInputStream(originalJsSourceCode.getBytes(soyViewConf.globalEncoding())));
        final Result result = compiler.compile(Lists.<SourceFile>newArrayList(), Lists.newArrayList(input), compilerOptions);

        logWarningsAndErrors(result);

        boolean origFallback = false;
        if (result.success) {
            final String minifiedJsSourceCode = compiler.toSource();
            if (StringUtils.isEmpty(minifiedJsSourceCode)) {
                origFallback = true;
            } else {
                writer.write(minifiedJsSourceCode);
            }
        } else {
            origFallback = true;
        }
        if (origFallback) {
            writer.write(originalJsSourceCode);
        }
    } finally {
        reader.close();
        writer.close();
    }
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
private static Compiler createCompiler(
    List<SourceFile> inputs, List<SourceFile> externs, CompilerOptions compilerOptions) {
  Compiler compiler = new Compiler(new BlackHoleErrorManager());
  compiler.disableThreads();
  compiler.compile(externs, inputs, compilerOptions);
  return compiler;
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
@Before
public void setUp() {
  errorManager = new FixingErrorManager();
  compiler = new Compiler(errorManager);
  compiler.disableThreads();
  errorManager.setCompiler(compiler);

  options = RefactoringDriver.getCompilerOptions();
  options.setWarningLevel(DiagnosticGroups.ANALYZER_CHECKS, WARNING);
  options.setWarningLevel(DiagnosticGroups.CHECK_VARIABLES, ERROR);
  options.setWarningLevel(DiagnosticGroups.DEBUGGER_STATEMENT_PRESENT, ERROR);
  options.setWarningLevel(DiagnosticGroups.LINT_CHECKS, WARNING);
  options.setWarningLevel(DiagnosticGroups.STRICT_MISSING_REQUIRE, ERROR);
  options.setWarningLevel(DiagnosticGroups.EXTRA_REQUIRE, ERROR);
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
private static Compiler getCompiler(String externs, String jsInput) {
  Compiler compiler = new Compiler(new BlackHoleErrorManager());
  compiler.disableThreads();
  CompilerOptions options = RefactoringDriver.getCompilerOptions();
  compiler.compile(
      ImmutableList.of(SourceFile.fromCode("externs", externs)),
      ImmutableList.of(SourceFile.fromCode("test", jsInput)),
      options);
  return compiler;
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
@Override
public String process(final String filename, final String source, final Config conf)
    throws Exception {
  final CompilerOptions copts = new CompilerOptions();
  copts.setCodingConvention(new ClosureCodingConvention());
  copts.setOutputCharset("UTF-8");
  copts.setWarningLevel(DiagnosticGroups.CHECK_VARIABLES, CheckLevel.WARNING);
  CompilationLevel level = level(get("level"));
  level.setOptionsForCompilationLevel(copts);

  Compiler.setLoggingLevel(Level.SEVERE);
  Compiler compiler = new Compiler();
  compiler.disableThreads();
  compiler.initOptions(copts);

  List<SourceFile> externs = externs(copts);
  Result result = compiler.compile(externs,
      ImmutableList.of(SourceFile.fromCode(filename, source)), copts);
  if (result.success) {
    return compiler.toSource();
  }
  List<AssetProblem> errors = Arrays.stream(result.errors)
      .map(error -> new AssetProblem(error.sourceName, error.lineNumber, error.getCharno(),
          error.description, null))
      .collect(Collectors.toList());
  throw new AssetException(name(), errors);
}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
@Override
public String compress(String source) {
	
	StringWriter writer = new StringWriter();
	
	//prepare source
	List<JSSourceFile> input = new ArrayList<JSSourceFile>();
	input.add(JSSourceFile.fromCode("source.js", source));
	
	//prepare externs
	List<JSSourceFile> externsList = new ArrayList<JSSourceFile>();
	if(compilationLevel.equals(CompilationLevel.ADVANCED_OPTIMIZATIONS)) {
		//default externs
		if(!customExternsOnly) {
			try {
				externsList = getDefaultExterns();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		//add user defined externs
		if(externs != null) {
			for(JSSourceFile extern : externs) {
				externsList.add(extern);
			}
		}
		//add empty externs
		if(externsList.size() == 0) {
			externsList.add(JSSourceFile.fromCode("externs.js", ""));
		}
	} else {
		//empty externs
		externsList.add(JSSourceFile.fromCode("externs.js", ""));
	}
	
	Compiler.setLoggingLevel(loggingLevel);
	
	Compiler compiler = new Compiler();
	compiler.disableThreads();
	
	compilationLevel.setOptionsForCompilationLevel(compilerOptions);
	warningLevel.setOptionsForWarningLevel(compilerOptions);
	
	Result result = compiler.compile(externsList, input, compilerOptions);
	
	if (result.success) {
		writer.write(compiler.toSource());
	} else {
		writer.write(source);
	}

	return writer.toString();

}
 

import com.google.javascript.jscomp.Compiler; //导入方法依赖的package包/类
/**
 * Outputs the source equivalent of the abstract syntax tree, optionally generating a sourcemap.
 *
 * @param node The JavaScript abstract syntax tree.
 * @param outputFormat The source output format options.
 * @param inputFileName The source file name to associate with the input node, used for sourcemap
 *     generation.
 * @param inputSourceMap The content of the input sourcemap.
 * @param sourceMapOutputFileName The name of the output sourcemap.
 * @return The equivalent JavaScript source.
 */
private static String outputSource(
    Node node,
    ImmutableSet<OutputFormat> outputFormat,
    String inputFileName,
    String inputSourceMap,
    String sourceMapOutputFileName) {
  CompilerOptions options = new CompilerOptions();
  options.setPrettyPrint(outputFormat.contains(OutputFormat.PRETTY));
  options.setPreferSingleQuotes(outputFormat.contains(OutputFormat.SINGLE_QUOTE_STRINGS));
  // The Closure Compiler treats the 'use strict' directive as a property of a node. CodeBuilder
  // doesn't consider directives during its code generation. Instead, it inserts the 'use strict'
  // directive if it is in a strict language mode.
  Set<String> directives = node.getDirectives();
  if ((directives != null) && directives.contains("use strict")) {
    options.setLanguage(CompilerOptions.LanguageMode.ECMASCRIPT_2015);
    options.setEmitUseStrict(true);
  }
  options.skipAllCompilerPasses();

  if (inputSourceMap != null) {
    SourceFile sourceMapSourceFile = SourceFile.fromCode("input.sourcemap", inputSourceMap);
    ImmutableMap<String, SourceMapInput> inputSourceMaps =
        ImmutableMap.of(inputFileName, new SourceMapInput(sourceMapSourceFile));
    options.setInputSourceMaps(inputSourceMaps);
    options.setApplyInputSourceMaps(true);
    // Simply setting the path to any non-null value will trigger source map generation.
    // Since sourceMapOutputPath is handled by AbstractCommandLineRunner and not the Compiler
    // itself, we manually output the final sourcemap below.
    options.setSourceMapOutputPath("/dev/null");
  }

  Compiler compiler = new Compiler();
  compiler.disableThreads();
  compiler.initOptions(options);
  compiler.initBasedOnOptions();
  Compiler.CodeBuilder cb = new Compiler.CodeBuilder();
  compiler.toSource(cb, 0, node);

  if (inputFileName != null && inputSourceMap != null && sourceMapOutputFileName != null) {
    try {
      FileOutputStream fileOut = new FileOutputStream(sourceMapOutputFileName);
      OutputStreamWriter out = new OutputStreamWriter(fileOut, UTF_8);
      compiler.getSourceMap().appendTo(out, "renamed.js");
      out.close();
    } catch (Exception e) {
      System.err.println(e + "Error writing output sourcemap.");
    }
  }

  return cb.toString();
}