List of usage examples for org.eclipse.jdt.internal.compiler DefaultErrorHandlingPolicies exitAfterAllProblems
public static IErrorHandlingPolicy exitAfterAllProblems()
From source file:br.com.objectos.code.JdtCompilerBuilderPojo.java
License:Apache License
@Override public JdtCompiler build() { NameEnvironment environment = new NameEnvironment(); IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.exitAfterAllProblems(); CompilerOptions options = new CompilerOptions(); options.set(optionMap.build());//from ww w. jav a 2 s . c o m IProblemFactory problemFactory = ProblemFactory.getProblemFactory(Locale.getDefault()); Compiler delegate = new Compiler(environment, policy, options, requestor, problemFactory); annotationProcessorManager.set(delegate); return new JdtCompiler(delegate); }
From source file:com.mysema.codegen.ECJEvaluatorFactory.java
License:Apache License
protected void compile(String source, ClassType projectionType, String[] names, Type[] types, String id, Map<String, Object> constants) throws IOException { // create source source = createSource(source, projectionType, names, types, id, constants); // compile// w ww . ja va 2 s. com final char[] targetContents = source.toCharArray(); final String targetName = id; final ICompilationUnit[] targetCompilationUnits = new ICompilationUnit[] { new ICompilationUnit() { @Override public char[] getContents() { return targetContents; } @Override public char[] getMainTypeName() { int dot = targetName.lastIndexOf('.'); if (dot > 0) return targetName.substring(dot + 1).toCharArray(); else return targetName.toCharArray(); } @Override public char[][] getPackageName() { StringTokenizer tok = new StringTokenizer(targetName, "."); char[][] result = new char[tok.countTokens() - 1][]; for (int j = 0; j < result.length; j++) { result[j] = tok.nextToken().toCharArray(); } return result; } @Override public char[] getFileName() { return CharOperation.concat(targetName.toCharArray(), ".java".toCharArray()); } @Override public boolean ignoreOptionalProblems() { return true; } } }; INameEnvironment env = new INameEnvironment() { private String join(char[][] compoundName, char separator) { if (compoundName == null) { return ""; } else { List<String> parts = Lists.newArrayListWithCapacity(compoundName.length); for (char[] part : compoundName) { parts.add(new String(part)); } return Joiner.on(separator).join(parts); } } @Override public NameEnvironmentAnswer findType(char[][] compoundTypeName) { return findType(join(compoundTypeName, '.')); } @Override public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName) { return findType(CharOperation.arrayConcat(packageName, typeName)); } private boolean isClass(String result) { if (Strings.isNullOrEmpty(result)) { return false; } // if it's the class we're compiling, then of course it's a class if (result.equals(targetName)) { return true; } InputStream is = null; try { // if this is a class we've already compiled, it's a class is = loader.getResourceAsStream(result); if (is == null) { // use our normal class loader now... String resourceName = result.replace('.', '/') + ".class"; is = parentClassLoader.getResourceAsStream(resourceName); if (is == null && !result.contains(".")) { // we couldn't find the class, and it has no package; is it a core class? is = parentClassLoader.getResourceAsStream("java/lang/" + resourceName); } } return is != null; } finally { if (is != null) { try { is.close(); } catch (IOException ex) { } } } } @Override public boolean isPackage(char[][] parentPackageName, char[] packageName) { // if the parent is a class, the child can't be a package String parent = join(parentPackageName, '.'); if (isClass(parent)) return false; // if the child is a class, it's not a package String qualifiedName = (parent.isEmpty() ? "" : parent + ".") + new String(packageName); return !isClass(qualifiedName); } @Override public void cleanup() { } private NameEnvironmentAnswer findType(String className) { String resourceName = className.replace('.', '/') + ".class"; InputStream is = null; try { // we're only asking ECJ to compile a single class; we shouldn't need this if (className.equals(targetName)) { return new NameEnvironmentAnswer(targetCompilationUnits[0], null); } is = loader.getResourceAsStream(resourceName); if (is == null) { is = parentClassLoader.getResourceAsStream(resourceName); } if (is != null) { ClassFileReader cfr = new ClassFileReader(ByteStreams.toByteArray(is), className.toCharArray(), true); return new NameEnvironmentAnswer(cfr, null); } else { return null; } } catch (ClassFormatException ex) { throw new RuntimeException(ex); } catch (IOException e) { throw new RuntimeException(e); } finally { if (is != null) { try { is.close(); } catch (IOException e) { } } } } }; ICompilerRequestor requestor = new ICompilerRequestor() { @Override public void acceptResult(CompilationResult result) { if (result.hasErrors()) { for (CategorizedProblem problem : result.getProblems()) { if (problem.isError()) { problemList.add(problem.getMessage()); } } } else { for (ClassFile clazz : result.getClassFiles()) { try { MemJavaFileObject jfo = (MemJavaFileObject) fileManager.getJavaFileForOutput( StandardLocation.CLASS_OUTPUT, new String(clazz.fileName()), JavaFileObject.Kind.CLASS, null); OutputStream os = jfo.openOutputStream(); os.write(clazz.getBytes()); } catch (IOException ex) { throw new RuntimeException(ex); } } } } }; problemList.clear(); IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.exitAfterAllProblems(); IProblemFactory problemFactory = new DefaultProblemFactory(Locale.getDefault()); try { //Compiler compiler = new Compiler(env, policy, getCompilerOptions(), requestor, problemFactory, true); Compiler compiler = new Compiler(env, policy, compilerOptions, requestor, problemFactory); compiler.compile(targetCompilationUnits); if (!problemList.isEmpty()) { StringBuilder sb = new StringBuilder(); for (String problem : problemList) { sb.append("\t").append(problem).append("\n"); } throw new CodegenException("Compilation of " + id + " failed:\n" + source + "\n" + sb.toString()); } } catch (RuntimeException ex) { // if we encountered an IOException, unbox and throw it; // if we encountered a ClassFormatException, box it as an IOException and throw it // otherwise, it's a legit RuntimeException, // not one of our checked exceptions boxed as unchecked; just rethrow Throwable cause = ex.getCause(); if (cause != null) { if (cause instanceof IOException) { throw (IOException) cause; } else if (cause instanceof ClassFormatException) { throw new IOException(cause); } } throw ex; } }
From source file:io.gige.compiler.internal.CompilationTaskImpl.java
License:Apache License
protected IErrorHandlingPolicy getHandlingPolicy() { return DefaultErrorHandlingPolicies.exitAfterAllProblems(); }
From source file:io.takari.maven.plugins.compile.jdt.CompilerJdt.java
License:Open Source License
@Override public int compile() throws MojoExecutionException, IOException { Map<String, String> args = new HashMap<String, String>(); // XXX figure out how to reuse source/target check from jdt // org.eclipse.jdt.internal.compiler.batch.Main.validateOptions(boolean) args.put(CompilerOptions.OPTION_TargetPlatform, getTarget()); // support 5/6/7 aliases args.put(CompilerOptions.OPTION_Compliance, getTarget()); // support 5/6/7 aliases args.put(CompilerOptions.OPTION_Source, getSource()); // support 5/6/7 aliases args.put(CompilerOptions.OPTION_ReportForbiddenReference, CompilerOptions.ERROR); Set<Debug> debug = getDebug(); if (debug == null || debug.contains(Debug.all)) { args.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.GENERATE); args.put(CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE); args.put(CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE); } else if (debug.contains(Debug.none)) { args.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.DO_NOT_GENERATE); args.put(CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.DO_NOT_GENERATE); args.put(CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.DO_NOT_GENERATE); } else {//from w ww. j ava 2 s . c om args.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.DO_NOT_GENERATE); args.put(CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.DO_NOT_GENERATE); args.put(CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.DO_NOT_GENERATE); for (Debug keyword : debug) { switch (keyword) { case lines: args.put(CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE); break; case source: args.put(CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE); break; case vars: args.put(CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.GENERATE); break; default: throw new IllegalArgumentException(); } } } class _CompilerOptions extends CompilerOptions { public void setShowWarnings(boolean showWarnings) { if (showWarnings) { warningThreshold = IrritantSet.COMPILER_DEFAULT_WARNINGS; } else { warningThreshold = new IrritantSet(0); } } } _CompilerOptions compilerOptions = new _CompilerOptions(); compilerOptions.set(args); compilerOptions.performMethodsFullRecovery = false; compilerOptions.performStatementsRecovery = false; compilerOptions.verbose = isVerbose(); compilerOptions.suppressWarnings = true; compilerOptions.setShowWarnings(isShowWarnings()); compilerOptions.docCommentSupport = true; if (isProcEscalate() && strategy instanceof IncrementalCompilationStrategy) { strategy.enqueueAllSources(); strategy = new FullCompilationStrategy(); } Classpath namingEnvironment = strategy.createClasspath(); IErrorHandlingPolicy errorHandlingPolicy = DefaultErrorHandlingPolicies.exitAfterAllProblems(); IProblemFactory problemFactory = ProblemFactory.getProblemFactory(Locale.getDefault()); Compiler compiler = new Compiler(namingEnvironment, errorHandlingPolicy, compilerOptions, this, problemFactory); compiler.options.produceReferenceInfo = true; EclipseFileManager fileManager = null; try { if (!isProcNone()) { fileManager = new EclipseFileManager(null, getSourceEncoding()); fileManager.setLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH, dependencies); fileManager.setLocation(StandardLocation.CLASS_OUTPUT, Collections.singleton(getOutputDirectory())); fileManager.setLocation(StandardLocation.SOURCE_OUTPUT, Collections.singleton(getGeneratedSourcesDirectory())); ProcessingEnvImpl processingEnv = new ProcessingEnvImpl(context, fileManager, getAnnotationProcessorOptions(), compiler, this); compiler.annotationProcessorManager = new AnnotationProcessorManager(processingEnv, fileManager, getAnnotationProcessors()); compiler.options.storeAnnotations = true; } return strategy.compile(namingEnvironment, compiler); } finally { if (fileManager != null) { fileManager.flush(); fileManager.close(); } } }
From source file:org.eclipse.ajdt.core.parserbridge.AJSourceElementParser2.java
License:Open Source License
public AJSourceElementParser2(AJCompilationUnitStructureRequestor requestor, // AspectJ Change IProblemFactory problemFactory, CompilerOptions options, boolean reportLocalDeclarations, boolean optimizeStringLiterals, boolean useSourceJavadocParser) { super(new ProblemReporter(DefaultErrorHandlingPolicies.exitAfterAllProblems(), options, problemFactory), optimizeStringLiterals);/*from ww w . jav a 2 s . c o m*/ this.reportLocalDeclarations = reportLocalDeclarations; // we want to notify all syntax error with the acceptProblem API // To do so, we define the record method of the ProblemReporter this.problemReporter = new ProblemReporter(DefaultErrorHandlingPolicies.exitAfterAllProblems(), options, problemFactory) { public void record(CategorizedProblem problem, CompilationResult unitResult, ReferenceContext context) { unitResult.record(problem, context); // TODO (jerome) clients are trapping problems either through factory or requestor... is result storing needed? AJSourceElementParser2.this.requestor.acceptProblem(problem); } }; this.requestor = requestor; this.options = options; this.notifier = new AJSourceElementNotifier(this.requestor, reportLocalDeclarations); // AspectJ Change // set specific javadoc parser this.useSourceJavadocParser = useSourceJavadocParser; if (useSourceJavadocParser) { this.javadocParser = new SourceJavadocParser(this); } }
From source file:org.eclipse.jdt.internal.core.hierarchy.HierarchyResolver.java
License:Open Source License
public HierarchyResolver(INameEnvironment nameEnvironment, Map settings, HierarchyBuilder builder, IProblemFactory problemFactory) { // create a problem handler with the 'exit after all problems' handling policy this.options = new CompilerOptions(settings); IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.exitAfterAllProblems(); ProblemReporter problemReporter = new ProblemReporter(policy, this.options, problemFactory); setEnvironment(new LookupEnvironment(this, this.options, problemReporter, nameEnvironment), builder); }