/* * This file is part of Sponge, licensed under the MIT License (MIT). * * Copyright (c) SpongePowered.org * Copyright (c) contributors * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ package org.spongepowered.tools.obfuscation; import java.io.File; import java.io.IOException; import java.io.PrintWriter; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; import javax.annotation.processing.Filer; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.ExecutableElement; import javax.lang.model.element.TypeElement; import javax.lang.model.element.VariableElement; import javax.tools.Diagnostic; import javax.tools.Diagnostic.Kind; import javax.tools.FileObject; import javax.tools.StandardLocation; import org.spongepowered.asm.mixin.injection.struct.ReferenceMapper; import org.spongepowered.tools.MirrorUtils; import net.minecraftforge.srg2source.rangeapplier.MethodData; import net.minecraftforge.srg2source.rangeapplier.SrgContainer; /** * Mixin info manager, stores all of the mixin info during processing and also manages access to the srgs */ class AnnotatedMixins { /** * Singleton instances for each ProcessingEnvironment */ private static Map instances = new HashMap(); /** * Local processing environment */ private final ProcessingEnvironment processingEnv; /** * Mixins during processing phase */ private final Map mixins = new HashMap(); /** * Name of the resource to write generated srgs to */ private final String outSrgFileName; /** * File containing the reobfd srgs */ private final File reobfSrgFile; /** * Reference mapper for reference mapping */ private final ReferenceMapper refMapper = new ReferenceMapper(); /** * SRG container for mcp->srg mappings */ private SrgContainer srgs; /** * True once we've tried to initialise the srgs, initially false so that we can do srg init lazily */ private boolean initDone; /** * Private constructor, get instances using {@link #getMixinsForEnvironment} */ private AnnotatedMixins(ProcessingEnvironment processingEnv) { String outSrgFileName = processingEnv.getOptions().get("outSrgFile"); this.outSrgFileName = (outSrgFileName != null) ? outSrgFileName : "mixins.srg"; String reobfSrgFileName = processingEnv.getOptions().get("reobfSrgFile"); if (reobfSrgFileName == null) { processingEnv.getMessager().printMessage(Kind.ERROR, "The reobfSrgFile argument was not supplied, processing cannot continue"); } this.processingEnv = processingEnv; this.reobfSrgFile = new File(reobfSrgFileName); } /** * Lazy initialisation for srgs, so that we only initialise the srgs if they're actually required. */ private boolean initSrgs() { if (!this.initDone) { this.initDone = true; try { this.processingEnv.getMessager().printMessage(Kind.NOTE, "Loading SRGs from " + this.reobfSrgFile.getAbsolutePath()); this.srgs = new SrgContainer().readSrg(this.reobfSrgFile); } catch (Exception ex) { ex.printStackTrace(); this.processingEnv.getMessager().printMessage(Kind.ERROR, "The specified SRG file could not be read, processing cannot continue"); this.srgs = null; } } return this.srgs != null; } /** * Write out generated srgs */ public void writeSrgs() { Set fieldMappings = new LinkedHashSet(); Set methodMappings = new LinkedHashSet(); for (AnnotatedMixin mixin : this.mixins.values()) { fieldMappings.addAll(mixin.getFieldMappings()); methodMappings.addAll(mixin.getMethodMappings()); } PrintWriter writer = null; try { writer = this.openSrgFileWriter(); for (String fieldMapping : fieldMappings) { writer.println(fieldMapping); } for (String methodMapping : methodMappings) { writer.println(methodMapping); } } catch (IOException ex) { ex.printStackTrace(); } finally { if (writer != null) { try { writer.close(); } catch (Exception ex) { // oh well } } } } /** * Open a writer for the output SRG file */ private PrintWriter openSrgFileWriter() throws IOException { if (this.outSrgFileName.matches("^.*[\\\\/:].*$")) { File outSrgFile = new File(this.outSrgFileName); outSrgFile.getParentFile().mkdirs(); this.processingEnv.getMessager().printMessage(Kind.NOTE, "Writing output SRGs to " + outSrgFile.getAbsolutePath()); return new PrintWriter(outSrgFile); } Filer filer = this.processingEnv.getFiler(); FileObject outSrg = filer.createResource(StandardLocation.CLASS_OUTPUT, "", this.outSrgFileName); this.processingEnv.getMessager().printMessage(Kind.NOTE, "Writing output SRGs to " + new File(outSrg.toUri()).getAbsolutePath()); return new PrintWriter(outSrg.openWriter()); } /** * Write out stored mappings */ public void writeRefs() { PrintWriter writer = null; try { Filer filer = this.processingEnv.getFiler(); FileObject outSrg = filer.createResource(StandardLocation.CLASS_OUTPUT, "", ReferenceMapper.DEFAULT_RESOURCE); writer = new PrintWriter(outSrg.openWriter()); this.refMapper.write(writer); } catch (IOException ex) { ex.printStackTrace(); } finally { if (writer != null) { try { writer.close(); } catch (Exception ex) { // oh well } } } } /** * Get the reference mapper */ public ReferenceMapper getReferenceMapper() { return this.refMapper; } /** * Clear all registered mixins */ public void clear() { this.mixins.clear(); } /** * Register a new mixin class */ public void registerMixin(TypeElement mixinType) { String name = mixinType.getQualifiedName().toString(); if (!this.mixins.containsKey(name)) { this.mixins.put(name, new AnnotatedMixin(this, mixinType)); } } /** * Get a registered mixin */ public AnnotatedMixin getMixin(TypeElement mixinType) { return this.getMixin(mixinType.getQualifiedName().toString()); } /** * Get a registered mixin */ public AnnotatedMixin getMixin(String mixinType) { return this.mixins.get(mixinType); } /** * Register an {@link org.spongepowered.asm.mixin.Overwrite} method * * @param mixinType Mixin class * @param method Overwrite method */ public void registerOverwrite(TypeElement mixinType, ExecutableElement method) { AnnotatedMixin mixinClass = this.getMixin(mixinType); if (mixinClass == null) { this.processingEnv.getMessager().printMessage(Kind.ERROR, "Found @Overwrite annotation on a non-mixin method " + method + " in " + mixinType); return; } if (mixinClass.remap()) { mixinClass.registerOverwrite(method); } } /** * Register a {@link org.spongepowered.asm.mixin.Shadow} field * * @param mixinType Mixin class * @param method Shadow field * @param shadow {@link org.spongepowered.asm.mixin.Shadow} annotation */ public void registerShadow(TypeElement mixinType, VariableElement field, AnnotationMirror shadow) { AnnotatedMixin mixinClass = this.getMixin(mixinType); if (mixinClass == null) { this.processingEnv.getMessager().printMessage(Kind.ERROR, "Found @Shadow annotation on a non-mixin field " + field + " in " + mixinType); return; } if (this.shouldRemap(mixinClass, shadow)) { mixinClass.registerShadow(field, shadow); } } /** * Register a {@link org.spongepowered.asm.mixin.Shadow} method * * @param mixinType Mixin class * @param method Shadow method * @param shadow {@link org.spongepowered.asm.mixin.Shadow} annotation */ public void registerShadow(TypeElement mixinType, ExecutableElement method, AnnotationMirror shadow) { AnnotatedMixin mixinClass = this.getMixin(mixinType); if (mixinClass == null) { this.processingEnv.getMessager().printMessage(Kind.ERROR, "Found @Shadow annotation on a non-mixin method " + method + " in " + mixinType); return; } if (this.shouldRemap(mixinClass, shadow)) { mixinClass.registerShadow(method, shadow); } } /** * Register a {@link org.spongepowered.asm.mixin.injection.Inject} method * * @param mixinType Mixin class * @param method Injector method * @param inject {@link org.spongepowered.asm.mixin.injection.Inject} annotation */ public void registerInjector(TypeElement mixinType, ExecutableElement method, AnnotationMirror inject) { AnnotatedMixin mixinClass = this.getMixin(mixinType); if (mixinClass == null) { this.processingEnv.getMessager().printMessage(Kind.ERROR, "Found @Inject annotation on a non-mixin method " + method + " in " + mixinType); return; } if (this.shouldRemap(mixinClass, inject)) { mixinClass.registerInjector(method, inject); Object ats = MirrorUtils.getAnnotationValue(inject, "at"); if (ats instanceof List) { @SuppressWarnings("unchecked") List annotationValue = (List)ats; for (AnnotationMirror at : annotationValue) { mixinClass.registerInjectionPoint(at); } } else if (ats instanceof AnnotationMirror) { mixinClass.registerInjectionPoint((AnnotationMirror)ats); } } } private boolean shouldRemap(AnnotatedMixin mixinClass, AnnotationMirror annotation) { return mixinClass.remap() && AnnotatedMixins.getRemapValue(annotation); } /** * Check whether we should remap the annotated member or skip it */ public static boolean getRemapValue(AnnotationMirror annotation) { return MirrorUtils.getAnnotationValue(annotation, "remap", Boolean.TRUE).booleanValue(); } /** * Print a message to the AP messager */ public void printMessage(Diagnostic.Kind kind, CharSequence msg) { this.processingEnv.getMessager().printMessage(kind, msg); } /** * Get an obfuscation mapping for a method */ public MethodData getObfMethod(MethodData method) { if (this.initSrgs()) { return this.srgs.methodMap.get(method); } return null; } /** * Get an obfuscation mapping for a field */ public String getObfField(String field) { if (this.initSrgs()) { return this.srgs.fieldMap.get(field); } return null; } /** * Get the mixin manager instance for this environment */ public static AnnotatedMixins getMixinsForEnvironment(ProcessingEnvironment processingEnv) { AnnotatedMixins mixins = AnnotatedMixins.instances.get(processingEnv); if (mixins == null) { mixins = new AnnotatedMixins(processingEnv); AnnotatedMixins.instances.put(processingEnv, mixins); } return mixins; } }