| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package org.apache.flex.abc; |
| |
| import org.apache.flex.abc.diagnostics.AbstractDiagnosticVisitor; |
| import org.apache.flex.abc.graph.IFlowgraph; |
| import org.apache.flex.abc.graph.IBasicBlock; |
| import org.apache.flex.abc.instructionlist.InstructionList; |
| import org.apache.flex.abc.optimize.DeadCodeFilter; |
| import org.apache.flex.abc.optimize.PeepholeOptimizerMethodBodyVisitor; |
| import org.apache.flex.abc.semantics.ClassInfo; |
| import org.apache.flex.abc.semantics.InstanceInfo; |
| import org.apache.flex.abc.semantics.Instruction; |
| import org.apache.flex.abc.semantics.Label; |
| import org.apache.flex.abc.semantics.Metadata; |
| import org.apache.flex.abc.semantics.MethodBodyInfo; |
| import org.apache.flex.abc.semantics.MethodInfo; |
| import org.apache.flex.abc.semantics.Name; |
| import org.apache.flex.abc.semantics.Namespace; |
| import org.apache.flex.abc.semantics.Nsset; |
| import org.apache.flex.abc.visitors.DelegatingClassVisitor; |
| import org.apache.flex.abc.visitors.DelegatingMetadataVisitor; |
| import org.apache.flex.abc.visitors.DelegatingMethodBodyVisitor; |
| import org.apache.flex.abc.visitors.DelegatingMethodVisitor; |
| import org.apache.flex.abc.visitors.DelegatingScriptVisitor; |
| import org.apache.flex.abc.visitors.DelegatingTraitVisitor; |
| import org.apache.flex.abc.visitors.DelegatingTraitsVisitor; |
| import org.apache.flex.abc.visitors.IABCVisitor; |
| import org.apache.flex.abc.visitors.IClassVisitor; |
| import org.apache.flex.abc.visitors.IDiagnosticsVisitor; |
| import org.apache.flex.abc.visitors.IMetadataVisitor; |
| import org.apache.flex.abc.visitors.IMethodBodyVisitor; |
| import org.apache.flex.abc.visitors.IMethodVisitor; |
| import org.apache.flex.abc.visitors.IScriptVisitor; |
| import org.apache.flex.abc.visitors.ITraitVisitor; |
| import org.apache.flex.abc.visitors.ITraitsVisitor; |
| import org.apache.flex.compiler.problems.ICompilerProblem; |
| import org.apache.flex.compiler.problems.UnreachableBlockProblem; |
| |
| import java.io.File; |
| import java.util.Collection; |
| |
| /** |
| * The ABCLinker links a sequence of ABC blocks into a single ABC block, |
| * and contains utility methods to perform various transformations on the ABC. |
| */ |
| public class ABCLinker |
| { |
| public static byte[] linkABC(Iterable<byte[]> inputABCs, int majorVersion, int minorVersion, ABCLinkerSettings settings) throws Exception |
| { |
| ABCEmitter emitter = new ABCEmitter(); |
| // ABCs from 4.5 may have non-sensical jumps past the end of a method |
| // so allow those, instead of throwin java exceptions |
| emitter.setAllowBadJumps(true); |
| emitter.visit(majorVersion, minorVersion); |
| for (byte[] inputABC : inputABCs) |
| { |
| ABCParser abcParser = new ABCParser(inputABC); |
| abcParser.parseABC(new LinkingVisitor(emitter, settings)); |
| } |
| emitter.visitEnd(); |
| return emitter.emit(); |
| } |
| |
| public static class ABCLinkerSettings |
| { |
| private boolean optimize = false; |
| private boolean enableInlining = false; |
| private boolean stripDebug = false; |
| private boolean stripFileAttributeFromGotoDefinitionHelp = false; |
| private boolean stripGotoDefinitionHelp = false; |
| private boolean removeDeadCode = false; |
| private Collection<String> meta_names = null; |
| @SuppressWarnings("unused") |
| private int minorVersion = ABCConstants.VERSION_ABC_MINOR_FP10; |
| @SuppressWarnings("unused") |
| private int majorVersion = ABCConstants.VERSION_ABC_MAJOR_FP10; |
| private Collection<ICompilerProblem> problems; |
| |
| /** |
| * Tell the linker whether it should run the peephole optimizer defaults |
| * to false |
| * |
| * @param b true if the ABCs should be optimized |
| */ |
| public void setOptimize(boolean b) |
| { |
| optimize = b; |
| } |
| |
| /** |
| * Tell the linker whether it should enable inlining of functions. |
| * defaults to false |
| * @param b true if the functions should be inlined |
| */ |
| public void setEnableInlining(boolean b) |
| { |
| enableInlining = b; |
| } |
| |
| /** |
| * Tell the linker whether is should strip out debug opcodes defaults to |
| * false |
| * |
| * @param b true if the ABCs should have the debug opcodes stripped out |
| */ |
| public void setStripDebugOpcodes(boolean b) |
| { |
| stripDebug = b; |
| } |
| |
| /** |
| * Tell the linker which metadata names it should keep. If null, it will |
| * keep them all except for "go to definition help" which is control by |
| * the stripGotoDefinitionHelp flag. Defaults to null. |
| * |
| * @param metadata_names A collection of metadata names that the linker |
| * will keep. |
| */ |
| public void setKeepMetadata(Collection<String> metadata_names) |
| { |
| meta_names = metadata_names; |
| } |
| |
| /** |
| * @return true if we should be stripping some metadata |
| */ |
| boolean shouldStripMetadata() |
| { |
| return meta_names != null || stripGotoDefinitionHelp || |
| stripFileAttributeFromGotoDefinitionHelp; |
| } |
| |
| public void setTargetABCVersion(int major, int minor) |
| { |
| this.majorVersion = major; |
| this.minorVersion = minor; |
| } |
| |
| /** |
| * If the metadata to keep is null, this flag determines if |
| * "go to definition help" metadata is removed. |
| * |
| * @param stripGotoDefinitionHelp <code>true</code> to strip the metadata, |
| * <code>false</code> to leave it. |
| */ |
| public void setStripGotoDefinitionHelp(boolean stripGotoDefinitionHelp) |
| { |
| this.stripGotoDefinitionHelp = stripGotoDefinitionHelp; |
| } |
| |
| /** |
| * If "go to definition help" meta is being kept, this flag determines |
| * if we should strip the file attribute from the metadata. |
| * |
| * @param stripFileAttributeFromGotoDefinitionHelp <code>true</code> to strip |
| * the file attribute, <code>false</code> to leave it. |
| */ |
| public void setStripFileAttributeFromGotoDefinitionHelp(boolean stripFileAttributeFromGotoDefinitionHelp) |
| { |
| this.stripFileAttributeFromGotoDefinitionHelp = stripFileAttributeFromGotoDefinitionHelp; |
| } |
| |
| /** |
| * Enable or disable the DeadCodeFilter optimization step. |
| * @param removeDeadCode true if the DeadCodeFilter should be run. |
| */ |
| public void setRemoveDeadCode(final boolean removeDeadCode) |
| { |
| this.removeDeadCode = removeDeadCode; |
| } |
| |
| /** |
| * Set a problems collection for errors or warnings during link. |
| * @param problems the problems collection to receive errors or warnings. |
| */ |
| public void setProblemsCollection(Collection<ICompilerProblem> problems) |
| { |
| this.problems = problems; |
| } |
| } |
| |
| /** |
| * IMethodBodyVisitor implementation that will strip out Debug opcodes |
| */ |
| private static final class DebugStrippingMethodBodyVisitor extends DelegatingMethodBodyVisitor |
| { |
| public DebugStrippingMethodBodyVisitor(IMethodBodyVisitor delegate) |
| { |
| super(delegate); |
| } |
| |
| // flag to keep track of if the last instruction was one we stripped out |
| // needed for figuring out where some labels land - see labelCurrent() |
| private boolean strippedLastInstruction; |
| |
| /** |
| * Determine if the opcode should be stripped out, or passed along to |
| * the next visitor. This also flags whether the opcode was stripped or |
| * not, so if you're calling this make sure you do what it tells you to |
| * |
| * @param opcode The instruction to check |
| * @return true if the instruction should be stripped out. |
| */ |
| private boolean stripInstruction(int opcode) |
| { |
| switch (opcode) |
| { |
| case ABCConstants.OP_debug: |
| case ABCConstants.OP_debugfile: |
| case ABCConstants.OP_debugline: |
| strippedLastInstruction = true; |
| break; |
| default: |
| strippedLastInstruction = false; |
| break; |
| } |
| return strippedLastInstruction; |
| } |
| |
| @Override |
| public void visitInstructionList(InstructionList new_list) |
| { |
| // for the delegates that run after this IVisitor, they will be processing |
| // a new copy of the instruction list, which will not have the debug opcodes |
| InstructionList strippedInstructionList = new InstructionList(new_list.size()); |
| for (Instruction inst : new_list.getInstructions()) |
| { |
| if (!stripInstruction(inst.getOpcode())) |
| strippedInstructionList.addInstruction(inst); |
| } |
| super.visitInstructionList(strippedInstructionList); |
| } |
| |
| @Override |
| public void visitInstruction(int opcode) |
| { |
| |
| if (stripInstruction(opcode)) |
| return; |
| super.visitInstruction(opcode); |
| } |
| |
| @Override |
| public void visitInstruction(int opcode, int immediate_operand) |
| { |
| if (stripInstruction(opcode)) |
| return; |
| |
| super.visitInstruction(opcode, immediate_operand); |
| } |
| |
| @Override |
| public void visitInstruction(int opcode, Object[] operands) |
| { |
| if (stripInstruction(opcode)) |
| return; |
| super.visitInstruction(opcode, operands); |
| } |
| |
| @Override |
| public void visitInstruction(int opcode, Object single_operand) |
| { |
| if (stripInstruction(opcode)) |
| return; |
| super.visitInstruction(opcode, single_operand); |
| } |
| |
| @Override |
| public void visitInstruction(Instruction instruction) |
| { |
| if (stripInstruction(instruction.getOpcode())) |
| return; |
| super.visitInstruction(instruction); |
| } |
| |
| @Override |
| public void labelCurrent(Label l) |
| { |
| // if we're trying to label a debug instruction that got stripped out |
| // then we really want to label the next instruction, and not whatever the |
| // last instruction happens to be. |
| // We only do this if the label may target a non-executable instruction - this |
| // is because we are stripping non executable instructions here - if the label must |
| // target an executable instruction, then the behavior of labelCurrent is correct - |
| // it would have walked back over the instructions until it found the first non-executable |
| // instruction. |
| if (strippedLastInstruction && !l.targetMustBeExecutable()) |
| super.labelNext(l); |
| else |
| super.labelCurrent(l); |
| } |
| } |
| |
| /** |
| * IMethodVisitor that will create a DebugStrippingMethodBodyVisitor - used |
| * when you want to remove debug opcodes from the method body. |
| */ |
| private static class DebugStrippingMethodVisitor extends DelegatingMethodVisitor |
| { |
| public DebugStrippingMethodVisitor(IMethodVisitor delegate) |
| { |
| super(delegate); |
| } |
| |
| @Override |
| public IMethodBodyVisitor visitBody(MethodBodyInfo mbi) |
| { |
| return new DebugStrippingMethodBodyVisitor(super.visitBody(mbi)); |
| } |
| } |
| |
| /** |
| * IMethodVisitor that will create an PeepholeOptimizerMethodBodyVisitor for |
| * the method body - used when you want to run the peephole optimizer for |
| * the method body |
| */ |
| private static class OptimizingMethodVisitor extends DelegatingMethodVisitor |
| { |
| public OptimizingMethodVisitor(IMethodVisitor delegate, Collection<ICompilerProblem> problems, final boolean removeDeadCode) |
| { |
| super(delegate); |
| this.problems = problems; |
| this.removeDeadCode = removeDeadCode; |
| } |
| |
| /** |
| * Sink for problems generated during this phase. |
| */ |
| final Collection<ICompilerProblem> problems; |
| |
| /** |
| * When true, run a DeadCodeFilter as part of the optimization pipeline. |
| */ |
| final boolean removeDeadCode; |
| |
| @Override |
| public IMethodBodyVisitor visitBody(MethodBodyInfo mbi) |
| { |
| // Set up the optimizer pipeline. |
| IMethodBodyVisitor delegate = super.visitBody(mbi); |
| |
| if ( removeDeadCode ) |
| { |
| IDiagnosticsVisitor diagnostics = new AbstractDiagnosticVisitor() |
| { |
| @Override |
| public void unreachableBlock(MethodBodyInfo methodBodyInfo, IFlowgraph cfg, IBasicBlock block) |
| { |
| if ( problems != null ) |
| { |
| String fileName = cfg.findSourcePath(block); |
| |
| if ( fileName != null && new File(fileName).isFile() ) |
| problems.add(new UnreachableBlockProblem(fileName, cfg.findLineNumber(block))); |
| } |
| } |
| }; |
| delegate = new DeadCodeFilter(mbi, delegate, diagnostics); |
| } |
| |
| return new PeepholeOptimizerMethodBodyVisitor(delegate); |
| } |
| } |
| |
| /** |
| * IScriptVisitor that will create a MetadataStrippingTraitsVisitor for the |
| * script traits |
| */ |
| private static class MetadataStrippingScriptVisitor extends DelegatingScriptVisitor |
| { |
| MetadataStrippingScriptVisitor(IScriptVisitor d, Collection<String> meta_names, |
| boolean stripGotoDefinitionHelp, |
| boolean stripFileAttribute) |
| { |
| super(d); |
| this.meta_names = meta_names; |
| this.stripGotoDefinitionHelp = stripGotoDefinitionHelp; |
| this.stripFileAttribute = stripFileAttribute; |
| } |
| |
| private Collection<String> meta_names; |
| private boolean stripGotoDefinitionHelp; |
| private boolean stripFileAttribute; |
| |
| @Override |
| public ITraitsVisitor visitTraits() |
| { |
| return new MetadataStrippingTraitsVisitor(super.visitTraits(), meta_names, |
| stripGotoDefinitionHelp, |
| stripFileAttribute); |
| } |
| |
| } |
| |
| /** |
| * IClassVisitor that will create a MetadataStrippingTraitsVisitor for the |
| * class and instance traits. |
| */ |
| private static class MetadataStrippingClassVisitor extends DelegatingClassVisitor |
| { |
| MetadataStrippingClassVisitor(IClassVisitor d, Collection<String> meta_names, |
| boolean stripGotoDefinitionHelp, |
| boolean stripFileAttribute) |
| { |
| super(d); |
| this.meta_names = meta_names; |
| this.stripGotoDefinitionHelp = stripGotoDefinitionHelp; |
| this.stripFileAttribute = stripFileAttribute; |
| } |
| |
| private Collection<String> meta_names; |
| private boolean stripGotoDefinitionHelp; |
| private boolean stripFileAttribute; |
| |
| @Override |
| public ITraitsVisitor visitClassTraits() |
| { |
| return new MetadataStrippingTraitsVisitor(super.visitClassTraits(), meta_names, |
| stripGotoDefinitionHelp, |
| stripFileAttribute); |
| } |
| |
| @Override |
| public ITraitsVisitor visitInstanceTraits() |
| { |
| return new MetadataStrippingTraitsVisitor(super.visitInstanceTraits(), meta_names, |
| stripGotoDefinitionHelp, |
| stripFileAttribute); |
| } |
| } |
| |
| /** |
| * ITraitVisitor that will create a metadata visitor that will strip out some |
| * metadata. |
| */ |
| private static class MetadataStrippingTraitVisitor extends DelegatingTraitVisitor |
| { |
| MetadataStrippingTraitVisitor(ITraitVisitor d, Collection<String> meta_names, |
| boolean stripGotoDefinitionHelp, |
| boolean stripFileAttribute) |
| { |
| super(d); |
| this.meta_names = meta_names; |
| this.stripGotoDefinitionHelp = stripGotoDefinitionHelp; |
| this.stripFileAttribute = stripFileAttribute; |
| } |
| |
| private Collection<String> meta_names; |
| private boolean stripGotoDefinitionHelp; |
| private boolean stripFileAttribute; |
| |
| @Override |
| public IMetadataVisitor visitMetadata(int count) |
| { |
| return new MetadataStrippingVisitor(super.visitMetadata(count), meta_names, |
| stripGotoDefinitionHelp, |
| stripFileAttribute); |
| } |
| } |
| |
| /** |
| * IMetadataVisitor that will only emit certain metadata, and will strip out |
| * the rest of the metadata. If no metadata is supposed to be stripped, then |
| * you shouldn't create one of these |
| */ |
| private static class MetadataStrippingVisitor extends DelegatingMetadataVisitor |
| { |
| |
| /** |
| * Constants for removing the __go_to_definition_help and __go_to_definition_ctor |
| * help that get injected for go to definition support |
| */ |
| private static final String GO_TO_DEFINITION_HELP = "__go_to_definition_help"; |
| private static final String GO_TO_DEFINITION_CTOR_HELP = "__go_to_ctor_definition_help"; |
| private static final String GO_TO_DEFINITION_HELP_FILE = "file"; |
| |
| /** |
| * If the meta tag is "__go_to_ctor_definition_help" or |
| * "__go_to_definition_help", strip off the "file" attribute. |
| * |
| * @param metadata The data to strip the "file" attribute from. |
| */ |
| static Metadata stripFileAttributeFromGotoDefinitionHelp(Metadata metadata) |
| { |
| String name = metadata.getName(); |
| if (GO_TO_DEFINITION_HELP.equals(name) || |
| GO_TO_DEFINITION_CTOR_HELP.equals(name)) |
| { |
| metadata = removeKey(metadata, GO_TO_DEFINITION_HELP_FILE); |
| } |
| |
| return metadata; |
| } |
| |
| /** |
| * Remove a key from this metadata. |
| * |
| * @param key The key to remove. May not be null. |
| */ |
| static Metadata removeKey(Metadata metadata, String key) |
| { |
| assert metadata != null; |
| assert key != null; |
| |
| String[] keys = metadata.getKeys(); |
| for (int i = 0; i < keys.length; i++) |
| { |
| if (key.equals(keys[i])) |
| { |
| String[] values = metadata.getValues(); |
| String[] newKeys = new String[keys.length - 1]; |
| String[] newValues = new String[keys.length - 1]; |
| |
| // Copy attributes up to found attribute. |
| if (i > 0) |
| { |
| System.arraycopy(keys, 0, newKeys, 0, i); |
| System.arraycopy(values, 0, newValues, 0, i); |
| |
| } |
| |
| // Copy attributes after the found attribute. |
| if (i < (keys.length - 1)) |
| { |
| System.arraycopy(keys, i + 1, newKeys, i, |
| keys.length - i - 1); |
| System.arraycopy(values, i + 1, newValues, i, |
| keys.length - i - 1); |
| } |
| |
| metadata = new Metadata(metadata.getName(), newKeys, newValues); |
| break; |
| } |
| } |
| |
| return metadata; |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param d the delegate visitor to wrap |
| * @param meta_names the names of the metadata which should be emitted. |
| * If null, all the names are emitted except for "go to definition help" |
| * metadata which is controlled by the stripGotoDefinitionHelp parameter |
| * and stripFileAttribute parameter. |
| * @param stripGotoDefinitionHelp true if "go to definition help" |
| * metadata should be stripped out, false otherwise. |
| * @param stripFileAttribute true if the "file" attribute of the goto |
| * definition metadata should be stripped. |
| */ |
| MetadataStrippingVisitor(IMetadataVisitor d, Collection<String> meta_names, |
| boolean stripGotoDefinitionHelp, |
| boolean stripFileAttribute) |
| { |
| super(d); |
| this.metaNames = meta_names; |
| this.stripGotoDefinitionHelp = stripGotoDefinitionHelp; |
| this.stripFileAttribute = stripFileAttribute; |
| } |
| |
| private Collection<String> metaNames; |
| private boolean stripGotoDefinitionHelp; |
| private boolean stripFileAttribute; |
| |
| @Override |
| public void visit(Metadata md) |
| { |
| if (shouldKeep(md)) |
| { |
| if (!stripGotoDefinitionHelp && stripFileAttribute) |
| md = stripFileAttributeFromGotoDefinitionHelp(md); |
| super.visit(md); |
| } |
| return; |
| } |
| |
| boolean shouldKeep(Metadata md) |
| { |
| if (metaNames == null) |
| { |
| if (GO_TO_DEFINITION_HELP.equals(md.getName()) || |
| GO_TO_DEFINITION_CTOR_HELP.equals(md.getName())) |
| { |
| return !stripGotoDefinitionHelp; |
| } |
| |
| return true; |
| } |
| return metaNames.contains(md.getName()); |
| } |
| } |
| |
| /** |
| * ITraitsVisitor that will wrap any generated ITraitVisitor in a |
| * MetadataStrippingTraitVisitor |
| */ |
| private static class MetadataStrippingTraitsVisitor extends DelegatingTraitsVisitor |
| { |
| MetadataStrippingTraitsVisitor(ITraitsVisitor d, Collection<String> meta_names, |
| boolean stripGotoDefinitionHelp, |
| boolean stripFileAttribute) |
| { |
| super(d); |
| this.meta_names = meta_names; |
| this.stripGotoDefinitionHelp = stripGotoDefinitionHelp; |
| this.stripFileAttribute = stripFileAttribute; |
| } |
| |
| private Collection<String> meta_names; |
| private boolean stripGotoDefinitionHelp; |
| private boolean stripFileAttribute; |
| |
| @Override |
| public ITraitVisitor visitSlotTrait(int kind, Name name, int slot_id, Name slot_type, Object slot_value) |
| { |
| return new MetadataStrippingTraitVisitor( |
| super.visitSlotTrait(kind, name, slot_id, slot_type, slot_value), |
| meta_names, |
| stripGotoDefinitionHelp, |
| stripFileAttribute); |
| } |
| |
| @Override |
| public ITraitVisitor visitClassTrait(int kind, Name name, int slot_id, ClassInfo clazz) |
| { |
| return new MetadataStrippingTraitVisitor( |
| super.visitClassTrait(kind, name, slot_id, clazz), |
| meta_names, |
| stripGotoDefinitionHelp, |
| stripFileAttribute); |
| } |
| |
| @Override |
| public ITraitVisitor visitMethodTrait(int kind, Name name, int disp_id, MethodInfo method) |
| { |
| return new MetadataStrippingTraitVisitor( |
| super.visitMethodTrait(kind, name, disp_id, method), |
| meta_names, |
| stripGotoDefinitionHelp, |
| stripFileAttribute); |
| } |
| } |
| |
| /** |
| * IABCVisitor implementation to do various transformations on an ABC file - |
| * stripping debug opcodes, optimizing, etc. |
| */ |
| private static class LinkingVisitor implements IABCVisitor |
| { |
| public LinkingVisitor(ABCEmitter delegate, ABCLinkerSettings linkSettings) |
| { |
| this.delegate = delegate; |
| this.settings = linkSettings; |
| } |
| |
| private final ABCEmitter delegate; |
| private final ABCLinkerSettings settings; |
| |
| @Override |
| public void visit(int major_version, int minor_version) |
| { |
| // Don't call into the delegate, the linker has done that! |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| // Do nothing... This will be called once by the linker on the |
| // delegate. |
| } |
| |
| @Override |
| public IScriptVisitor visitScript() |
| { |
| IScriptVisitor sv = delegate.visitScript(); |
| if (settings.shouldStripMetadata()) |
| sv = new MetadataStrippingScriptVisitor(sv, settings.meta_names, |
| settings.stripGotoDefinitionHelp, |
| settings.stripFileAttributeFromGotoDefinitionHelp); |
| return sv; |
| } |
| |
| @Override |
| public IClassVisitor visitClass(InstanceInfo iinfo, ClassInfo cinfo) |
| { |
| IClassVisitor cv = delegate.visitClass(iinfo, cinfo); |
| if (settings.shouldStripMetadata()) |
| cv = new MetadataStrippingClassVisitor(cv, settings.meta_names, |
| settings.stripGotoDefinitionHelp, |
| settings.stripFileAttributeFromGotoDefinitionHelp); |
| return cv; |
| } |
| |
| @Override |
| public IMethodVisitor visitMethod(MethodInfo minfo) |
| { |
| IMethodVisitor mv = delegate.visitMethod(minfo); |
| if (settings.optimize) |
| mv = new OptimizingMethodVisitor(mv, settings.problems, settings.removeDeadCode); |
| |
| // Run the debug stripping visitor first, so the debug |
| // instructions won't confuse the peephole optimizer |
| // building a chain of visitors, so the debug stripping will |
| // wrap the optimizing visitor |
| if (settings.stripDebug) |
| mv = new DebugStrippingMethodVisitor(mv); |
| |
| return mv; |
| } |
| |
| @Override |
| public void visitPooledInt(Integer i) |
| { |
| // emitter automatically pools values. |
| } |
| |
| @Override |
| public void visitPooledUInt(Long l) |
| { |
| // emitter automatically pools values. |
| } |
| |
| @Override |
| public void visitPooledDouble(Double d) |
| { |
| // emitter automatically pools values. |
| } |
| |
| @Override |
| public void visitPooledString(String s) |
| { |
| // emitter automatically pools values. |
| } |
| |
| @Override |
| public void visitPooledNamespace(Namespace ns) |
| { |
| if (settings.enableInlining) |
| ns.setMergePrivateNamespaces(true); |
| } |
| |
| @Override |
| public void visitPooledNsSet(Nsset nss) |
| { |
| // emitter automatically pools values. |
| } |
| |
| @Override |
| public void visitPooledName(Name n) |
| { |
| // emitter automatically pools values. |
| } |
| |
| @Override |
| public void visitPooledMetadata(Metadata md) |
| { |
| // emitter automatically pools values. |
| } |
| } |
| } |
