truffle: graal/com.oracle.max.asmdis/src/com/sun/max/asm/gen/AssemblerGenerator.java comparison

comparison graal/com.oracle.max.asmdis/src/com/sun/max/asm/gen/AssemblerGenerator.java @ 4142:bc8527f3071c

Adjust code base to new level of warnings.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sun, 18 Dec 2011 05:24:06 +0100
parents	e233f5660da4
children

comparison

equal deleted inserted replaced

-:04d21be7a24f
+:bc8527f3071c
 return name + "(" + paramTypes.substring(1, paramTypes.length() - 1) + ")";
 }
 }
-private List<Template_Type> filterTemplates(List<Template_Type> templates) {
+private List<Template_Type> filterTemplates(List<Template_Type> templateList) {
 if (!generateRedundantInstructionsOption.getValue()) {
-final List<Template_Type> result = new LinkedList<Template_Type>();
+final List<Template_Type> result = new LinkedList<>();
-for (Template_Type template : templates) {
+for (Template_Type template : templateList) {
 if (!template.isRedundant()) {
 result.add(template);
 }
 }
 return result;
 }
-return templates;
+return templateList;
 }
 /**
 * Initializes the set of label and raw templates that will be generated as assembler methods.
 * This includes doing any filtering out of templates based on an {@linkplain #assemblerInterfaceNameOption assembler interface}.
 final String assemblerInterfaceName = assemblerInterfaceNameOption.getValue();
 if (assemblerInterfaceName == null) {
 templates = filterTemplates(assembly().templates());
 labelTemplates = filterTemplates(assembly().labelTemplates());
 } else {
-final List<Template_Type> newTemplates = new ArrayList<Template_Type>();
+final List<Template_Type> newTemplates = new ArrayList<>();
-final List<Template_Type> newLabelTemplates = new ArrayList<Template_Type>();
+final List<Template_Type> newLabelTemplates = new ArrayList<>();
 Class assemberInterface = null;
 try {
 assemberInterface = Class.forName(assemblerInterfaceName);
 ProgramError.check(assemberInterface.isInterface(), "The class " + assemblerInterfaceName + " is not an interface");
 } catch (ClassNotFoundException e) {
 throw ProgramError.unexpected("The assembler interface class " + assemblerInterfaceName + " must be on the class path");
 }
-final Set<MethodKey> assemblerInterfaceMethods = new HashSet<MethodKey>();
+final Set<MethodKey> assemblerInterfaceMethods = new HashSet<>();
 for (Method assemblerInterfaceMethod : assemberInterface.getDeclaredMethods()) {
 assemblerInterfaceMethods.add(new MethodKey(assemblerInterfaceMethod));
 }
 for (Template_Type labelTemplate : assembly().labelTemplates()) {
 */
 private File getSourceFileFor(String className) {
 return new File(outputDirectoryOption.getValue(), className.replace('.', File.separatorChar) + ".java").getAbsoluteFile();
 }
-protected final String formatParameterList(String separator, List<? extends Parameter> parameters, boolean typesOnly) {
+protected static final String formatParameterList(String separator, List<? extends Parameter> parameters, boolean typesOnly) {
 String sep = separator;
 final StringBuilder sb = new StringBuilder();
 for (Parameter parameter : parameters) {
 sb.append(sep);
 sb.append(Classes.getSimpleName(parameter.type(), true));
 */
 protected abstract int printMethod(IndentWriter writer, Template_Type template);
 /**
 * Prints the source code for support methods that are used by the methods printed by {@link #printMethod(IndentWriter, Template)}.
+* @param writer
 *
 * @return the number of subroutines printed
 */
 protected int printSubroutines(IndentWriter writer) {
 return 0;
 * @param templateList the list of templates for which code is being generated
 * @return a set of packages sorted by name
 */
 public Set<String> getImportPackages(String className, Iterable<Template_Type> templateList) {
 final String outputPackage = getPackageName(className);
-final Set<String> packages = new TreeSet<String>();
+final Set<String> packages = new TreeSet<>();
 packages.add(getPackageName(AssemblyException.class));
 packages.add(getPackageName(Label.class));
 for (Template_Type template : templateList) {
 for (Parameter parameter : template.parameters()) {
 final Class type = parameter.type();
 * This method is overridden by subclasses that may generate the code for 2 related label templates
 * in a single assembler method. For example, on X86 most branch instructions can take offsets of variable bit widths
 * and the logic for decoding the bit width of a {@link Label} value may be generated in a single assembler method.
 * <p>
 * The default implementation of this method returns {@code false}.
+* @param labelTemplate
 */
 protected boolean omitLabelTemplate(Template_Type labelTemplate) {
 return false;
 }
 /**
 * Gets a reference to the architecture manual section describing the given template. The
 * returned string should conform to the format of the {@code @see} Javadoc tag.
+* @param template
 */
 protected String getJavadocManualReference(Template_Type template) {
 return null;
 }
 * print what raw instruction they are derived from.
 *
 * @param extraLinks
 *                a sequence to which extra javadoc links should be appended
 */
+@SuppressWarnings("unused")
 protected void printExtraMethodJavadoc(IndentWriter writer, Template_Type template, List<String> extraLinks, boolean forLabelAssemblerMethod) {
 }
 private boolean seenNoSuchAssemblerMethodError;
 * Writes the Javadoc comment for an assembler method.
 *
 * @param template the template from which the assembler method is generated
 */
 protected void printMethodJavadoc(IndentWriter writer, Template_Type template, boolean forLabelAssemblerMethod) {
-final List<String> extraLinks = new LinkedList<String>();
+final List<String> extraLinks = new LinkedList<>();
 final List<? extends Parameter> parameters = getParameters(template, forLabelAssemblerMethod);
 writer.println("/**");
 writer.println(" * Pseudo-external assembler syntax: {@code " + template.externalName() + externalMnemonicSuffixes(parameters) + "  }" + externalParameters(parameters));
 final boolean printExampleInstruction = true;
 if (printExampleInstruction) {
-final List<Argument> arguments = new ArrayList<Argument>();
+final List<Argument> arguments = new ArrayList<>();
 final AddressMapper addressMapper = new AddressMapper();
 for (Parameter p : template.parameters()) {
 final Argument exampleArg = p.getExampleArgument();
 if (exampleArg != null) {
 arguments.add(exampleArg);
 }
 }
 }
 printExtraMethodJavadoc(writer, template, extraLinks, forLabelAssemblerMethod);
-final List<InstructionConstraint> constraints = new ArrayList<InstructionConstraint>(template.instructionDescription().specifications().size());
+final List<InstructionConstraint> constraints = new ArrayList<>(template.instructionDescription().specifications().size());
 for (Object s : template.instructionDescription().specifications()) {
 if (s instanceof InstructionConstraint) {
 constraints.add((InstructionConstraint) s);
 }
 }
 writer.println(" */");
 }
 protected abstract DisassembledInstruction generateExampleInstruction(Template_Type template, List<Argument> arguments) throws AssemblyException;
-private String externalParameters(List< ? extends Parameter> parameters) {
+private static String externalParameters(List< ? extends Parameter> parameters) {
 final StringBuilder sb = new StringBuilder();
 boolean first = true;
 for (Parameter parameter : parameters) {
 if (!ExternalMnemonicSuffixArgument.class.isAssignableFrom(parameter.type())) {
 if (!first) {
 }
 }
 return sb.toString();
 }
-private String externalMnemonicSuffixes(List< ? extends Parameter> parameters) {
+private static String externalMnemonicSuffixes(List< ? extends Parameter> parameters) {
 final StringBuilder sb = new StringBuilder();
 for (Parameter parameter : parameters) {
 if (ExternalMnemonicSuffixArgument.class.isAssignableFrom(parameter.type())) {
 boolean first = true;
 String close = "]";
 final CharArraySource charArrayWriter = new CharArraySource((int) sourceFile.length());
 final IndentWriter writer = new IndentWriter(new PrintWriter(charArrayWriter));
 writer.indent();
 int codeLineCount = 0;
-final Map<InstructionDescription, Integer> instructionDescriptions = new HashMap<InstructionDescription, Integer>();
+final Map<InstructionDescription, Integer> instructionDescriptions = new HashMap<>();
 int maxTemplatesPerDescription = 0;
 int i = 0;
 for (Template_Type template : templateList) {
 printMethodComment(writer, template, i + 1, false);
 codeLineCount += printMethod(writer, template);
 protected static List<Parameter> getParameters(Template template, boolean forLabelAssemblerMethod) {
 if (!forLabelAssemblerMethod || template.labelParameterIndex() == -1) {
 final Class<List<Parameter>> type = null;
 return Utils.cast(type, template.parameters());
 }
-final List<Parameter> parameters = new ArrayList<Parameter>(template.parameters());
+final List<Parameter> parameters = new ArrayList<>(template.parameters());
 parameters.set(template.labelParameterIndex(), LabelParameter.LABEL);
 return parameters;
 }
 protected void printLabelMethodHead(IndentWriter writer, Template_Type template, List<Parameter> parameters) {
 assemblerClassName,
 labelInstructionSubclassGenerator);
 labelMethodHelperClasses.add(stringWriter.toString());
 }
-private final List<String> labelMethodHelperClasses = new ArrayList<String>();
+private final List<String> labelMethodHelperClasses = new ArrayList<>();
 private void printLabelMethodHelperClass(
 IndentWriter writer,
 Template_Type template,
 List<Parameter> parameters,
 if (rawAssemblerClassName.equals(labelAssemblerClassName)) {
 if (rawAssemblerMethodsUpdated || labelAssemblerMethodsUpdated) {
 System.out.println("modified: " + getSourceFileFor(rawAssemblerClassName));
 if (!ToolChain.compile(AssemblerGenerator.class, rawAssemblerClassName)) {
-List<Template_Type> allTemplates = new ArrayList<Template_Type>(templates());
+List<Template_Type> allTemplates = new ArrayList<>(templates());
 allTemplates.addAll(labelTemplates());
 throw ProgramError.unexpected("compilation failed for: " + rawAssemblerClassName +
 "[Maybe missing an import statement for one of the following packages: " +
 getImportPackages(rawAssemblerClassName, allTemplates));
 }

Mercurial > hg > truffle

comparison graal/com.oracle.max.asmdis/src/com/sun/max/asm/gen/AssemblerGenerator.java @ 4142:bc8527f3071c