/** * This option is only supported on JDK 8 and older and will be ignored when source level is 9 or newer. * @since 2.7 * @see https://www.oracle.com/technetwork/java/javase/9-relnote-issues-3704069.html */ public void setBootClassPath(String bootClassPath) { JavaVersion version = JavaVersion.fromQualifier(getJavaSourceVersion()); if (version.isAtLeast(JavaVersion.JAVA9)) { if (!bootClassPath.isEmpty()) { log.warn("Option bootClassPath is only valid for Java 8 and lower. The value '"+bootClassPath+"' will be ignored."); } } else { this.bootClassPath = bootClassPath; } }
/** Change the version of the Java source to be used for the generated Java files. * * @param version the Java version. */ public void setJavaSourceVersion(String version) { final JavaVersion javaVersion = JavaVersion.fromQualifier(version); if (javaVersion == null) { final List<String> qualifiers = new ArrayList<>(); for (final JavaVersion vers : JavaVersion.values()) { qualifiers.add(vers.getQualifier()); } throw new RuntimeException(MessageFormat.format( Messages.SarlBatchCompiler_0, version, Joiner.on(Messages.SarlBatchCompiler_1).join(qualifiers))); } getGeneratorConfig().setJavaSourceVersion(javaVersion); }
private long toClassFmt(final JavaVersion version) { return version.toJdtClassFileConstant(); }
/** * @since 2.8 */ public void setJavaSourceVersion(final String javaSourceVersion) { JavaVersion javaVersion = JavaVersion.fromQualifier(javaSourceVersion); if(javaVersion == null) { List<String> qualifiers = Lists.newArrayList(); for (JavaVersion version : JavaVersion.values()) qualifiers.addAll(version.getAllQualifiers()); throw new IllegalArgumentException("Unknown Java Version Qualifier: '" + javaSourceVersion + "'. Valid values are: '" + Joiner.on(", ").join(qualifiers) + "'"); } generatorConfig.setJavaSourceVersion(javaVersion); }
/** Replies if the generation is for Java version 8 at least. * * @param context the context. * @return {@code true} if Java 8 or newer. */ protected boolean isAtLeastJava8(EObject context) { return this.generatorConfigProvider.get(EcoreUtil.getRootContainer(context)).getJavaSourceVersion().isAtLeast(JavaVersion.JAVA8); }
version = JavaVersion.fromQualifier(this.source); scriptExecutor.setJavaSourceVersion(version.getQualifier()); scriptExecutor.setTempFolder(this.tempDirectory.getAbsoluteFile());
private static void printUsage() { PrintStream out = System.out; String allVersionQualifiers = Arrays.stream(JavaVersion.values()) .map(v -> v.getQualifier()) .collect(Collectors.joining(", ")); out.println("Usage: Main <options> <source directories>"); out.println("where possible options include:"); out.println("-d <directory> Specify where to place generated xtend files"); out.println("-tp <path> Temp directory to hold generated stubs and classes"); out.println("-cp <path> Specify where to find user class files"); out.println("-encoding <encoding> Specify character encoding used by source files"); out.println("-javaSourceVersion <version> Create Java Source compatible to this version. Can be: " + allVersionQualifiers); out.println("-noSuppressWarningsAnnotation Don't put @SuppressWarnings() into generated Java Code"); out.println("-generateGeneratedAnnotation Put @Generated into generated Java Code"); out.println("-includeDateInGeneratedAnnnotation If -generateGeneratedAnnotation is used, add the current date/time."); out.println("-generateAnnotationComment <string> If -generateGeneratedAnnotation is used, add a comment."); out.println("-useCurrentClassLoader Use current classloader as parent classloader"); out.println("-writeTraceFiles Write Trace-Files"); }
public static JavaVersion fromBree(String bree) { for (JavaVersion version : JavaVersion.values()) { if (version.bree.equals(bree)) return version; } return null; }
/** * @since 2.8 */ public String getJavaSourceVersion() { return generatorConfig.getJavaSourceVersion().getQualifier(); }
/** Invoked for creating the default generator configuration. * * @return the configuration. */ protected GeneratorConfig createDefaultGeneratorConfig() { final GeneratorConfig config = new GeneratorConfig(); if (this.defaultVersion == null) { this.defaultVersion = JavaVersion.fromQualifier(System.getProperty("java.specification.version")); //$NON-NLS-1$ if (this.defaultVersion != null) { config.setJavaSourceVersion(this.defaultVersion); } } else { config.setJavaSourceVersion(this.defaultVersion); } return config; }
protected String getComplianceLevelArg() { JavaVersion javaVersion = JavaVersion.JAVA5; if (generatorConfigProvider != null) { GeneratorConfig generatorConfig = generatorConfigProvider.get(null); javaVersion = generatorConfig.getJavaSourceVersion(); } return javaVersion.getComplianceLevelArg(); }
protected void setOverride(JvmOperation operation) { if (generatorConfig.getJavaSourceVersion().isAtLeast(JAVA6) && !containsAnnotation(operation, Override.class)) { operation.getAnnotations().add(_annotationTypesBuilder.annotationRef(Override.class)); } }
version = JavaVersion.fromQualifier(this.source); it.append(Strings.convertToJavaString(version.getQualifier())); it.append("\");"); //$NON-NLS-1$ it.newLine();
public static JavaVersion fromQualifier(String qualifier) { JavaVersion[] values = JavaVersion.values(); // iterate backwards since it's a fair assumption that we'll use a more recent java version for(int i = values.length - 1; i >= 0; i--) { JavaVersion candidate = values[i]; if (Arrays.contains(candidate.qualifiers, qualifier)) return candidate; } return null; }
/** Replies the version of the Java source to be used for the generated Java files. * * @return the Java version. */ @Pure public String getJavaSourceVersion() { return getGeneratorConfig().getJavaSourceVersion().getQualifier(); }
protected GeneratorConfig getGeneratorConfig(EObject element) { GeneratorConfig result = (GeneratorConfig) getContext().get(GeneratorConfig.class); if (result == null) { result = generatorConfigProvider.get(element); getContext().put(GeneratorConfig.class, result); if (result.getJavaSourceVersion().isAtLeast(JAVA8)) { methodInInterfaceModifierValidator = new ModifierValidator( newArrayList("public", "abstract", "static", "def", "override"), this); } else { methodInInterfaceModifierValidator = new ModifierValidator( newArrayList("public", "abstract", "def", "override"), this); } } return result; }
/** Replies if the compiler is using Java8 or higher. * * @return <code>true</code> if the compiler uses Java8 or higher. Otherwise <code>false</code>. */ public boolean isAtLeastJava8() { final JavaVersion javaVersion = JavaVersion.fromQualifier(SARLVersion.MINIMAL_JDK_VERSION); return javaVersion != null && getGeneratorConfig().getJavaSourceVersion().isAtLeast(javaVersion); }
protected long toJdtVersion(final JavaVersion version) { return version.toJdtClassFileConstant(); }
protected List<IResolvedOperation> computeAllOperations() { JvmType rawType = getRawType(); if (!(rawType instanceof JvmDeclaredType)) { return Collections.emptyList(); } Multimap<String, AbstractResolvedOperation> processedOperations = LinkedHashMultimap.create(); for (IResolvedOperation resolvedOperation : getDeclaredOperations()) { processedOperations.put(resolvedOperation.getDeclaration().getSimpleName(), (AbstractResolvedOperation) resolvedOperation); } if (targetVersion.isAtLeast(JavaVersion.JAVA8)) { computeAllOperationsFromSortedSuperTypes((JvmDeclaredType) rawType, processedOperations); } else { Set<JvmType> processedTypes = Sets.newHashSet(rawType); computeAllOperationsFromSuperTypes((JvmDeclaredType) rawType, processedOperations, processedTypes); } // make sure the declared operations are the first in the list List<IResolvedOperation> result = new ArrayList<IResolvedOperation>(processedOperations.size()); result.addAll(getDeclaredOperations()); for (AbstractResolvedOperation operation : processedOperations.values()) { if (operation.getDeclaration().getDeclaringType() != rawType) { result.add(operation); } } return Collections.unmodifiableList(result); }