Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
39,700 | void (int diff) { this.pointer += diff; } | addToPointer |
39,701 | String () { return toString(0); } | toString |
39,702 | String (int indent) { String new_line_separator = DecompilerContext.getNewLineSeparator(); StringBuilder buf = new StringBuilder(); for (int i = 0; i < collinstr.size(); i++) { buf.append(TextUtil.getIndentString(indent)); buf.append(collinstr.getKey(i).intValue()); buf.append(": "); buf.append(collinstr.get(i).toStrin... | toString |
39,703 | int () { return pointer; } | getPointer |
39,704 | void (int pointer) { this.pointer = pointer; } | setPointer |
39,705 | ExceptionTable () { return exceptionTable; } | getExceptionTable |
39,706 | void (InstructionSequence seq) { defaultDestination = seq.getPointerByRelOffset(operands[0]); int prefix = opcode == CodeConstants.opc_tableswitch ? 3 : 2; int len = operands.length - prefix; int low = 0; if (opcode == CodeConstants.opc_lookupswitch) { len /= 2; } else { low = operands[1]; } destinations = new int[len]... | initInstruction |
39,707 | int[] () { return destinations; } | getDestinations |
39,708 | int[] () { return values; } | getValues |
39,709 | int () { return defaultDestination; } | getDefaultDestination |
39,710 | SwitchInstruction () { SwitchInstruction copy = (SwitchInstruction)super.clone(); copy.defaultDestination = defaultDestination; copy.destinations = destinations.clone(); copy.values = values.clone(); return copy; } | clone |
39,711 | List<ExceptionHandler> () { return handlers; } | getHandlers |
39,712 | Instruction (int opcode, boolean wide, int group, int bytecodeVersion, int[] operands) { if (opcode >= opc_ifeq && opcode <= opc_if_acmpne || opcode == opc_ifnull || opcode == opc_ifnonnull || opcode == opc_jsr || opcode == opc_jsr_w || opcode == opc_goto || opcode == opc_goto_w) { return new JumpInstruction(opcode, gr... | create |
39,713 | boolean (Instruction i1, Instruction i2) { return i1 != null && i2 != null && (i1 == i2 || i1.opcode == i2.opcode && i1.wide == i2.wide && i1.operandsCount() == i2.operandsCount()); } | equals |
39,714 | void (InstructionSequence seq) { } | initInstruction |
39,715 | int () { return operands == null ? 0 : operands.length; } | operandsCount |
39,716 | int (int index) { return operands[index]; } | operand |
39,717 | boolean () { return opcode != opc_goto && opcode != opc_goto_w && opcode != opc_ret && !(opcode >= opc_ireturn && opcode <= opc_return) && opcode != opc_athrow && opcode != opc_jsr && opcode != opc_tableswitch && opcode != opc_lookupswitch; } | canFallThrough |
39,718 | String () { StringBuilder res = new StringBuilder(); if (wide) res.append("@wide "); res.append("@").append(TextUtil.getInstructionName(opcode)); int len = operandsCount(); for (int i = 0; i < len; i++) { int op = operands[i]; if (op < 0) { res.append(" -").append(Integer.toHexString(-op)); } else { res.append(" ").app... | toString |
39,719 | Instruction () { return create(opcode, wide, group, bytecodeVersion, operands == null ? null : operands.clone()); } | clone |
39,720 | void (InstructionSequence seq) { destination = seq.getPointerByRelOffset(this.operand(0)); } | initInstruction |
39,721 | JumpInstruction () { JumpInstruction copy = (JumpInstruction)super.clone(); copy.destination = destination; return copy; } | clone |
39,722 | String () { String new_line_separator = DecompilerContext.getNewLineSeparator(); return "from: " + from + " to: " + to + " handler: " + handler + new_line_separator + "from_instr: " + from_instr + " to_instr: " + to_instr + " handler_instr: " + handler_instr + new_line_separator + "exceptionClass: " + exceptionClass + ... | toString |
39,723 | void (DataPoint data, Instruction instr, ConstantPool pool) { ListStack<VarType> stack = data.getStack(); int[][] arr = stack_impact[instr.opcode]; if (arr != null) { // simple types only int[] read = arr[0]; int[] write = arr[1]; if (read != null) { int depth = 0; for (int type : read) { depth++; if (type == CodeConst... | stepTypes |
39,724 | void (DataPoint data, Instruction instr, ConstantPool pool) { VarType var1; PrimitiveConstant cn; LinkConstant ck; ListStack<VarType> stack = data.getStack(); switch (instr.opcode) { case CodeConstants.opc_aconst_null: stack.push(new VarType(CodeConstants.TYPE_NULL, 0, null)); break; case CodeConstants.opc_ldc: case Co... | processSpecialInstructions |
39,725 | BasicBlock (int newId) { BasicBlock block = new BasicBlock(newId, seq.clone()); block.originalOffsets.addAll(originalOffsets); return block; } | clone |
39,726 | Instruction (int index) { return seq.getInstr(index); } | getInstruction |
39,727 | Instruction () { return seq.isEmpty() ? null : seq.getLastInstr(); } | getLastInstruction |
39,728 | Integer (int index) { return index < originalOffsets.size() ? originalOffsets.get(index) : Integer.valueOf(-1); } | getOriginalOffset |
39,729 | int () { return seq.length(); } | size |
39,730 | void (BasicBlock block) { predecessors.add(block); } | addPredecessor |
39,731 | void (BasicBlock block) { while (predecessors.remove(block)) /**/; } | removePredecessor |
39,732 | void (BasicBlock block) { successors.add(block); block.addPredecessor(this); } | addSuccessor |
39,733 | void (BasicBlock block) { while (successors.remove(block)) /**/; block.removePredecessor(this); } | removeSuccessor |
39,734 | void (BasicBlock oldBlock, BasicBlock newBlock) { for (int i = 0; i < successors.size(); i++) { if (successors.get(i).id == oldBlock.id) { successors.set(i, newBlock); oldBlock.removePredecessor(this); newBlock.addPredecessor(this); } } for (int i = 0; i < successorExceptions.size(); i++) { if (successorExceptions.get(... | replaceSuccessor |
39,735 | void (BasicBlock block) { predecessorExceptions.add(block); } | addPredecessorException |
39,736 | void (BasicBlock block) { while (predecessorExceptions.remove(block)) /**/; } | removePredecessorException |
39,737 | void (BasicBlock block) { if (!successorExceptions.contains(block)) { successorExceptions.add(block); block.addPredecessorException(this); } } | addSuccessorException |
39,738 | void (BasicBlock block) { while (successorExceptions.remove(block)) /**/; block.removePredecessorException(this); } | removeSuccessorException |
39,739 | boolean (BasicBlock block) { return successors.stream().anyMatch(successor -> successor.id == block.id); } | isSuccessor |
39,740 | List<Integer> () { return originalOffsets; } | getOriginalOffsets |
39,741 | InstructionSequence () { return seq; } | getSeq |
39,742 | List<BasicBlock> () { return predecessors; } | getPredecessors |
39,743 | List<BasicBlock> () { return successors; } | getSuccessors |
39,744 | List<BasicBlock> () { return predecessorExceptions; } | getPredecessorExceptions |
39,745 | List<BasicBlock> () { return successorExceptions; } | getSuccessorExceptions |
39,746 | String () { return id + ":" + DecompilerContext.getNewLineSeparator() + seq.toString(0); } | toString |
39,747 | boolean () { return protectedRange.contains(handler); } | isCircular |
39,748 | String () { String new_line_separator = DecompilerContext.getNewLineSeparator(); StringBuilder buf = new StringBuilder(); buf.append("exceptionType:"); if (exceptionTypes == null) { buf.append(" null"); } else { for (String exception_type : exceptionTypes) { buf.append(" ").append(exception_type); } } buf.append(new_li... | toString |
39,749 | BasicBlock () { return handler; } | getHandler |
39,750 | void (BasicBlock handler) { this.handler = handler; } | setHandler |
39,751 | List<BasicBlock> () { return protectedRange; } | getProtectedRange |
39,752 | List<String> () { return this.exceptionTypes; } | getExceptionTypes |
39,753 | void (String exceptionType) { if (this.exceptionTypes == null) { return; } if (exceptionType == null) { this.exceptionTypes = null; } else { this.exceptionTypes.add(exceptionType); } } | addExceptionType |
39,754 | String () { return exceptionTypes != null ? exceptionTypes.stream().distinct().collect(Collectors.joining(":")) : null; } | getUniqueExceptionsString |
39,755 | void () { for (BasicBlock block : blocks) { block.mark = 0; } } | removeMarkers |
39,756 | String () { if (blocks == null) return "Empty"; String new_line_separator = DecompilerContext.getNewLineSeparator(); StringBuilder buf = new StringBuilder(); for (BasicBlock block : blocks) { buf.append("----- Block ").append(block.id).append(" -----").append(new_line_separator); buf.append(block); buf.append("----- Ed... | toString |
39,757 | void (StructClass cl, StructMethod mt) { processJsr(); removeJsr(cl, mt); removeMarkers(); DeadCodeHelper.removeEmptyBlocks(this); } | inlineJsr |
39,758 | void (BasicBlock block) { while (block.getSuccessors().size() > 0) { block.removeSuccessor(block.getSuccessors().get(0)); } while (block.getSuccessorExceptions().size() > 0) { block.removeSuccessorException(block.getSuccessorExceptions().get(0)); } while (block.getPredecessors().size() > 0) { block.getPredecessors().ge... | removeBlock |
39,759 | ExceptionRangeCFG (BasicBlock handler, BasicBlock block) { //List<ExceptionRangeCFG> ranges = new ArrayList<ExceptionRangeCFG>(); for (int i = exceptions.size() - 1; i >= 0; i--) { ExceptionRangeCFG range = exceptions.get(i); if (range.getHandler() == handler && range.getProtectedRange().contains(block)) { return range... | getExceptionRange |
39,760 | void (InstructionSequence instrseq) { short[] states = findStartInstructions(instrseq); Map<Integer, BasicBlock> mapInstrBlocks = new HashMap<>(); VBStyleCollection<BasicBlock, Integer> colBlocks = createBasicBlocks(states, instrseq, mapInstrBlocks); blocks = colBlocks; connectBlocks(colBlocks, mapInstrBlocks); setExce... | buildBlocks |
39,761 | short[] (InstructionSequence seq) { int len = seq.length(); short[] inststates = new short[len]; Set<Integer> excSet = new HashSet<>(); for (ExceptionHandler handler : seq.getExceptionTable().getHandlers()) { excSet.add(handler.from_instr); excSet.add(handler.to_instr); excSet.add(handler.handler_instr); } for (int i =... | findStartInstructions |
39,762 | void (List<BasicBlock> lstbb, Map<Integer, BasicBlock> mapInstrBlocks) { for (int i = 0; i < lstbb.size(); i++) { BasicBlock block = lstbb.get(i); Instruction instr = block.getLastInstruction(); boolean fallthrough = instr.canFallThrough(); BasicBlock bTemp; switch (instr.group) { case GROUP_JUMP -> { int dest = ((Jump... | connectBlocks |
39,763 | void (InstructionSequence instrseq, Map<Integer, BasicBlock> instrBlocks) { exceptions = new ArrayList<>(); Map<String, ExceptionRangeCFG> mapRanges = new HashMap<>(); for (ExceptionHandler handler : instrseq.getExceptionTable().getHandlers()) { BasicBlock from = instrBlocks.get(handler.from_instr); BasicBlock to = ins... | setExceptionEdges |
39,764 | void () { final Map<BasicBlock, BasicBlock> subroutines = new LinkedHashMap<>(); for (BasicBlock block : blocks) { if (block.getSeq().getLastInstr().opcode == CodeConstants.opc_jsr) { LinkedList<BasicBlock> stack = new LinkedList<>(); LinkedList<LinkedList<BasicBlock>> stackJsrStacks = new LinkedList<>(); Set<BasicBloc... | setSubroutineEdges |
39,765 | void () { while (true) { if (processJsrRanges() == 0) break; } } | processJsr |
39,766 | int () { List<JsrRecord> lstJsrAll = new ArrayList<>(); // get all jsr ranges for (Entry<BasicBlock, BasicBlock> ent : subroutines.entrySet()) { BasicBlock jsr = ent.getKey(); BasicBlock ret = ent.getValue(); lstJsrAll.add(new JsrRecord(jsr, getJsrRange(jsr, ret), ret)); } // sort ranges // FIXME: better sort order Lis... | processJsrRanges |
39,767 | Set<BasicBlock> (BasicBlock jsr, BasicBlock ret) { Set<BasicBlock> blocks = new HashSet<>(); List<BasicBlock> lstNodes = new LinkedList<>(); lstNodes.add(jsr); BasicBlock dom = jsr.getSuccessors().get(0); while (!lstNodes.isEmpty()) { BasicBlock node = lstNodes.remove(0); for (int j = 0; j < 2; j++) { List<BasicBlock> ... | getJsrRange |
39,768 | void (BasicBlock jsr, BasicBlock ret, Set<BasicBlock> common_blocks) { List<BasicBlock> lstNodes = new LinkedList<>(); Map<Integer, BasicBlock> mapNewNodes = new HashMap<>(); lstNodes.add(jsr); mapNewNodes.put(jsr.id, jsr); while (!lstNodes.isEmpty()) { BasicBlock node = lstNodes.remove(0); for (int j = 0; j < 2; j++) ... | splitJsrRange |
39,769 | void (Set<BasicBlock> common_blocks, Map<Integer, BasicBlock> mapNewNodes) { for (int i = exceptions.size() - 1; i >= 0; i--) { ExceptionRangeCFG range = exceptions.get(i); List<BasicBlock> lstRange = range.getProtectedRange(); HashSet<BasicBlock> setBoth = new HashSet<>(common_blocks); setBoth.retainAll(lstRange); if ... | splitJsrExceptionRanges |
39,770 | void (StructClass cl, StructMethod mt) { removeJsrInstructions(cl.getPool(), first, DataPoint.getInitialDataPoint(mt)); } | removeJsr |
39,771 | void (ConstantPool pool, BasicBlock block, DataPoint data) { ListStack<VarType> stack = data.getStack(); InstructionSequence seq = block.getSeq(); for (int i = 0; i < seq.length(); i++) { Instruction instr = seq.getInstr(i); VarType var = null; if (instr.opcode == CodeConstants.opc_astore || instr.opcode == CodeConstan... | removeJsrInstructions |
39,772 | void () { first = blocks.get(0); last = new BasicBlock(++last_id); for (BasicBlock block : blocks) { if (block.getSuccessors().isEmpty()) { last.addPredecessor(block); } } } | setFirstAndLastBlocks |
39,773 | List<BasicBlock> () { List<BasicBlock> res = new LinkedList<>(); addToReversePostOrderListIterative(first, res); return res; } | getReversePostOrder |
39,774 | void (BasicBlock root, List<? super BasicBlock> lst) { LinkedList<BasicBlock> stackNode = new LinkedList<>(); LinkedList<Integer> stackIndex = new LinkedList<>(); Set<BasicBlock> setVisited = new HashSet<>(); stackNode.add(root); stackIndex.add(0); while (!stackNode.isEmpty()) { BasicBlock node = stackNode.getLast(); i... | addToReversePostOrderListIterative |
39,775 | BasicBlock () { return first; } | getFirst |
39,776 | void (BasicBlock first) { this.first = first; } | setFirst |
39,777 | List<ExceptionRangeCFG> () { return exceptions; } | getExceptions |
39,778 | BasicBlock () { return last; } | getLast |
39,779 | Set<BasicBlock> () { return finallyExits; } | getFinallyExits |
39,780 | DecompilerContext () { return currentContext.get(); } | getCurrentContext |
39,781 | void (DecompilerContext context) { currentContext.set(context); } | setCurrentContext |
39,782 | void (String key, Object value) { getCurrentContext().properties.put(key, value); } | setProperty |
39,783 | void (ImportCollector importCollector) { DecompilerContext context = getCurrentContext(); context.importCollector = importCollector; context.counterContainer = new CounterContainer(); context.bytecodeSourceMapper = new BytecodeSourceMapper(); } | startClass |
39,784 | void (VarProcessor varProcessor) { DecompilerContext context = getCurrentContext(); context.varProcessor = varProcessor; context.counterContainer = new CounterContainer(); } | startMethod |
39,785 | Object (String key) { return getCurrentContext().properties.get(key); } | getProperty |
39,786 | boolean (String key) { return "1".equals(getProperty(key)); } | getOption |
39,787 | String () { return getOption(IFernflowerPreferences.NEW_LINE_SEPARATOR) ? IFernflowerPreferences.LINE_SEPARATOR_UNX : IFernflowerPreferences.LINE_SEPARATOR_WIN; } | getNewLineSeparator |
39,788 | IFernflowerLogger () { return getCurrentContext().logger; } | getLogger |
39,789 | StructContext () { return getCurrentContext().structContext; } | getStructContext |
39,790 | ClassesProcessor () { return getCurrentContext().classProcessor; } | getClassProcessor |
39,791 | CancellationManager () { return getCurrentContext().cancellationManager; } | getCancellationManager |
39,792 | PoolInterceptor () { return getCurrentContext().poolInterceptor; } | getPoolInterceptor |
39,793 | ImportCollector () { return getCurrentContext().importCollector; } | getImportCollector |
39,794 | VarProcessor () { return getCurrentContext().varProcessor; } | getVarProcessor |
39,795 | CounterContainer () { return getCurrentContext().counterContainer; } | getCounterContainer |
39,796 | BytecodeSourceMapper () { return getCurrentContext().bytecodeSourceMapper; } | getBytecodeSourceMapper |
39,797 | void (ClassWrapper wrapper) { StructClass cl = wrapper.getClassStruct(); // hide values/valueOf methods and super() invocations for (MethodWrapper method : wrapper.getMethods()) { StructMethod mt = method.methodStruct; String name = mt.getName(); String descriptor = mt.getDescriptor(); if ("values".equals(name)) { if (... | clearEnum |
39,798 | IIdentifierRenamer (String className, IFernflowerLogger logger) { if (className != null) { try { Class<?> renamerClass = Fernflower.class.getClassLoader().loadClass(className); return (IIdentifierRenamer) renamerClass.getDeclaredConstructor().newInstance(); } catch (Exception e) { logger.writeMessage("Cannot load renam... | loadHelper |
39,799 | void (File source) { structContext.addSpace(source, true); } | addSource |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.