Java tutorial
/******************************************************************************* * Copyright 2014, * Luis Pina <luis@luispina.me>, * Michael Hicks <mwh@cs.umd.edu> * * This file is part of Rubah. * * Rubah is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Rubah is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Rubah. If not, see <http://www.gnu.org/licenses/>. *******************************************************************************/ package rubah.tools; import java.io.BufferedWriter; import java.io.File; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.IOException; import java.lang.reflect.Modifier; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import org.apache.commons.io.IOUtils; import org.javatuples.Pair; import org.objectweb.asm.Opcodes; import rubah.bytecode.transformers.AddHashCodeField; import rubah.framework.Clazz; import rubah.framework.Field; import rubah.framework.Namespace; import rubah.framework.Type; import rubah.runtime.Version; import rubah.update.change.Change; import rubah.update.change.ChangeSet; import rubah.update.change.ChangeType; import rubah.update.change.ClassChange; import com.beust.jcommander.JCommander; import com.beust.jcommander.Parameter; import com.beust.jcommander.ParameterException; import com.beust.jcommander.converters.BooleanConverter; import com.beust.jcommander.converters.FileConverter; import freemarker.cache.StringTemplateLoader; import freemarker.template.Configuration; import freemarker.template.DefaultObjectWrapper; import freemarker.template.Template; import freemarker.template.TemplateException; public class UpdateClassGenerator implements Opcodes { public static final String V0_PREFFIX = "v0"; public static final String V1_PREFFIX = "v1"; public static final String METHOD_NAME = "convert"; public static final String METHOD_NAME_STATIC = "convertStatic"; public static final String COPY_METHOD_NAME_STATIC = "copyFields"; private static class ArgParser { @Parameter(converter = FileConverter.class, description = "Previous version descriptor", names = { "-v0" }, required = true) private File v0Descriptor; @Parameter(converter = FileConverter.class, description = "New version descriptor", names = { "-v1" }, required = true) private File v1Descriptor; @Parameter(converter = FileConverter.class, description = "File where to write the update class Java source", names = { "-u", "--update-class" }, required = true) private File outJavaFile; @Parameter(description = "Package of the generated Java source file", names = { "-p", "--package" }) private String outJavaPackage; @Parameter(converter = FileConverter.class, description = "Jar file where to writhe the conversion classes", names = { "-o", "--out" }, required = true) private File outJar; @Parameter(converter = BooleanConverter.class, description = "Flag that makes this tool generate conversion code for unchanged classes", names = { "-a", "--all" }) private boolean allClasses = false; } private final static Map<Type, String> primitiveNullValues; static { primitiveNullValues = new HashMap<Type, String>(); primitiveNullValues.put(Type.BOOLEAN_TYPE, "false"); primitiveNullValues.put(Type.BYTE_TYPE, "(byte) 0"); primitiveNullValues.put(Type.CHAR_TYPE, "\0"); primitiveNullValues.put(Type.DOUBLE_TYPE, "0.0"); primitiveNullValues.put(Type.FLOAT_TYPE, "0"); primitiveNullValues.put(Type.INT_TYPE, "0"); primitiveNullValues.put(Type.LONG_TYPE, "0L"); primitiveNullValues.put(Type.SHORT_TYPE, "0"); } private boolean allClasses; private Namespace defaultNamespace = new Namespace(); private Version v0, v1; private Map<Clazz, ClassChange> changes; private Map<Namespace, String> preffixes = new HashMap<Namespace, String>(); public static void main(String[] args) throws IOException { ArgParser parser = new ArgParser(); JCommander argParser = new JCommander(parser); try { argParser.parse(args); } catch (ParameterException e) { System.out.println(e.getMessage()); argParser.usage(); System.exit(1); } UpdateClassGenerator ucg = new UpdateClassGenerator(parser.v0Descriptor, parser.v1Descriptor, parser.allClasses); ucg.generateConversionJar(parser.outJar); ucg.generateUpdateClass(parser.outJavaFile, parser.outJavaPackage); } public UpdateClassGenerator(File v0Descriptor, File v1Descriptor, boolean allClasses) throws IOException { this.allClasses = allClasses; this.v0 = new Version(0, UpdatableJarAnalyzer.readFile(v0Descriptor, this.defaultNamespace), null); this.v1 = new Version(1, UpdatableJarAnalyzer.readFile(v1Descriptor, this.defaultNamespace), this.v0); this.preffixes.put(this.v0.getNamespace(), V0_PREFFIX); this.preffixes.put(this.v1.getNamespace(), V1_PREFFIX); this.changes = new Comparator(this.v0, this.v1).computeChanges(false); } public void generateUpdateClass(File outJavaFile, String outJavaPackage) throws IOException { String template = new String( IOUtils.toCharArray(UpdateClassGenerator.class.getResourceAsStream("/UpdateClass.template.java"))); Configuration cfg = new Configuration(); StringTemplateLoader loader = new StringTemplateLoader(); loader.putTemplate("template", template); cfg.setTemplateLoader(loader); cfg.setObjectWrapper(new DefaultObjectWrapper()); Template temp = cfg.getTemplate("template"); FileWriter fw = new FileWriter(outJavaFile); BufferedWriter bw = new BufferedWriter(fw); try { temp.process(this.buildTemplateModel(outJavaPackage), bw); } catch (TemplateException e) { throw new Error(e); } bw.close(); fw.close(); } private Map<String, Object> buildTemplateModel(String outJavaPackage) { Map<String, Object> templateModel = new HashMap<String, Object>(); templateModel.put("package", outJavaPackage); templateModel.put("namespace", this.defaultNamespace); templateModel.put("modifier", new Modifier()); templateModel.put("helper", this); templateModel.put("convertName", METHOD_NAME); templateModel.put("convertStaticName", METHOD_NAME_STATIC); templateModel.put("copyStaticFieldsMethodName", COPY_METHOD_NAME_STATIC); HashSet<ChangesTemplateModel> detectedChanges = new HashSet<ChangesTemplateModel>(); for (Entry<Clazz, ClassChange> change : this.changes.entrySet()) { if (change.getValue().getChangeSet().hasChange(ChangeType.NEW_CLASS)) { continue; } ChangesTemplateModel ctm = new ChangesTemplateModel( this.addPreffixToFQN(change.getValue().getOriginal()), this.addPreffixToFQN(change.getKey())); if (this.allClasses) { ctm.hasStaticChanges = true; ctm.hasNonStaticChanges = true; } for (Entry<Field, Change<Field>> fieldChange : change.getValue().getFieldChanges().entrySet()) { if (this.isHashCode(fieldChange)) { continue; } ChangeSet changeSet = fieldChange.getValue().getChangeSet(); if (changeSet.hasChange(ChangeType.NEW_FIELD)) { if (Modifier.isStatic(fieldChange.getKey().getAccess())) { ctm.hasStaticChanges = true; } else { ctm.hasNonStaticChanges = true; } ctm.newFields.add(new Pair<Field, Change<Field>>(fieldChange.getKey(), fieldChange.getValue())); } else if (changeSet.hasChange(ChangeType.NEW_CONSTANT)) { ctm.hasStaticChanges = true; ctm.newConstants .add(new Pair<Field, Change<Field>>(fieldChange.getKey(), fieldChange.getValue())); } else if (changeSet.hasChange(ChangeType.FIELD_TYPE_CHANGE)) { if (Modifier.isStatic(fieldChange.getKey().getAccess())) { ctm.hasStaticChanges = true; } else { ctm.hasNonStaticChanges = true; } ctm.typeChangedFields .add(new Pair<Field, Change<Field>>(fieldChange.getKey(), fieldChange.getValue())); } else { ctm.unmodifiedFields .add(new Pair<Field, Change<Field>>(fieldChange.getKey(), fieldChange.getValue())); } } if (ctm.hasNonStaticChanges || ctm.hasStaticChanges) { detectedChanges.add(ctm); } } templateModel.put("classes", detectedChanges); return templateModel; } private boolean isHashCode(Entry<Field, Change<Field>> fieldChange) { return fieldChange.getKey().getName().equals(AddHashCodeField.FIELD_NAME) || (fieldChange.getValue().getOriginal() != null && fieldChange.getValue().getOriginal().getName().equals(AddHashCodeField.FIELD_NAME)); } public String addPreffixToFQNIgnoreArrays(Clazz c) { if (c.isArray()) { c = c.getNamespace().getClass(c.getASMType().getElementType()); } String preffix = this.preffixes.get(c.getNamespace()); if (preffix != null) { return preffix + "." + c.getFqn(); } return c.getFqn(); } public String getNullValue(Clazz c) { if (c.getASMType().isPrimitive()) { return primitiveNullValues.get(c.getASMType()); } else { return "null"; } } private String addPreffixToFQN(Clazz c) { String preffix = this.preffixes.get(c.getNamespace()); if (preffix != null) { return preffix + "." + c.getFqn(); } return c.getFqn(); } public void generateConversionJar(File outJar) throws IOException { FileOutputStream fos = new FileOutputStream(outJar); JarOutputStream jos = new JarOutputStream(fos, new Manifest()); this.generateConversionClasses(jos, this.v0, this.preffixes.get(this.v1.getNamespace())); this.generateConversionClasses(jos, this.v1, ""); jos.close(); fos.close(); } private void generateConversionClasses(JarOutputStream jos, Version v, String newPreffix) throws IOException { ConversionClassGenerator ccg = new ConversionClassGenerator(v.getNamespace(), this.preffixes.get(v.getNamespace()), newPreffix); for (Clazz cl : v.getNamespace().getDefinedClasses()) { ccg.addConversionClassesToJar(jos, cl); } } public static class SortedChanges { } public static class ChangesTemplateModel { private final String v0, v1; private boolean hasStaticChanges = false; private boolean hasNonStaticChanges = false; public final Set<Pair<Field, Change<Field>>> unmodifiedFields = new HashSet<Pair<Field, Change<Field>>>(); public final Set<Pair<Field, Change<Field>>> newFields = new HashSet<Pair<Field, Change<Field>>>(); public final Set<Pair<Field, Change<Field>>> newConstants = new HashSet<Pair<Field, Change<Field>>>(); public final Set<Pair<Field, Change<Field>>> typeChangedFields = new HashSet<Pair<Field, Change<Field>>>(); public ChangesTemplateModel(String v0, String v1) { this.v0 = v0; this.v1 = v1; } public String getV0() { return this.v0; } public String getV1() { return this.v1; } public boolean isHasStaticChanges() { return this.hasStaticChanges; } public void setHasStaticChanges(boolean hasStaticChanges) { this.hasStaticChanges = hasStaticChanges; } public boolean isHasNonStaticChanges() { return this.hasNonStaticChanges; } public void setHasNonStaticChanges(boolean hasNonStaticChanges) { this.hasNonStaticChanges = hasNonStaticChanges; } public Set<Pair<Field, Change<Field>>> getUnmodifiedFields() { return this.unmodifiedFields; } public Set<Pair<Field, Change<Field>>> getNewFields() { return this.newFields; } public Set<Pair<Field, Change<Field>>> getNewConstants() { return this.newConstants; } public Set<Pair<Field, Change<Field>>> getTypeChangedFields() { return this.typeChangedFields; } } }