Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
40,400 | void (Statement stat) { boolean found; do { found = false; for (int i = 0; i < stat.getStats().size(); i++) { Statement st = stat.getStats().get(i); cleanUpUnreachableBlocks(st); if (st.type == StatementType.SEQUENCE && st.getStats().size() > 1) { Statement last = st.getStats().getLast(); Statement secondlast = st.getS... | cleanUpUnreachableBlocks |
40,401 | int (Statement stat) { int ret = 0; Statement dest; if (stat.getExprents() == null) { while (true) { int changed = 0; for (Statement st : stat.getStats()) { changed = integrateExits(st); if (changed > 0) { ret = 1; break; } } if (changed == 0) { break; } } if (stat.type == StatementType.IF) { IfStatement ifst = (IfStat... | integrateExits |
40,402 | Statement (StatEdge edge) { Statement dest = edge.getDestination(); if (edge.getType() == EdgeType.BREAK && dest.type == StatementType.BASIC_BLOCK && edge.explicit && (edge.labeled || isOnlyEdge(edge))) { List<Exprent> data = dest.getExprents(); if (data != null && data.size() == 1) { if (data.get(0).type == Exprent.EX... | isExitEdge |
40,403 | boolean (StatEdge edge) { Statement stat = edge.getDestination(); for (StatEdge ed : stat.getAllPredecessorEdges()) { if (ed != edge) { if (ed.getType() == EdgeType.REGULAR) { Statement source = ed.getSource(); if (source.type == StatementType.BASIC_BLOCK || (source.type == StatementType.IF && ((IfStatement)source).ift... | isOnlyEdge |
40,404 | void (RootStatement root) { DummyExitStatement dummyExit = root.getDummyExit(); for (StatEdge edge : dummyExit.getAllPredecessorEdges()) { if (!edge.explicit) { Statement source = edge.getSource(); List<Exprent> lstExpr = source.getExprents(); if (lstExpr != null && !lstExpr.isEmpty()) { Exprent expr = lstExpr.get(lstE... | removeRedundantReturns |
40,405 | boolean (RootStatement root) { FlattenStatementsHelper flatthelper = new FlattenStatementsHelper(); DirectGraph dgraph = flatthelper.buildDirectGraph(root); LinkedList<DirectNode> stack = new LinkedList<>(); stack.add(dgraph.first); HashSet<DirectNode> setVisited = new HashSet<>(); boolean res = false; while (!stack.is... | findPPandMM |
40,406 | boolean (List<Exprent> lst) { boolean result = false; for (int i = 0; i < lst.size(); i++) { Exprent exprent = lst.get(i); exprentReplaced = false; Exprent retexpr = processExprentRecursive(exprent); if (retexpr != null) { lst.set(i, retexpr); result = true; i--; // process the same exprent again } result |= exprentRep... | processExprentList |
40,407 | Exprent (Exprent exprent) { boolean replaced = true; while (replaced) { replaced = false; for (Exprent expr : exprent.getAllExprents()) { Exprent retexpr = processExprentRecursive(expr); if (retexpr != null) { exprent.replaceExprent(expr, retexpr); replaced = true; exprentReplaced = true; break; } } } if (exprent.type ... | processExprentRecursive |
40,408 | void (@NotNull RootStatement statement, @NotNull StructClass structClass) { if (!structClass.hasPatternsInInstanceofSupport()) return; boolean recordPatternSupport = structClass.hasRecordPatternSupport(); List<TempVarAssignmentItem> tempVarAssignments = new ArrayList<>(); List<Runnable> runnables = replaceAssignmentsWi... | replaceAssignmentsWithPatternVariables |
40,409 | List<Runnable> (@NotNull Statement statement, @NotNull Set<IfStatement> usedIfStatements, @NotNull List<TempVarAssignmentItem> tempVarAssignments, boolean recordPatternSupport) { ArrayList<Runnable> actions = new ArrayList<>(); if (statement instanceof IfStatement ifStatement && !usedIfStatements.contains(ifStatement))... | replaceAssignmentsWithPatternVariables |
40,410 | FunctionExprent (@NotNull IfStatement ifStat) { return ifStat.getHeadexprent().getAllExprents(true).stream() .filter(expr -> expr.type == Exprent.EXPRENT_FUNCTION).map(expr -> (FunctionExprent)expr) .filter(expr -> expr.getFuncType() == FunctionExprent.FUNCTION_INSTANCEOF) .findFirst().orElse(null); } | findInstanceofExprent |
40,411 | PatternVariableCandidate (@NotNull Statement ifElseStat, @NotNull VarExprent operand, @NotNull ConstExprent checkType, boolean recordPatternSupport, @NotNull Statement topLevelStatement) { if (ifElseStat instanceof BasicBlockStatement basicBlockStatement) { //check that cast correct and get the last assignment PatternV... | findInitPatternVarCandidate |
40,412 | PatternVariableCandidate (@NotNull Statement ifBranch, @NotNull VarExprent operand, @NotNull ConstExprent checkType, @NotNull VarTracker varTracker, @NotNull Statement topLevelStatement) { if (ifBranch instanceof BasicBlockStatement) { //check that cast correct and get the last assignment PatternVariableCandidate candi... | findNextPatternVarCandidate |
40,413 | PatternVariableCandidate (@NotNull Statement ifElseStat, @NotNull VarExprent operand, @NotNull ConstExprent checkType, @NotNull Statement topLevelStatement) { List<Exprent> ifElseExprents = ifElseStat.getExprents(); if (ifElseExprents==null || ifElseExprents.isEmpty() || ifElseExprents.get(0).type != Exprent.EXPRENT_AS... | findSimpleCandidateFromIfStat |
40,414 | PatternVariableCandidate (@NotNull BasicBlockStatement blockStatement, @NotNull VarExprent varExprent, @NotNull VarExprent candidate) { Statement parent = blockStatement.getParent(); if (!(parent instanceof SequenceStatement parentSequenceStatement)) { return null; } int indexOfBlock = parentSequenceStatement.getStats(... | findInitRecordPatternCandidate |
40,415 | PatternVariableCandidate (@NotNull Statement parent, @NotNull VarTracker varTracker) { if (!(parent instanceof SequenceStatement)) { return null; } if (checkRegularEdgesForRecordPattern(parent)) return null; Set<IfStatement> ifStatements = new HashSet<>(); VBStyleCollection<Statement, Integer> stats = parent.getStats()... | findRecordPatternCandidate |
40,416 | PatternVariableCandidate (@NotNull Statement statement, @NotNull VarTracker tracker, @NotNull List<TempVarAssignmentItem> tempVarAssignmentItems) { if (!(statement instanceof IfStatement ifStatement)) { return null; } if (ifStatement.isNegated() || ifStatement.getHeadexprent().getAllExprents().size() != 1) { return nul... | findRecursivelyInstanceOfIfStatement |
40,417 | boolean (@NotNull VarTracker tracker, @NotNull CatchStatement statement) { Statement tryBody = statement.getFirst(); if (tryBody == null || tryBody.getStats() == null || !tryBody.getStats().isEmpty() || tryBody.getExprents() == null || tryBody.getExprents().size() != 1) { return false; } Exprent body = tryBody.getExpre... | processCatchStatement |
40,418 | boolean (@NotNull VarTracker tracker, @NotNull Statement statement) { if (statement instanceof BasicBlockStatement && statement.getExprents() != null) { for (Exprent statementExprent : statement.getExprents()) { if (!collectRecordAssignment(tracker, statementExprent, statement)) return false; } } return true; } | processFullBlock |
40,419 | boolean (@NotNull VarTracker tracker, @NotNull Statement statement) { if (statement instanceof BasicBlockStatement && statement.getExprents() != null) { boolean found = false; for (Exprent statementExprent : statement.getExprents()) { if (collectRecordAssignment(tracker, statementExprent, statement)) { found = true; co... | processAtLeastOneBlock |
40,420 | boolean (@NotNull VarTracker tracker, @Nullable Exprent exprent, @NotNull Statement statement) { if (!(exprent instanceof AssignmentExprent assignmentExprent)) { return false; } Exprent exprentLeft = assignmentExprent.getLeft(); if (!(exprentLeft instanceof VarExprent leftVarExprent)) { return false; } Exprent right = ... | collectRecordAssignment |
40,421 | boolean (@NotNull Statement parent) { for (int i = 0; i < parent.getStats().size(); i++) { Statement statement = parent.getStats().get(i); if (i != parent.getStats().size() - 1) { List<StatEdge> edges = statement.getSuccessorEdges(StatEdge.EdgeType.DIRECT_ALL); if (edges.size() != 1) { return true; } StatEdge edge = ed... | checkRegularEdgesForRecordPattern |
40,422 | VarExprent () { return varExprent; } | getVarExprent |
40,423 | List<TempVarAssignmentItem> () { return tempVarAssignments; } | getTempVarAssignments |
40,424 | Runnable () { return cleaner; } | getCleaner |
40,425 | Set<IfStatement> () { return usedIfStatement; } | getUsedIfStatement |
40,426 | Statement () { return nextStatement; } | getNextStatement |
40,427 | void (@NotNull VarTracker tracker) { root = tracker.root; varRecordTracker.putAll(tracker.varRecordTracker); varTempAssignmentTracker.addAll(tracker.varTempAssignmentTracker); } | putAll |
40,428 | void (RootStatement root) { LinkedList<Statement> stack = new LinkedList<>(); stack.add(root); while (!stack.isEmpty()) { Statement stat = stack.removeFirst(); stat.clearTempInformation(); stack.addAll(stat.getStats()); } } | clearStatements |
40,429 | void (Exprent exprent, VarType type) { maxTypeExprents.add(new ExprentTypePair(exprent, type)); } | addMaxTypeExprent |
40,430 | void (Exprent exprent, VarType type) { minTypeExprents.add(new ExprentTypePair(exprent, type)); } | addMinTypeExprent |
40,431 | List<ExprentTypePair> () { return maxTypeExprents; } | getMaxTypeExprents |
40,432 | List<ExprentTypePair> () { return minTypeExprents; } | getMinTypeExprents |
40,433 | void (VarVersionEdge edge) { predecessors.add(edge); } | addPredecessor |
40,434 | void (VarVersionEdge edge) { predecessors.remove(edge); } | removePredecessor |
40,435 | void (VarVersionEdge edge) { successors.add(edge); } | addSuccessor |
40,436 | void (VarVersionEdge edge) { successors.remove(edge); } | removeSuccessor |
40,437 | List<IGraphNode> () { List<IGraphNode> lst = new ArrayList<>(predecessors.size()); for (VarVersionEdge edge : predecessors) { lst.add(edge.source); } return lst; } | getPredecessorNodes |
40,438 | String () { return "(" + var + '_' + version + ')'; } | toString |
40,439 | VarVersionNode (VarVersionPair ver) { VarVersionNode node; nodes.addWithKey(node = new VarVersionNode(ver.var, ver.version), ver); return node; } | createNode |
40,440 | void (Collection<VarVersionNode> colnodes, Collection<VarVersionPair> colpaars) { nodes.addAllWithKey(colnodes, colpaars); } | addNodes |
40,441 | boolean (VarVersionNode node, Set<VarVersionNode> domnodes) { if (domnodes.size() == 1) { return engine.isDominator(node, domnodes.iterator().next()); } else { Set<VarVersionNode> marked = new HashSet<>(); if (domnodes.contains(node)) { return true; } List<VarVersionNode> lstNodes = new LinkedList<>(); lstNodes.add(nod... | isDominatorSet |
40,442 | void () { Set<VarVersionNode> roots = new HashSet<>(); for (VarVersionNode node : nodes) { if (node.predecessors.isEmpty()) { roots.add(node); } } engine = new GenericDominatorEngine(new IGraph() { @Override public List<? extends IGraphNode> getReversePostOrderList() { return getReversedPostOrder(roots); } @Override pu... | initDominators |
40,443 | List<VarVersionNode> (Collection<VarVersionNode> roots) { List<VarVersionNode> lst = new LinkedList<>(); Set<VarVersionNode> setVisited = new HashSet<>(); for (VarVersionNode root : roots) { List<VarVersionNode> lstTemp = new LinkedList<>(); addToReversePostOrderListIterative(root, lstTemp, setVisited); lst.addAll(lstT... | getReversedPostOrder |
40,444 | void (VarVersionNode root, List<? super VarVersionNode> lst, Set<? super VarVersionNode> setVisited) { Map<VarVersionNode, List<VarVersionEdge>> mapNodeSuccs = new HashMap<>(); LinkedList<VarVersionNode> stackNode = new LinkedList<>(); LinkedList<Integer> stackIndex = new LinkedList<>(); stackNode.add(root); stackIndex... | addToReversePostOrderListIterative |
40,445 | boolean (Object o) { if (o == this) return true; if (!(o instanceof VarVersionEdge edge)) return false; return type == edge.type && source == edge.source && dest == edge.dest; } | equals |
40,446 | int () { return hashCode; } | hashCode |
40,447 | String () { return source.toString() + " ->" + type + "-> " + dest.toString(); } | toString |
40,448 | void (@NotNull RootStatement root, @NotNull DirectGraph graph) { setInitVariables(); setCatchBlockVariables(root); resetExprentTypes(graph); //noinspection StatementWithEmptyBody while (!processVarTypes(graph)) ; } | calculateVarTypes |
40,449 | void () { boolean thisVar = !method.hasModifier(CodeConstants.ACC_STATIC); if (thisVar) { StructClass currentClass = (StructClass)DecompilerContext.getProperty(DecompilerContext.CURRENT_CLASS); VarType classType = new VarType(CodeConstants.TYPE_OBJECT, 0, currentClass.qualifiedName); minExprentTypes.put(new VarVersionP... | setInitVariables |
40,450 | void (@NotNull RootStatement root) { LinkedList<Statement> statements = new LinkedList<>(); statements.add(root); while (!statements.isEmpty()) { Statement statement = statements.removeFirst(); List<VarExprent> catchVariables = null; if (statement.type == StatementType.CATCH_ALL) { catchVariables = ((CatchAllStatement)... | setCatchBlockVariables |
40,451 | boolean (@NotNull Exprent currentExprent) { for (Exprent exprent : currentExprent.getAllExprents()) { if (!checkTypeExprent(exprent)) return false; } if (currentExprent.type == Exprent.EXPRENT_CONST) { ConstExprent constExprent = (ConstExprent)currentExprent; if (constExprent.getConstType().getTypeFamily() <= CodeConst... | checkTypeExprent |
40,452 | boolean (@NotNull DirectGraph graph) { return graph.iterateExprents(exprent -> checkTypeExprent(exprent) ? 0 : 1); } | processVarTypes |
40,453 | boolean (@NotNull Exprent exprent, @NotNull VarType newType, boolean checkMinExprentType) { if (exprent.type == Exprent.EXPRENT_CONST) { ConstExprent constExprent = (ConstExprent)exprent; VarType constType = constExprent.getConstType(); if (newType.getTypeFamily() > CodeConstants.TYPE_FAMILY_INTEGER || constType.getTyp... | changeExprentType |
40,454 | boolean (@NotNull VarVersionPair varVersion, @NotNull Exprent exprent, @NotNull VarType newType, boolean checkMinExprentType) { if (checkMinExprentType) { VarType currentMinType = minExprentTypes.get(varVersion); VarType newMinType; if (currentMinType == null || newType.getTypeFamily() > currentMinType.getTypeFamily())... | changeConstExprentType |
40,455 | void (@NotNull DirectGraph graph) { graph.iterateExprents(currExprent -> { List<Exprent> allExprents = currExprent.getAllExprents(true); allExprents.add(currExprent); for (Exprent exprent : allExprents) { if (exprent.type == Exprent.EXPRENT_VAR) { ((VarExprent)exprent).setVarType(VarType.VARTYPE_UNKNOWN); } else if (ex... | resetExprentTypes |
40,456 | VarType (VarVersionPair pair) { return minExprentTypes.get(pair); } | getVarType |
40,457 | void (VarVersionPair pair, VarType type) { minExprentTypes.put(pair, type); } | setVarType |
40,458 | boolean (Object o) { if (o == this) return true; if (!(o instanceof VarVersionPair paar)) return false; return var == paar.var && version == paar.version; } | equals |
40,459 | int () { if (hashCode == -1) { hashCode = this.var * 3 + this.version; } return hashCode; } | hashCode |
40,460 | String () { return "(" + var + "," + version + ")"; } | toString |
40,461 | void (RootStatement root) { VarVersionsProcessor oldProcessor = varVersions; varVersions = new VarVersionsProcessor(method, methodDescriptor); varVersions.setVarVersions(root, oldProcessor); } | setVarVersions |
40,462 | void (Statement root) { mapVarNames = new HashMap<>(); new VarDefinitionHelper(root, method, this).setVarDefinitions(); } | setVarDefinitions |
40,463 | void (Map<Integer, String> mapDebugVarNames) { if (varVersions == null) { return; } Map<Integer, Integer> mapOriginalVarIndices = varVersions.getMapOriginalVarIndices(); List<VarVersionPair> listVars = new ArrayList<>(mapVarNames.keySet()); listVars.sort(Comparator.comparingInt(o -> o.var)); Map<String, Integer> mapNam... | setDebugVarNames |
40,464 | Integer (int index) { return varVersions == null ? null : varVersions.getMapOriginalVarIndices().get(index); } | getVarOriginalIndex |
40,465 | void (VarNamesCollector vc) { Map<VarVersionPair, String> tempVarNames = new HashMap<>(mapVarNames); for (Entry<VarVersionPair, String> ent : tempVarNames.entrySet()) { mapVarNames.put(ent.getKey(), vc.getFreeName(ent.getValue())); } } | refreshVarNames |
40,466 | VarNamesCollector () { return varNamesCollector; } | getVarNamesCollector |
40,467 | VarType (VarVersionPair pair) { return varVersions == null ? null : varVersions.getVarType(pair); } | getVarType |
40,468 | void (VarVersionPair pair, VarType type) { varVersions.setVarType(pair, type); } | setVarType |
40,469 | String (VarVersionPair pair) { return mapVarNames == null ? null : mapVarNames.get(pair); } | getVarName |
40,470 | void (VarVersionPair pair, String name) { mapVarNames.put(pair, name); } | setVarName |
40,471 | Collection<String> () { return mapVarNames != null ? mapVarNames.values() : Collections.emptySet(); } | getVarNames |
40,472 | int (VarVersionPair pair) { return varVersions == null ? VAR_FINAL : varVersions.getVarFinal(pair); } | getVarFinal |
40,473 | void (VarVersionPair pair, int finalType) { varVersions.setVarFinal(pair, finalType); } | setVarFinal |
40,474 | Set<VarVersionPair> () { return externalVars; } | getExternalVars |
40,475 | boolean (VarVersionPair pair) { return finalParameters.get(pair.var); } | isParameterFinal |
40,476 | void (VarVersionPair pair) { finalParameters.set(pair.var); } | setParameterFinal |
40,477 | int () { return firstParameterVarIndex; } | getFirstParameterVarIndex |
40,478 | int () { return firstParameterPosition; } | getFirstParameterPosition |
40,479 | void (RootStatement root, VarVersionsProcessor previousVersionsProcessor) { SSAConstructorSparseEx ssa = new SSAConstructorSparseEx(); ssa.splitVariables(root, method); FlattenStatementsHelper flattenHelper = new FlattenStatementsHelper(); DirectGraph graph = flattenHelper.buildDirectGraph(root); mergePhiVersions(ssa, ... | setVarVersions |
40,480 | void (SSAConstructorSparseEx ssa, DirectGraph graph) { // collect phi versions List<Set<VarVersionPair>> lst = new ArrayList<>(); for (Entry<VarVersionPair, FastSparseSet<Integer>> ent : ssa.getPhi().entrySet()) { Set<VarVersionPair> set = new HashSet<>(); set.add(ent.getKey()); for (Integer version : ent.getValue()) {... | mergePhiVersions |
40,481 | void (DirectGraph graph, final Map<VarVersionPair, Integer> versions) { graph.iterateExprents(exprent -> { List<Exprent> lst = exprent.getAllExprents(true); lst.add(exprent); for (Exprent expr : lst) { if (expr.type == Exprent.EXPRENT_VAR) { VarExprent var = (VarExprent)expr; Integer version = versions.get(new VarVersi... | updateVersions |
40,482 | void (VarTypeProcessor typeProcessor) { Map<VarVersionPair, VarType> mapExprentMaxTypes = typeProcessor.getMaxExprentTypes(); Map<VarVersionPair, VarType> mapExprentMinTypes = typeProcessor.getMinExprentTypes(); for (VarVersionPair paar : new ArrayList<>(mapExprentMinTypes.keySet())) { VarType type = mapExprentMinTypes... | eliminateNonJavaTypes |
40,483 | void (VarTypeProcessor typeProcessor, DirectGraph graph, StructMethod mt) { Map<VarVersionPair, VarType> mapExprentMaxTypes = typeProcessor.getMaxExprentTypes(); Map<VarVersionPair, VarType> mapExprentMinTypes = typeProcessor.getMinExprentTypes(); Map<Integer, Set<Integer>> mapVarVersions = new HashMap<>(); for (VarVer... | simpleMerge |
40,484 | void (VarTypeProcessor typeProcessor, DirectGraph graph, VarVersionsProcessor previousVersionsProcessor) { final Map<VarVersionPair, VarType> mapExprentMaxTypes = typeProcessor.getMaxExprentTypes(); Map<VarVersionPair, VarType> mapExprentMinTypes = typeProcessor.getMinExprentTypes(); Map<VarVersionPair, Integer> mapFin... | setNewVarIndices |
40,485 | VarType (VarVersionPair pair) { return typeProcessor.getVarType(pair); } | getVarType |
40,486 | void (VarVersionPair pair, VarType type) { typeProcessor.setVarType(pair, type); } | setVarType |
40,487 | int (VarVersionPair pair) { Integer fin = typeProcessor.getFinalVariables().get(pair); return fin == null ? VarProcessor.VAR_FINAL : fin; } | getVarFinal |
40,488 | void (VarVersionPair pair, int finalType) { typeProcessor.getFinalVariables().put(pair, finalType); } | setVarFinal |
40,489 | void () { VarNamesCollector vc = varproc.getVarNamesCollector(); for (Entry<Integer, Statement> en : mapVarDefStatements.entrySet()) { Statement stat = en.getValue(); Integer index = en.getKey(); if (implDefVars.contains(index)) { // already implicitly defined continue; } varproc.setVarName(new VarVersionPair(index.int... | setVarDefinitions |
40,490 | Statement (Statement stat, Integer varindex) { LinkedList<Statement> stack = new LinkedList<>(); stack.add(stat); while (!stack.isEmpty()) { Statement st = stack.remove(0); if (stack.isEmpty() || mapStatementVars.get(st.id).contains(varindex)) { if (st.isLabeled() && !stack.isEmpty()) { return st; } if (st.getExprents(... | findFirstBlock |
40,491 | Set<Integer> (Statement stat) { HashMap<Integer, Integer> mapCount = new HashMap<>(); List<VarExprent> condlst; if (stat.getExprents() == null) { // recurse on children statements List<Integer> childVars = new ArrayList<>(); List<Exprent> currVars = new ArrayList<>(); for (Object obj : stat.getSequentialObjects()) { if... | initStatement |
40,492 | List<VarExprent> (List<Exprent> lst) { List<VarExprent> res = new ArrayList<>(); List<Exprent> listTemp = new ArrayList<>(); for (Exprent expr : lst) { listTemp.addAll(expr.getAllExprents(true)); listTemp.add(expr); } for (Exprent exprent : listTemp) { if (exprent.type == Exprent.EXPRENT_VAR) { res.add((VarExprent)expr... | getAllVars |
40,493 | boolean (Exprent expr, Integer index) { if (expr.type == Exprent.EXPRENT_ASSIGNMENT) { Exprent left = ((AssignmentExprent)expr).getLeft(); if (left.type == Exprent.EXPRENT_VAR) { VarExprent var = (VarExprent)left; if (var.getIndex() == index) { var.setDefinition(true); return true; } } } return false; } | setDefinition |
40,494 | VarType (int val, boolean boolPermitted) { if (boolPermitted) { VarType constType = VarType.VARTYPE_BOOLEAN; if (val != 0 && val != 1) { constType = constType.copy(true); } return constType; } else if (0 <= val && val <= 127) { return VarType.VARTYPE_BYTECHAR; } else if (-128 <= val && val <= 127) { return VarType.VART... | guessType |
40,495 | Exprent () { return new ConstExprent(constType, value, bytecode); } | copy |
40,496 | VarType () { return constType; } | getExprType |
40,497 | int () { return Exprent.MULTIPLE_USES | Exprent.SIDE_EFFECTS_FREE; } | getExprentUse |
40,498 | List<Exprent> () { return new ArrayList<>(); } | getAllExprents |
40,499 | TextBuffer (int indent, BytecodeMappingTracer tracer) { boolean literal = DecompilerContext.getOption(IFernflowerPreferences.LITERALS_AS_IS); boolean ascii = DecompilerContext.getOption(IFernflowerPreferences.ASCII_STRING_CHARACTERS); tracer.addMapping(bytecode); if (constType.getType() != CodeConstants.TYPE_NULL && va... | toJava |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.