public static void main(String[] args) { List<String> classes = Arrays.asList(JTranscReflection.getAllClasses()); System.out.println(classes.size() >= 2); System.out.println(classes.contains(JTranscSystemTest.class.getName())); System.out.println(classes.contains("com.donot.exists")); IntMap<Simple> intMap = IntMap.Utils.create(); intMap.set(0, Simple.Utils.create()); intMap.set(1, Simple.Utils.create()); System.out.println(intMap.exists(0)); System.out.println(intMap.has(1)); System.out.println(intMap.exists(2)); intMap.remove(1); System.out.println(intMap.has(1)); intMap.get(0).flush(); }
@Override public PersistentMap<Long, V> include(Long key, V value) { IntMap<MapEntry<Long, V>> im = getInner(key); MapEntry<Long, V> entry = new MapEntry<Long, V>(key, value); long newCount = count; int lo = Bits.lowWord(key); if (im == null) { im = IntMap.create(lo, entry); newCount += 1; } else { if (!im.containsKey(lo)) newCount++; im = im.include(lo, entry); } IntMap<IntMap<MapEntry<Long, V>>> newData = data.include(Bits.highWord(key), im); if (data == newData) return this; return new LongMap<V>(newData, newCount); }
/** * Analyzes the given method. * * @param c the class to which the method belongs. * @param m the method to be analyzed. * @return the symbolic state of the execution stack frame at each bytecode instruction of the * method. The size of the returned array is equal to the number of instructions (and labels) * of the method. A given frame is <tt>null</tt> if and only if the corresponding instruction * cannot be reached (dead code). * @throws AnalyzerException if a problem occurs during the analysis. */ public Frame[] analyze(final ClassNode c, final MethodNode m) throws AnalyzerException { n = m.instructions.size(); indexes = new IntMap(2 * n); handlers = new List[n]; frames = new Frame[n]; subroutines = new Subroutine[n]; queued = new boolean[n]; queue = new int[n]; top = 0; // computes instruction indexes for (int i = 0; i < n; ++i) { indexes.put(m.instructions.get(i), i); } // computes exception handlers for each instruction for (int i = 0; i < m.tryCatchBlocks.size(); ++i) { TryCatchBlockNode tcb = (TryCatchBlockNode) m.tryCatchBlocks.get(i); int begin = indexes.get(tcb.start); int end = indexes.get(tcb.end); for (int j = begin; j < end; ++j) { List insnHandlers = handlers[j]; if (insnHandlers == null) { insnHandlers = new ArrayList(); handlers[j] = insnHandlers; } insnHandlers.add(tcb); } } // initializes the data structures for the control flow analysis algorithm Frame current = newFrame(m.maxLocals, m.maxStack); Frame handler = newFrame(m.maxLocals, m.maxStack); Type[] args = Type.getArgumentTypes(m.desc); int local = 0; if ((m.access & ACC_STATIC) == 0) { Type ctype = Type.getType("L" + c.name + ";"); current.setLocal(local++, interpreter.newValue(ctype)); } for (int i = 0; i < args.length; ++i) { current.setLocal(local++, interpreter.newValue(args[i])); if (args[i].getSize() == 2) { current.setLocal(local++, interpreter.newValue(null)); } } while (local < m.maxLocals) { current.setLocal(local++, interpreter.newValue(null)); } merge(0, current, null); // control flow analysis while (top > 0) { int insn = queue[--top]; Frame f = frames[insn]; Subroutine subroutine = subroutines[insn]; queued[insn] = false; try { Object o = m.instructions.get(insn); jsr = false; if (o instanceof Label) { merge(insn + 1, f, subroutine); } else { AbstractInsnNode insnNode = (AbstractInsnNode) o; int insnOpcode = insnNode.getOpcode(); current.init(f).execute(insnNode, interpreter); subroutine = subroutine == null ? null : subroutine.copy(); if (insnNode instanceof JumpInsnNode) { JumpInsnNode j = (JumpInsnNode) insnNode; if (insnOpcode != GOTO && insnOpcode != JSR) { merge(insn + 1, current, subroutine); } if (insnOpcode == JSR) { jsr = true; merge(indexes.get(j.label), current, new Subroutine(j.label, m.maxLocals, j)); } else { merge(indexes.get(j.label), current, subroutine); } } else if (insnNode instanceof LookupSwitchInsnNode) { LookupSwitchInsnNode lsi = (LookupSwitchInsnNode) insnNode; merge(indexes.get(lsi.dflt), current, subroutine); for (int j = 0; j < lsi.labels.size(); ++j) { Label label = (Label) lsi.labels.get(j); merge(indexes.get(label), current, subroutine); } } else if (insnNode instanceof TableSwitchInsnNode) { TableSwitchInsnNode tsi = (TableSwitchInsnNode) insnNode; merge(indexes.get(tsi.dflt), current, subroutine); for (int j = 0; j < tsi.labels.size(); ++j) { Label label = (Label) tsi.labels.get(j); merge(indexes.get(label), current, subroutine); } } else if (insnOpcode == RET) { if (subroutine == null) { throw new AnalyzerException("RET instruction outside of a sub routine"); } else { for (int i = 0; i < subroutine.callers.size(); ++i) { int caller = indexes.get(subroutine.callers.get(i)); merge(caller + 1, frames[caller], current, subroutines[caller], subroutine.access); } } } else if (insnOpcode != ATHROW && (insnOpcode < IRETURN || insnOpcode > RETURN)) { if (subroutine != null) { if (insnNode instanceof VarInsnNode) { int var = ((VarInsnNode) insnNode).var; subroutine.access[var] = true; if (insnOpcode == LLOAD || insnOpcode == DLOAD || insnOpcode == LSTORE || insnOpcode == DSTORE) { subroutine.access[var + 1] = true; } } else if (insnNode instanceof IincInsnNode) { int var = ((IincInsnNode) insnNode).var; subroutine.access[var] = true; } } merge(insn + 1, current, subroutine); } } List insnHandlers = handlers[insn]; if (insnHandlers != null) { for (int i = 0; i < insnHandlers.size(); ++i) { TryCatchBlockNode tcb = (TryCatchBlockNode) insnHandlers.get(i); Type type; if (tcb.type == null) { type = Type.getType("Ljava/lang/Throwable;"); } else { type = Type.getType("L" + tcb.type + ";"); } handler.init(f); handler.clearStack(); handler.push(interpreter.newValue(type)); merge(indexes.get(tcb.handler), handler, subroutine); } } } catch (Exception e) { throw new AnalyzerException("Error at instruction " + insn + ": " + e.getMessage()); } } return frames; }
/** * Returns the index of the given instruction. * * @param insn a {@link Label} or {@link AbstractInsnNode} of the last recently analyzed method. * @return the index of the given instruction of the last recently analyzed method. */ public int getIndex(final Object insn) { return indexes.get(insn); }