00001:/*
00002: **
00003: * Decompiler.java Copyright (c) 2006,07 Swaroop Belur
00004: *
00005: * This program is free software; you can redistribute it and/itor
00006: * modify it under the terms of the GNU General Public License
00007: * as published by the Free Software Foundation; either version 2
00008: * of the License, or (at your option) any later version.
00009:
00010: * This program is distributed in the hope that it will be useful,
00011: * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00013: * GNU General Public License for more details.
00014:
00015: * You should have received a copy of the GNU General Public License
00016: * along with this program; if not, write to the Free Software
00017: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00018: *
00019: **
00020: */
00021:
00022:package net.sf.jdec.core;
00023:
00024:import java.io.IOException;
00025:import java.util.ArrayList;
00026:import java.util.Arrays;
00027:import java.util.Collection;
00028:import java.util.Collections;
00029:import java.util.HashMap;
00030:import java.util.Hashtable;
00031:import java.util.Iterator;
00032:import java.util.List;
00033:import java.util.Map;
00034:import java.util.Set;
00035:import java.util.Stack;
00036:import java.util.StringTokenizer;
00037:import java.util.Map.Entry;
00038:
00039:import net.sf.jdec.blockhelpers.BranchHelper;
00040:import net.sf.jdec.blockhelpers.IFHelper;
00041:import net.sf.jdec.blockhelpers.LoopHelper;
00042:import net.sf.jdec.blockhelpers.TryHelper;
00043:import net.sf.jdec.blocks.CatchBlock;
00044:import net.sf.jdec.blocks.FinallyBlock;
00045:import net.sf.jdec.blocks.IFBlock;
00046:import net.sf.jdec.blocks.Loop;
00047:import net.sf.jdec.blocks.Switch;
00048:import net.sf.jdec.blocks.TryBlock;
00049:import net.sf.jdec.blocks.TryCatchFinally;
00050:import net.sf.jdec.blocks.Switch.Case;
00051:import net.sf.jdec.commonutil.Objects;
00052:import net.sf.jdec.config.Configuration;
00053:import net.sf.jdec.constantpool.CPString;
00054:import net.sf.jdec.constantpool.ClassDescription;
00055:import net.sf.jdec.constantpool.ClassInfo;
00056:import net.sf.jdec.constantpool.DoublePrimitive;
00057:import net.sf.jdec.constantpool.FieldRef;
00058:import net.sf.jdec.constantpool.FloatPrimitive;
00059:import net.sf.jdec.constantpool.IntPrimitive;
00060:import net.sf.jdec.constantpool.InterfaceMethodRef;
00061:import net.sf.jdec.constantpool.LongPrimitive;
00062:import net.sf.jdec.constantpool.MethodRef;
00063:import net.sf.jdec.constantpool.NameAndType;
00064:import net.sf.jdec.constantpool.MethodInfo.ExceptionTable;
00065:import net.sf.jdec.core.ShortcutAnalyser.Shortcutchain;
00066:import net.sf.jdec.core.ShortcutAnalyser.Shortcutstore;
00067:import net.sf.jdec.io.Writer;
00068:import net.sf.jdec.jvminstructions.commandholders.IInstructionCommandHolder;
00069:import net.sf.jdec.jvminstructions.commands.AbstractInstructionCommand;
00070:import net.sf.jdec.jvminstructions.util.InstrConstants;
00071:import net.sf.jdec.jvminstructions.util.InstructionHelper;
00072:import net.sf.jdec.lookup.FinderFactory;
00073:import net.sf.jdec.lookup.IFinder;
00074:import net.sf.jdec.main.ConsoleLauncher;
00075:import net.sf.jdec.reflection.Behaviour;
00076:import net.sf.jdec.reflection.ConstructorMember;
00077:import net.sf.jdec.util.AllExceptionHandler;
00078:import net.sf.jdec.util.ExecutionState;
00079:import net.sf.jdec.util.Util;
00080:
00081:/*******************************************************************************
00082: *
00083: * @author swaroop belur
00084: */
00085:public class Decompiler {
00086:
00087: private long startTime;
00088:
00089: private Behaviour behaviour;
00090:
00091: private ClassDescription cd;
00092:
00093: private OperandStack opStack;
00094:
00095: private Hashtable synchSkips = null;
00096:
00097: private List sortedsynchSkips = null;
00098:
00099: private List frozenMonitorStarts = new ArrayList();
00100:
00101: private List frozenMonitorExists = new ArrayList();
00102:
00103: private ShortcutAnalyser sanalyser = null;
00104:
00105: /***************************************************************************
00106: *
00107: * @param behaviour
00108: * Represents Either an Instance of Method of a class or a
00109: * constructor of a class
00110: */
00111:
00112: public Decompiler(Behaviour behaviour, ClassDescription cd) {
00113: Util.resetCurrentSpace();
00114: ExecutionState.setMethodContext(behaviour);
00115: GlobalVariableStore.reset();
00116: behaviour.setClassRef(ConsoleLauncher.getClazzRef());
00117: sanalyser = behaviour.getShortCutAnalyser();
00118: StringBuffer t = new StringBuffer("");
00119: Util.checkForImport(behaviour.getReturnType(), t);
00120: this .behaviour = behaviour;
00121: this .cd = cd;
00122: // opStack = new OperandStack();
00123: opStack = behaviour.getOpStack();
00124: if (cd.isClassCompiledWithMinusG() == false) {
00125:
00126: storeDataTypesForMethodParams(this .behaviour, this .cd);
00127: createLocalVariablesForMethodParams(this .behaviour, this .cd);
00128: if (this .behaviour.getCode() != null) {
00129: // BigInteger b
00130: storeDataTypesWRTConversionInst(this .behaviour, this .cd);
00131: storeDataTypesWRTMethodParams(this .behaviour, this .cd);
00132: storeDataTypesWRTLoadNStoreCombinations(this .behaviour, this .cd);
00133: long l = -1, l2 = -1;
00134: try {
00135: anewarrayrefpos = new Hashtable();
00136: GlobalVariableStore.setProblematicInvokes(new ArrayList());
00137: // l=System.currentTimeMillis();
00138: // System.out.println("Before Invoke "+(l-Jdec.l3));
00139: storeDataTypesWRTInvokeInst(this .behaviour, this .cd);
00140: // l2=System.currentTimeMillis();
00141: // System.out.println("After Invoke "+(l2-l));
00142: } catch (RuntimeException re) {
00143:
00144: AllExceptionHandler handler = new AllExceptionHandler(re,
00145: "Runtime Exception while handling storeDataTypesWRTInvokeInst");
00146: handler.setBehaviour(behaviour);
00147: handler.reportException(); // TODO: Uncomment This later
00148: ConsoleLauncher.addCouldNotFinish(behaviour);
00149: l2 = System.currentTimeMillis();
00150: return;
00151: }
00152:
00153: }
00154: // java.lang.String s="sdfasdf";
00155:
00156: }
00157: if (cd.isClassCompiledWithMinusG()) {
00158: // storeDataTypesWRTInvokeInst(this.behaviour,this.cd);
00159: }
00160:
00161: findSkipRangesWRTSynchronizedBlocks();
00162:
00163: setSynchBlockRangesFromSynchBlocks();
00164:
00165: }
00166:
00167: /***************************************************************************
00168: * Algo to correct the synch bug use the synchblocks sort by start for each :
00169: * get the first above monitorexist then get first not frozen monitor enter
00170: * for this..freeze this mark start as monitor enter, end as this exit
00171: *
00172: * finally in resetEndOfSynchBlockIfNecessary skip those for which monitor
00173: * exits have been frozen also.
00174: *
00175: */
00176: private void setSynchBlockRangesFromSynchBlocks() {
00177: if (sortedsynchSkips == null)
00178: return;
00179: byte code[] = behaviour.getCode();
00180: ArrayList allstarts = behaviour.getInstructionStartPositions();
00181:
00182: outerfor: for (int k = 0; k < sortedsynchSkips.size(); k++) {
00183: int astart = ((SynchSkipHelper) sortedsynchSkips.get(k)).start;
00184: int aend = ((SynchSkipHelper) sortedsynchSkips.get(k)).end;
00185: for (int from = astart - 1; from >= 0; from--) {
00186: boolean isstart = isThisInstrStart(allstarts, from);
00187: if (isstart) {
00188: int current = code[from];
00189: if (current == JvmOpCodes.MONITOREXIT) {
00190: for (int j = from - 1; j >= 0; j--) {
00191: isstart = isThisInstrStart(allstarts, j);
00192: if (isstart) {
00193: int temp = code[j];
00194: if (temp == JvmOpCodes.MONITORENTER) {
00195: if (frozenMonitorStarts
00196: .contains(new Integer(j))) {
00197: continue;
00198: } else {
00199: ExceptionTable aTable = getSynchBlockGivenStart(j);
00200: if (aTable != null) {
00201: frozenMonitorStarts
00202: .add(new Integer(j));
00203: frozenMonitorExists
00204: .add(new Integer(from));
00205: aTable.setSynchEnd(from);
00206:
00207: continue outerfor;
00208: }
00209: }
00210: }
00211: }
00212: }
00213: }
00214: }
00215:
00216: }
00217: }
00218: }
00219:
00220: private ExceptionTable getSynchBlockGivenStart(int start) {
00221: ArrayList synchtables = behaviour.getSynchronizedEntries();
00222: if (!Objects.isNullOrEmpty(synchtables)) {
00223:
00224: for (int z = 0; z < synchtables.size(); z++) {
00225:
00226: ExceptionTable table = (ExceptionTable) synchtables.get(z);
00227: if (table.getMonitorEnterPosInCode() == start) {
00228: return table;
00229: }
00230:
00231: }
00232:
00233: }
00234: return null;
00235: }
00236:
00237: public void decompileCode() {
00238:
00239: StringBuffer buffer = new StringBuffer();
00240: try {
00241: if (behaviour == null) {
00242: java.lang.String mesg = "Exception Occured while Disassembling Code\n";
00243: mesg += "The behaviour Object was null";
00244: AllExceptionHandler handler = new AllExceptionHandler(
00245: new NullPointerException(mesg));
00246: handler.reportException();
00247:
00248: } else {
00249: // Log Message
00250:
00251: java.lang.String mesg = "\n[INFO]Attempting to generate code represented By\n";
00252: mesg += "[INFO]Method Name :\t" + behaviour.getBehaviourName()
00253: + "\n";
00254: Writer writer = Writer.getWriter("log");
00255: writer.writeLog(mesg, Configuration.getLogLevel());
00256: writer.flush();
00257:
00258: // Write to ConsoleDetail file For UI....
00259:
00260: // Attempt to Dis
00261:
00262: byte[] bytecodes = behaviour.getCode();
00263:
00264: /**
00265: * NOTE:
00266: *
00267: * opcodes below represents the disassembled String for the
00268: * behaviour... This Disasembler Object has the object ref to
00269: * the behaviour passed. Since the opcode is the complete
00270: * disassembled code for this behaviour, we can go and set it
00271: * for the behaviour object using Reflection API. Later on The
00272: * code to print out the complete representation of the Class
00273: * can access the
00274: *
00275: * Reflection API to print out the class...
00276: *
00277: *
00278: */
00279:
00280: startTime = System.currentTimeMillis();
00281: if (Configuration.getDecompileroption().equalsIgnoreCase("dis")) {
00282: // disassembleJVMOpCodes(bytecodes);
00283: } else
00284: parseJVMOpCodes(bytecodes);
00285:
00286: if (this .behaviour != null) {
00287: // System.out.println(this.behaviour.getBehaviourName()+"
00288: // BEHAVIOUR NAME");
00289: // this.behaviour.setVMInstructions(opcodes);
00290: // this.behaviour.setCodeStatements(code)
00291: }
00292:
00293: }
00294:
00295: }
00296:
00297: catch (IOException ioe) {
00298: AllExceptionHandler handler = new AllExceptionHandler(ioe);
00299: handler.setBehaviour(behaviour);
00300: handler.reportException();
00301: // Just in Case Code Returns from
00302: // reportException method
00303:
00304: } catch (RuntimeException re) {
00305:
00306: AllExceptionHandler handler = new AllExceptionHandler(re,
00307: "Runtime Exception while handling storeDataTypesWRTInvokeInst");
00308: handler.setBehaviour(behaviour);
00309: handler.reportException(); // TODO: Uncomment This later
00310: ConsoleLauncher.addCouldNotFinish(behaviour);
00311: return;
00312:
00313: }
00314:
00315: }
00316:
00317: private int currentForIndex;
00318:
00319: private LocalVariableStructure structure = null;
00320:
00321: private boolean createdLocalVariableStructure;
00322:
00323: private ArrayList returnsaddedAtIfElse = null;
00324:
00325: private GeneratedIfTracker generatedIfTracker = new GeneratedIfTracker();
00326:
00327: public void parseJVMOpCodes(byte[] info) {
00328:
00329: GlobalVariableStore.setContinue_JumpOffsets(new ArrayList());
00330: GlobalVariableStore.setBreak_JumpOffsets(new ArrayList());
00331: GlobalVariableStore.setLabelAssociated(new Hashtable());
00332: GlobalVariableStore.setRetAtIfElseEnd(new Hashtable());
00333: ConsoleLauncher.setCurrentMethodBeingExecuted(this .behaviour);
00334: createdLocalVariableStructure = false; // for -g:none option
00335: GlobalVariableStore.setReturnsAtI(new HashMap());
00336:
00337: ArrayList methodTries = behaviour.getAllTriesForMethod();
00338: Operand tempOperand = null;
00339: java.lang.String tempString = "";
00340:
00341: behaviour.replaceBuffer("");
00342: int opValueI = Integer.MIN_VALUE;
00343: byte opValueB = Byte.MIN_VALUE;
00344: float opValueF = Float.MIN_VALUE;
00345: double opValueD = Double.NEGATIVE_INFINITY;
00346: long opValueL = Long.MIN_VALUE;
00347: java.lang.String errorMesg = "";
00348: IntPrimitive constInt = null;
00349: FloatPrimitive constFloat = null;
00350: DoublePrimitive constDouble = null;
00351: LongPrimitive constLong = null;
00352: ClassInfo constCInfo = null;
00353: CPString constString = null;
00354: MethodRef mref = null;
00355: FieldRef fref = null;
00356: NameAndType ninfo = null;
00357: java.lang.String stringLiteral = null;
00358:
00359: Operand op = null;
00360: Operand op1 = null;
00361: Operand op2 = null;
00362: Operand op3 = null;
00363: Operand op4 = null;
00364:
00365: IFBlock ifst = null;
00366:
00367: Behaviour b = null;
00368:
00369: java.lang.String funcCall = "";
00370:
00371: int type = -1;
00372:
00373: Hashtable methodLookUp = cd.getMethodLookUp();
00374:
00375: LocalVariableTable table = LocalVariableTable.getInstance();
00376: boolean cons = false;
00377: if (behaviour instanceof ConstructorMember) {
00378: cons = true;
00379: }
00380:
00381: structure = table
00382: .getLocaVarStructure(behaviour.getBehaviourName().concat(
00383: behaviour.getStringifiedParameters()).concat("" + cons));
00384: if (structure != null)
00385: behaviour.setMethodLocalVariables(structure);
00386: LocalVariable local = null;
00387: GlobalVariableStore.setLABELS(new Hashtable());
00388: returnsaddedAtIfElse = new ArrayList();
00389:
00390: boolean invokevirtualFound = false;
00391: ArrayList inststarts = behaviour.getInstructionStartPositions();
00392: GlobalVariableStore.setMultinewfound(false);
00393:
00394: forloop: for (int i = 0; i < info.length; i++) {
00395:
00396: currentForIndex = i;
00397:
00398: IFHelper.addGeneratedIfCode(currentForIndex, generatedIfTracker);
00399:
00400: ExecutionState.setCurrentInstructionPosition(currentForIndex);
00401:
00402: java.lang.String doWhileCloseStmt = closeDoWhile(i);
00403:
00404: java.lang.String printLater = "";
00405:
00406: boolean isStart = isThisInstrStart(inststarts, i);
00407: if (!isStart)
00408: continue;
00409:
00410: boolean skipWRTbooleanShrtAssgn = checkForSkipWRTbooleanShortcutAssignFound(i);
00411: if (skipWRTbooleanShrtAssgn)
00412: continue;
00413:
00414: boolean skipWRTPostIncr = checkForPostIncrSkip(GlobalVariableStore
00415: .getSkipsWRTPostIncr(), i);
00416: if (skipWRTPostIncr)
00417: continue;
00418:
00419: boolean skipIteration = skipIterationWRTIFSAtEndOFLoop(i, info);
00420: if (skipIteration) {
00421: behaviour.appendToBuffer(Util
00422: .formatDecompiledStatement(doWhileCloseStmt));
00423:
00424: continue;
00425: }
00426:
00427: StringBuffer resetPos = new StringBuffer("");
00428:
00429: resetEndOfSynchBlockIfNecessary(i);
00430:
00431: boolean avoidskip = false;
00432:
00433: boolean skip = false;
00434:
00435: if (!avoidskip)
00436: skip = skipCurrentIteraton(i, false, info);
00437: if (!skip && !avoidskip) {
00438: skip = checkWRTClassLoadIF(i);
00439: }
00440: ArrayList starts = behaviour.getInstructionStartPositions();
00441: if (skip
00442: && (info[i] == JvmOpCodes.DUP || info[i] == JvmOpCodes.DUP2)
00443: && isThisInstrStart(starts, i)) {
00444: GlobalVariableStore.setDupnothandled(true);
00445: }
00446:
00447: if (skip && Configuration.getDecompileroption().equals("dc")
00448: && !avoidskip) {
00449: continue;
00450: }
00451:
00452: try {
00453:
00454: boolean needtoresetelsehasbugun = false;
00455:
00456: int prevstart = getPrevStartCodePos(info, i);
00457:
00458: StringBuffer ifelsecode = new StringBuffer("");
00459: StringBuffer reset = new StringBuffer("");
00460: boolean oktoendifelse = isItoktoendifelse(i);
00461: if (oktoendifelse) {
00462: checkForIFElseEndStatement(info, behaviour.getMethodIfs(),
00463: i, reset, opStack, ifelsecode, "if");
00464: }
00465: boolean ifbeforeclashedhandler = TryHelper
00466: .doesClashedIfWithExceptionHandlerStartBefore(i);
00467: if (!ifbeforeclashedhandler)
00468: behaviour.appendToBuffer(ifelsecode.toString());
00469:
00470: if (doWhileCloseStmt.trim().length() > 0) {
00471: IFinder finder = FinderFactory.getFinder(IFinder.BASE);
00472: int prev = finder.getPrevStartOfInst(currentForIndex);
00473: if (prev > 0) {
00474: finder = FinderFactory.getFinder(IFinder.BRANCH);
00475: boolean isif = finder.isInstructionIF(prev);
00476: if (isif) {
00477: IFBlock aif = IFHelper.getIfGivenStart(prev);
00478: if (aif.getIfStart() == aif.getIfCloseLineNumber()) {
00479: if (aif.IfHasBeenClosed()) {
00480: String ifendstmt = "\nbreak;\n}\n";
00481: ifendstmt = Util
00482: .formatDecompiledStatement(ifendstmt);
00483: behaviour.appendToBuffer(ifendstmt);
00484: }
00485: }
00486: }
00487: }
00488: }
00489: behaviour.appendToBuffer(Util
00490: .formatDecompiledStatement(doWhileCloseStmt));
00491:
00492: java.lang.String brlbl = getAnyLabelAtI(GlobalVariableStore
00493: .getLABELS(), i);
00494:
00495: if (brlbl != null && brlbl.trim().length() > 0) {
00496: behaviour.appendToBuffer("\n" + brlbl + ":\n");
00497: } else {
00498: behaviour.appendToBuffer("\n" + "#FORINDEX" + i + "#"
00499: + "\n");
00500: }
00501:
00502: int instructionAtI = info[i];
00503: boolean skipexcp = skipExceptionTables(i);
00504: java.lang.String fromExceptionTable = "";
00505: if (!skipexcp)
00506: fromExceptionTable = pollExcepionTables(i, instructionAtI);
00507:
00508: boolean end = isIEndOfGuard(i, behaviour);
00509: boolean returnadded = false;
00510: int returnposincode = -1;
00511: if (end) {
00512: StringBuffer sb = new StringBuffer("");
00513: java.lang.String returnString = isAnyReturnPresentInSkipRegion(
00514: info, i, behaviour, sb);
00515: java.lang.String str = sb.toString();
00516: try {
00517: returnposincode = Integer.parseInt(str);
00518: } catch (NumberFormatException ne) {
00519: }
00520:
00521: if (returnString != null
00522: && returnString.trim().length() == 0) {
00523: if (i == (info.length - 1)) {
00524: returnString = getReturnTypeInst(info, i);
00525: returnposincode = i;
00526:
00527: }
00528: }
00529: java.lang.Object val = null;
00530:
00531: if (returnString != null
00532: && returnString.trim().length() > 0) {
00533: int loadIndex = -1;
00534: StringBuffer stb = new StringBuffer("");
00535: if (returnposincode != -1)
00536: loadIndex = getLoadIndexForReturn(info,
00537: returnposincode, stb);
00538: if (loadIndex != -1) {
00539: LocalVariableStructure struck = behaviour
00540: .getLocalVariables();
00541: int rangeinx = Integer.parseInt(stb.toString());
00542: if (rangeinx != -1) {
00543: if (cd.isClassCompiledWithMinusG()) {
00544: LocalVariable temp = struck
00545: .getVariabelAtIndex(loadIndex,
00546: rangeinx);
00547: if (temp != null) {
00548: op = new Operand();
00549: op.setOperandValue(temp.getVarName());
00550: op.setOperandName(temp.getVarName());
00551: opStack.push(op);
00552: }
00553:
00554: } else {
00555: LocalVariable temp = struck
00556: .getVariabelAtIndex(loadIndex);
00557: if (temp != null) {
00558: op = new Operand();
00559: op.setOperandValue(temp.getVarName());
00560: op.setOperandName(temp.getVarName());
00561: opStack.push(op);
00562: }
00563: }
00564: }
00565: }
00566: int returnPos = getReturnStringPosInCode(info, i,
00567: behaviour);
00568: if (returnString.equals("return") == false
00569: && opStack.size() > 0) {
00570: // StackTop=opStack.peekTopOfStack();
00571: Operand StackTop = opStack.getTopOfStack();
00572: if (StackTop != null) {
00573: val = StackTop.getOperandValue();
00574: if (val != null)
00575: val = val.toString();
00576: }
00577: if (StackTop != null) {
00578:
00579: if (val != null)
00580: tempString = "return " + val;
00581: else
00582: tempString = "return ";
00583: behaviour.appendToBuffer(Util
00584: .formatDecompiledStatement(tempString));
00585:
00586: returnadded = true;
00587: }
00588:
00589: } else if (returnString.equals("return") == true) {
00590: int prev = currentForIndex - 1;
00591: boolean oktoadd = true;
00592: if (isThisInstrStart(behaviour
00593: .getInstructionStartPositions(), prev)) {
00594: if (info[prev] == JvmOpCodes.ATHROW) {
00595: oktoadd = false;
00596: }
00597: }
00598: if (oktoadd) {
00599: tempString = "return ";
00600: behaviour.appendToBuffer(Util
00601: .formatDecompiledStatement(tempString));
00602:
00603: returnadded = true;
00604: }
00605: }
00606: if (returnadded) {
00607: if (returnPos != -1) {
00608: GlobalVariableStore.getReturnsAtI().put(
00609: new Integer(returnPos), "true");
00610: } else {
00611: GlobalVariableStore.getReturnsAtI().put(
00612: new Integer(i), "true");
00613: }
00614: }
00615:
00616: }
00617:
00618: }
00619:
00620: if (returnadded)
00621: behaviour.appendToBuffer(";\n");
00622: if (fromExceptionTable.indexOf("finally") != -1)
00623: fromExceptionTable = fromExceptionTable + " ";
00624:
00625: else
00626: fromExceptionTable = fromExceptionTable;
00627: tempString = fromExceptionTable;
00628:
00629: java.lang.String printExceptionTable = "";
00630: if (tempString != null && tempString.length() > 0)
00631: printExceptionTable = tempString;
00632:
00633: Iterator loopIterator = behaviour.getBehaviourLoops()
00634: .iterator();
00635: while (loopIterator.hasNext()) {
00636: Loop iloop = (Loop) loopIterator.next();
00637: if (iloop.getStartIndex() == i && iloop.isInfinite()) {
00638: boolean clash = doesthis ClashWithCaseBegin(behaviour
00639: .getAllSwitchBlks(), i);
00640: boolean loopsEndAtIf = doesLoopHaveAnIfAtEnd(i, info,
00641: iloop);
00642: if (clash) {
00643: if (iloop.printloopStart()) {
00644: printLater = "while(true)\n{\n"; // :CHECK
00645: if (iloop.isDoWhile()) {
00646: Util.forceTrimLines = false;
00647: printLater = Util
00648: .formatDecompiledStatement("while(true)\n{\n");
00649: printLater += "//INSERT IFCODE FOR DOWHILE HERE"
00650: + iloop.getStartIndex() + "\n";
00651: GlobalVariableStore.getDowhileloopmarkers()
00652: .add(
00653: new Integer(iloop
00654: .getStartIndex()));
00655: Util.forceTrimLines = true;
00656: }
00657:
00658: iloop.setPrintloopStart(false);
00659: }
00660: if (loopsEndAtIf) {
00661: java.lang.String loopendbody = anyWhileBodyHere(
00662: iloop.getEndIndex(), iloop, opStack);
00663: if (loopendbody.trim().length() > 0) {
00664:
00665: printLater += loopendbody;
00666:
00667: }
00668: }
00669:
00670: }
00671: if (!clash) {
00672: if (iloop.printloopStart()) {
00673: int after = isLoopAfterTry(iloop.getEndIndex());
00674: if (after == 0) {
00675: tempString = fromExceptionTable;
00676: behaviour
00677: .appendToBuffer(Util
00678: .formatDecompiledStatement(tempString));
00679: tempString = "while(true)\n{\n";
00680: if (iloop.isDoWhile()) {
00681: Util.forceTrimLines = false;
00682: tempString = Util
00683: .formatDecompiledStatement("while(true)\n{\n");
00684: tempString += "//INSERT IFCODE FOR DOWHILE HERE"
00685: + iloop.getStartIndex() + "\n";
00686: GlobalVariableStore
00687: .getDowhileloopmarkers()
00688: .add(
00689: new Integer(
00690: iloop
00691: .getStartIndex()));
00692: Util.forceTrimLines = true;
00693: }
00694: behaviour
00695: .appendToBuffer(Util
00696: .formatDecompiledStatement(tempString));
00697: fromExceptionTable = "";
00698: } else if (after == 1) {
00699: tempString = "while(true)\n{\n";
00700: if (iloop.isDoWhile()) {
00701: Util.forceTrimLines = false;
00702: tempString = Util
00703: .formatDecompiledStatement("while(true)\n{\n");
00704: tempString += "//INSERT IFCODE FOR DOWHILE HERE"
00705: + iloop.getStartIndex() + "\n";
00706: Util.forceTrimLines = true;
00707: GlobalVariableStore
00708: .getDowhileloopmarkers()
00709: .add(
00710: new Integer(
00711: iloop
00712: .getStartIndex()));
00713: }
00714: behaviour
00715: .appendToBuffer(Util
00716: .formatDecompiledStatement(tempString));
00717: behaviour
00718: .appendToBuffer(Util
00719: .formatDecompiledStatement(fromExceptionTable));
00720:
00721: fromExceptionTable = "";
00722: } else if (after == 2) {
00723: tempString = "while(true)\n{\n";//
00724: if (iloop.isDoWhile()) {
00725: Util.forceTrimLines = false;
00726: tempString = Util
00727: .formatDecompiledStatement("while(true)\n{\n");
00728: tempString += "//INSERT IFCODE FOR DOWHILE HERE"
00729: + iloop.getStartIndex() + "\n";
00730: Util.forceTrimLines = true;
00731: GlobalVariableStore
00732: .getDowhileloopmarkers()
00733: .add(
00734: new Integer(
00735: iloop
00736: .getStartIndex()));
00737: }
00738: behaviour
00739: .appendToBuffer(Util
00740: .formatDecompiledStatement(tempString));
00741: }
00742:
00743: iloop.setPrintloopStart(false);
00744: }
00745:
00746: printLater = "";
00747: if (loopsEndAtIf) {
00748: java.lang.String loopendbody = anyWhileBodyHere(
00749: iloop.getEndIndex(), iloop, opStack);
00750: if (loopendbody.trim().length() > 0) {
00751:
00752: behaviour
00753: .appendToBuffer(Util
00754: .formatDecompiledStatement(loopendbody));
00755: iloop.setPrintloopStart(false);
00756: }
00757: }
00758: }
00759: } else {
00760: boolean dowhile = checkForDoWhile(currentForIndex,
00761: info, iloop);
00762: if (dowhile == false) {
00763: if (iloop.getEndIndex() == i) {
00764: tempString = "";// anyWhileBodyHere(i,iloop,opStack);
00765: if (tempString.trim().length() > 0) {
00766: tempString = tempString + "}\n";
00767: iloop.setWasLoopClosedInCode(true);
00768: i = i + 2;
00769: behaviour
00770: .appendToBuffer(Util
00771: .formatDecompiledStatement(tempString)); // TODO:
00772: // BUg
00773: // in
00774: // formatting
00775: continue forloop;
00776: } else {
00777: if (iloop.wasLoopClosedInCode() == false) {
00778: tempString = "}\n"; // le
00779: behaviour
00780: .appendToBuffer(Util
00781: .formatDecompiledStatement(tempString));
00782: iloop.setWasLoopClosedInCode(true);
00783: }
00784: }
00785: } else if (iloop.getLoopEndForBracket() == i
00786: && iloop.wasLoopClosedInCode() == false) {
00787:
00788: tempString = "}\n";// \n"; // Loop End
00789: behaviour.appendToBuffer(Util
00790: .formatDecompiledStatement(tempString));
00791: iloop.setWasLoopClosedInCode(true);
00792: }
00793: }
00794:
00795: // Check wrt loopendduetoreset
00796: if (iloop.getLoopendDueToReset() == i) {
00797: if (iloop.wasLoopClosedInCode() == false) {
00798: tempString = "}\n";
00799: behaviour.appendToBuffer(Util
00800: .formatDecompiledStatement(tempString));
00801: iloop.setWasLoopClosedInCode(true);
00802: }
00803: }
00804:
00805: }
00806:
00807: }
00808:
00809: java.lang.String switchStmt = pollSwitchBlksForMethod(i, info);
00810:
00811: if (casefound) {
00812:
00813: behaviour.appendToBuffer(switchStmt);
00814: behaviour
00815: .appendToBuffer(((switchStmt.trim().length() == 0) ? ""
00816: : "\n"));
00817: behaviour.appendToBuffer(Util
00818: .formatDecompiledStatement(fromExceptionTable));
00819: behaviour.appendToBuffer(((fromExceptionTable.trim()
00820: .length() == 0) ? "" : "\n"));
00821: } else {
00822: Util.forceTrimLines = true;
00823: behaviour.appendToBuffer(Util
00824: .formatDecompiledStatement(fromExceptionTable));
00825: behaviour.appendToBuffer(((fromExceptionTable.trim()
00826: .length() == 0) ? "" : "\n"));
00827: behaviour.appendToBuffer(switchStmt);
00828: behaviour
00829: .appendToBuffer(((switchStmt.trim().length() == 0) ? ""
00830: : "\n"));
00831:
00832: if (ifbeforeclashedhandler) {
00833: if (ifelsecode.toString().startsWith(" ")) {
00834: ifelsecode = new StringBuffer(ifelsecode.toString()
00835: .substring(1));
00836: }
00837: if (ifelsecode.toString().startsWith(" ")) {
00838: ifelsecode = new StringBuffer(ifelsecode.toString()
00839: .substring(1));
00840: }
00841: if (ifelsecode.toString().startsWith(" ")) {
00842: ifelsecode = new StringBuffer(ifelsecode.toString()
00843: .substring(1));
00844: }
00845: if (ifelsecode.toString().startsWith(" ")) {
00846: ifelsecode = new StringBuffer(ifelsecode.toString()
00847: .substring(1));
00848: }
00849: behaviour.appendToBuffer("\n" + ifelsecode.toString());
00850: // Util .updateCurrentSpace(Util.getIncrementSpace(),
00851: // "add");
00852: }
00853: Util.forceTrimLines = true;
00854: }
00855:
00856: // OK in all cases?
00857:
00858: // NOTE: printLater should only be used for while statement .
00859: // ...Not For anything else
00860:
00861: if (printLater.trim().length() > 0) {
00862: behaviour.appendToBuffer(Util
00863: .formatDecompiledStatement(printLater));
00864: printLater = "";
00865:
00866: }
00867:
00868: java.lang.String synch = pollsynchblocks(i);
00869: behaviour.appendToBuffer(Util.formatDecompiledStatement(synch));
00870:
00871: skip = skipCurrentIteraton(i, true, info);
00872: if (skip
00873: && (info[i] == JvmOpCodes.DUP || info[i] == JvmOpCodes.DUP2)
00874: && isThisInstrStart(starts, i)) {
00875: GlobalVariableStore.setDupnothandled(true);
00876: }
00877:
00878: if (skip && !avoidskip)
00879: continue;
00880: GlobalVariableStore.setThisLoop(null);
00881:
00882: skip = skipIterationIf_IFEndOfloop(i, info);
00883: if (skip && !avoidskip) {
00884: i = i + 2;
00885: continue;
00886: }
00887:
00888: int skipBytes;
00889:
00890: if (isInstructionIF(info[currentForIndex])) {
00891: int loopBeginForIf = IFHelper
00892: .attachMarkerToIfInDoWhileKindOfLoop(currentForIndex);
00893: if (loopBeginForIf != -1) {
00894: if (GlobalVariableStore.getDowhileloopmarkers() != null
00895: && GlobalVariableStore.getDowhileloopmarkers()
00896: .contains(new Integer(loopBeginForIf)))
00897: behaviour.appendToBuffer("\n<IF_AT_LOOP_END_BEGIN_"
00898: + loopBeginForIf + "_>\n");
00899:
00900: }
00901: }
00902:
00903: switch (info[i]) {
00904: case JvmOpCodes.AALOAD:
00905: skipBytes = handleAALOAD(opStack);
00906: i = i + skipBytes;
00907: continue;
00908: case JvmOpCodes.AASTORE:
00909: skipBytes = handleAASTORECase();
00910: i = i + skipBytes;
00911: continue;
00912: case JvmOpCodes.ACONST_NULL:
00913: skipBytes = handleACONSTNULL();
00914: i = i + skipBytes;
00915: continue;
00916: case JvmOpCodes.ALOAD:
00917: skipBytes = handleAloadCase(info, i, opStack);
00918: i = i + skipBytes;
00919: continue;
00920:
00921: case JvmOpCodes.ALOAD_0:
00922:
00923: skipBytes = handlesimpleaload(0);
00924: i = i + skipBytes;
00925:
00926: continue;
00927: case JvmOpCodes.ALOAD_1:
00928:
00929: skipBytes = handlesimpleaload(1);
00930: i = i + skipBytes;
00931: continue;
00932: case JvmOpCodes.ALOAD_2:
00933:
00934: skipBytes = handlesimpleaload(2);
00935: i = i + skipBytes;
00936: continue;
00937: case JvmOpCodes.ALOAD_3:
00938: skipBytes = handlesimpleaload(3);
00939: i = i + skipBytes;
00940: continue;
00941:
00942: case JvmOpCodes.ANEWARRAY:
00943:
00944: skipBytes = handleANEWARRAYCase(info);
00945: i = i + skipBytes;
00946: continue;
00947: case JvmOpCodes.ARETURN:
00948:
00949: skipBytes = handleARETURNCase(currentForIndex,
00950: GlobalVariableStore.getReturnsAtI());
00951: i = i + skipBytes;
00952: continue;
00953: case JvmOpCodes.ARRAYLENGTH:
00954: skipBytes = handleARRAYLENGTHCase();
00955: i = i + skipBytes;
00956: continue;
00957: case JvmOpCodes.ASTORE:
00958: skipBytes = handleComplexAStore(info, i);
00959: i = i + skipBytes;
00960:
00961: continue;
00962: case JvmOpCodes.ASTORE_0:
00963: skipBytes = handleSimpleASTORECase(i, 0);
00964: i = i + skipBytes;
00965: continue;
00966: case JvmOpCodes.ASTORE_1:
00967:
00968: skipBytes = handleSimpleASTORECase(i, 1);
00969: i = i + skipBytes;
00970: continue;
00971: case JvmOpCodes.ASTORE_2:
00972: skipBytes = handleSimpleASTORECase(i, 2);
00973: i = i + skipBytes;
00974: continue;
00975: case JvmOpCodes.ASTORE_3:
00976: skipBytes = handleSimpleASTORECase(i, 3);
00977: i = i + skipBytes;
00978: continue;
00979: case JvmOpCodes.ATHROW:
00980:
00981: skipBytes = handleATHROW(info);
00982: i = i + skipBytes;
00983: continue;
00984:
00985: // LETTER B
00986: case JvmOpCodes.BALOAD:
00987:
00988: skipBytes = handleBALOAD(opStack);
00989: i = i + skipBytes;
00990: continue;
00991: case JvmOpCodes.BASTORE:
00992: skipBytes = handleBASTORE(opStack);
00993: i = i + skipBytes;
00994: continue;
00995: case JvmOpCodes.BIPUSH:
00996: skipBytes = handleBIPush(info);
00997: i = i + skipBytes;
00998:
00999: continue;
01000:
01001: // LETTER C
01002: case JvmOpCodes.CALOAD:
01003: skipBytes = handleCALOAD(opStack);
01004: i = i + skipBytes;
01005: continue;
01006: case JvmOpCodes.CASTORE:
01007:
01008: skipBytes = handleCASTORE(opStack);
01009: i = i + skipBytes;
01010: continue;
01011: case JvmOpCodes.CHECKCAST:
01012:
01013: handleCheckCast(opStack, info);
01014: i = i + 2;
01015: continue;
01016:
01017: // LETTER D
01018: case JvmOpCodes.D2F:
01019: skipBytes = handleD2F();
01020: i = i + skipBytes;
01021: continue;
01022: case JvmOpCodes.D2I:
01023: skipBytes = handleD2I();
01024: i = i + skipBytes;
01025: continue;
01026: case JvmOpCodes.D2L:
01027: skipBytes = handleD2L();
01028: i = i + skipBytes;
01029: continue;
01030: case JvmOpCodes.DADD:
01031: skipBytes = handleDADD();
01032: i = i + skipBytes;
01033: continue;
01034: case JvmOpCodes.DALOAD:
01035:
01036: skipBytes = handleDALOAD(opStack);
01037: i = i + skipBytes;
01038: continue;
01039: case JvmOpCodes.DASTORE:
01040: skipBytes = handleDASTORE(opStack);
01041: i = i + skipBytes;
01042: continue;
01043: case JvmOpCodes.DCMPG:
01044: skipBytes = handleDCMPG(opStack, info);
01045: i = i + skipBytes;
01046: continue;
01047: case JvmOpCodes.DCMPL:
01048: skipBytes = handleDCMPL(opStack, info);
01049: i = i + skipBytes;
01050: continue;
01051: case JvmOpCodes.DCONST_0:
01052: handleDCONST(opStack, 0.0);
01053:
01054: continue;
01055: case JvmOpCodes.DCONST_1:
01056: handleDCONST(opStack, 1.0);
01057:
01058: continue;
01059:
01060: case JvmOpCodes.DDIV:
01061: handleDDIV(opStack);
01062:
01063: continue;
01064: case JvmOpCodes.DLOAD:
01065:
01066: skipBytes = handleDLOADCase(JvmOpCodes.DLOAD);
01067: i = i + skipBytes;
01068: continue;
01069: case JvmOpCodes.DLOAD_0:
01070:
01071: handleDLOADCase(JvmOpCodes.DLOAD_0);
01072:
01073: continue;
01074: case JvmOpCodes.DLOAD_1:
01075:
01076: handleDLOADCase(JvmOpCodes.DLOAD_1);
01077:
01078: continue;
01079: case JvmOpCodes.DLOAD_2:
01080:
01081: handleDLOADCase(JvmOpCodes.DLOAD_2);
01082:
01083: continue;
01084: case JvmOpCodes.DLOAD_3:
01085:
01086: handleDLOADCase(JvmOpCodes.DLOAD_3);
01087:
01088: continue;
01089: case JvmOpCodes.DMUL:
01090: handleDMUL(opStack);
01091:
01092: continue;
01093: case JvmOpCodes.DNEG:
01094: handleDNEG(opStack);
01095:
01096: continue;
01097: case JvmOpCodes.DREM:
01098: handleDREM(opStack);
01099:
01100: continue;
01101: case JvmOpCodes.DRETURN:
01102: handleDRETURN(info);
01103:
01104: // behaviour.getParentBehaviour().getOpStack().push(op);
01105: /*
01106: * parsedString += "DRETURN"; parsedString+="\n";
01107: * parsedString+="\t";parsedString+="\t";
01108: */
01109: continue;
01110: case JvmOpCodes.DSTORE:
01111:
01112: skipBytes = handleComplexDStore();
01113: i = i + skipBytes;
01114:
01115: continue;
01116: case JvmOpCodes.DSTORE_0:
01117:
01118: handleSimpleDstoreCaseInst(JvmOpCodes.DSTORE_0);
01119:
01120: continue;
01121: case JvmOpCodes.DSTORE_1:
01122:
01123: handleSimpleDstoreCaseInst(JvmOpCodes.DSTORE_1);
01124:
01125: continue;
01126: case JvmOpCodes.DSTORE_2:
01127:
01128: handleSimpleDstoreCaseInst(JvmOpCodes.DSTORE_2);
01129:
01130: continue;
01131: case JvmOpCodes.DSTORE_3:
01132:
01133: handleSimpleDstoreCaseInst(JvmOpCodes.DSTORE_3);
01134:
01135: continue;
01136: case JvmOpCodes.DSUB:
01137: handleDSUB();
01138:
01139: continue;
01140: case JvmOpCodes.DUP:
01141: handleDUP(opStack);
01142:
01143: continue;
01144: case JvmOpCodes.DUP_X1:
01145: handleDUPX1(opStack);
01146: continue;
01147: case JvmOpCodes.DUP_X2:
01148: handleDUPX2();
01149: continue;
01150: case JvmOpCodes.DUP2:
01151: handleDUP2(opStack);
01152:
01153: continue;
01154: case JvmOpCodes.DUP2_X1:
01155: handleDUP2X1(opStack);
01156: continue;
01157: case JvmOpCodes.DUP2_X2:
01158: handleDUP2X2(opStack);
01159:
01160: continue;
01161:
01162: // LETTER F
01163: case JvmOpCodes.F2D:
01164: handleF2D();
01165:
01166: continue;
01167: case JvmOpCodes.F2I:
01168: handleF2I();
01169: continue;
01170: case JvmOpCodes.F2L:
01171: handleF2L();
01172: continue;
01173: case JvmOpCodes.FADD:
01174: handleFADD();
01175:
01176: continue;
01177: case JvmOpCodes.FALOAD:
01178:
01179: handleFALOAD();
01180: continue;
01181: case JvmOpCodes.FASTORE:
01182:
01183: handleFASTORE();
01184:
01185: continue;
01186: case JvmOpCodes.FCMPG:
01187: handleFCMPG(opStack, info);
01188: continue;
01189: case JvmOpCodes.FCMPL:
01190: handleFCMPL(opStack, info);
01191: continue;
01192: case JvmOpCodes.FCONST_0:
01193: handleFCONST(opStack, "0.0f");
01194:
01195: continue;
01196: case JvmOpCodes.FCONST_1:
01197: handleFCONST(opStack, "1.0f");
01198: continue;
01199: case JvmOpCodes.FCONST_2:
01200: handleFCONST(opStack, "2.0f");
01201: continue;
01202: case JvmOpCodes.FDIV:
01203: handleFDIV(opStack);
01204:
01205: continue;
01206: case JvmOpCodes.FLOAD:
01207:
01208: skipBytes = handleFLOAD(JvmOpCodes.FLOAD);
01209: i = i + skipBytes;
01210: continue;
01211: case JvmOpCodes.FLOAD_0:
01212:
01213: handleFLOAD(JvmOpCodes.FLOAD_0);
01214:
01215: continue;
01216: case JvmOpCodes.FLOAD_1:
01217:
01218: handleFLOAD(JvmOpCodes.FLOAD_1);
01219:
01220: // opStack.push(element);
01221: continue;
01222: case JvmOpCodes.FLOAD_2:
01223: handleFLOAD(JvmOpCodes.FLOAD_2);
01224:
01225: // opStack.push(element);
01226: continue;
01227: case JvmOpCodes.FLOAD_3:
01228:
01229: handleFLOAD(JvmOpCodes.FLOAD_3);
01230:
01231: // opStack.push(element);
01232: continue;
01233: case JvmOpCodes.FMUL:
01234: handleFMUL();
01235:
01236: continue;
01237: case JvmOpCodes.FNEG:
01238: handleFNEG();
01239: continue;
01240: case JvmOpCodes.FREM:
01241: handleFREM();
01242: continue;
01243: case JvmOpCodes.FRETURN:
01244: handleFRETURN();
01245:
01246: continue;
01247: case JvmOpCodes.FSTORE:
01248:
01249: skipBytes = handleComplexFSTORE();
01250: i = i + skipBytes;
01251: continue;
01252: case JvmOpCodes.FSTORE_0:
01253:
01254: handleSimpleFstoreCaseInst(opStack, info, 0);
01255:
01256: continue;
01257: case JvmOpCodes.FSTORE_1:
01258:
01259: handleSimpleFstoreCaseInst(opStack, info, 1);
01260:
01261: continue;
01262:
01263: case JvmOpCodes.FSTORE_2:
01264:
01265: handleSimpleFstoreCaseInst(opStack, info, 2);
01266:
01267: continue;
01268: case JvmOpCodes.FSTORE_3:
01269:
01270: handleSimpleFstoreCaseInst(opStack, info, 3);
01271:
01272: continue;
01273: case JvmOpCodes.FSUB:
01274: handleFSUB();
01275:
01276: continue;
01277:
01278: // LETTER G
01279: case JvmOpCodes.GETFIELD: // TODO: check whether this needs to
01280: // push classtype intp stack
01281:
01282: skipBytes = handleGetField(info);
01283:
01284: i += skipBytes;
01285:
01286: continue;
01287: case JvmOpCodes.GETSTATIC:
01288:
01289: skipBytes = handleGetStatic();
01290: i = i + skipBytes;
01291:
01292: continue;
01293: case JvmOpCodes.GOTO: // Mistake here. GOTO of switch not
01294:
01295: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01296: JvmOpCodes.GOTO);
01297: i = i + skipBytes;
01298: continue;
01299: case JvmOpCodes.GOTO_W: // TODO Need to do Test vigorously and
01300: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01301: JvmOpCodes.GOTO_W);
01302: i = i + skipBytes;
01303:
01304: // LETTER I
01305: case JvmOpCodes.I2B:
01306: handleI2B();
01307: continue;
01308: case JvmOpCodes.I2C:
01309: handleI2C();
01310:
01311: continue;
01312: case JvmOpCodes.I2D:
01313: handleI2D();
01314: continue;
01315: case JvmOpCodes.I2F:
01316: handleI2F();
01317: continue;
01318: case JvmOpCodes.I2L:
01319: handleI2L();
01320: continue;
01321: case JvmOpCodes.I2S:
01322: handleI2S();
01323: continue;
01324: case JvmOpCodes.IADD:
01325: handleIADD();
01326: continue;
01327: case JvmOpCodes.IALOAD:
01328: handleIALOAD();
01329:
01330: continue;
01331: case JvmOpCodes.IAND:
01332: handleIAND();
01333: continue;
01334: case JvmOpCodes.IASTORE:
01335:
01336: handleIASTORE();
01337:
01338: continue;
01339: case JvmOpCodes.ICONST_0:
01340: handleICONST(0);
01341: continue;
01342: case JvmOpCodes.ICONST_1:
01343: handleICONST(1);
01344: continue;
01345: case JvmOpCodes.ICONST_2:
01346: handleICONST(2);
01347: continue;
01348: case JvmOpCodes.ICONST_3:
01349: handleICONST(3);
01350: continue;
01351: case JvmOpCodes.ICONST_4:
01352: handleICONST(4);
01353: continue;
01354: case JvmOpCodes.ICONST_5:
01355: handleICONST(5);
01356: continue;
01357: case JvmOpCodes.ICONST_M1:
01358: handleICONST(-1);
01359: continue;
01360: case JvmOpCodes.IDIV:
01361: handleIDIV();
01362: continue;
01363: case JvmOpCodes.IF_ACMPEQ:
01364: skipBytes = handleIFACMPEQ(info);
01365:
01366: i = i + skipBytes;
01367:
01368: continue;
01369: case JvmOpCodes.IF_ACMPNE:
01370: handleIFACMPNE(info);
01371: i++;
01372: i++;
01373: continue;
01374: case JvmOpCodes.IF_ICMPEQ:
01375: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01376: JvmOpCodes.IF_ICMPEQ);
01377: i = i + skipBytes;
01378: continue;
01379:
01380: case JvmOpCodes.IF_ICMPNE:
01381: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01382: JvmOpCodes.IF_ICMPNE);
01383: i = i + skipBytes;
01384: continue;
01385:
01386: case JvmOpCodes.IF_ICMPLT:
01387:
01388: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01389: JvmOpCodes.IF_ICMPLT);
01390: i = i + skipBytes;
01391: continue;
01392: case JvmOpCodes.IF_ICMPGE:
01393: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01394: JvmOpCodes.IF_ICMPGE);
01395: i = i + skipBytes;
01396: continue;
01397: case JvmOpCodes.IF_ICMPGT:
01398: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01399: JvmOpCodes.IF_ICMPGT);
01400: i = i + skipBytes;
01401: continue;
01402: case JvmOpCodes.IF_ICMPLE:
01403: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01404: JvmOpCodes.IF_ICMPLE);
01405: i = i + skipBytes;
01406: continue;
01407: case JvmOpCodes.IFEQ:
01408: handleIFEQ(info);
01409: i += 2;
01410: continue;
01411: case JvmOpCodes.IFNE:
01412: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01413: JvmOpCodes.IFNE);
01414: i += 2;
01415: continue;
01416: case JvmOpCodes.IFLT:
01417: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01418: JvmOpCodes.IFLT);
01419: i += 2;
01420: continue;
01421: case JvmOpCodes.IFGE:
01422: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01423: JvmOpCodes.IFGE);
01424: i += 2;
01425: continue;
01426: case JvmOpCodes.IFGT:
01427: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01428: JvmOpCodes.IFGT);
01429: i += 2;
01430: continue;
01431: case JvmOpCodes.IFLE:
01432: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01433: JvmOpCodes.IFLE);
01434: i += 2;
01435: continue;
01436: case JvmOpCodes.IFNONNULL:
01437: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01438: JvmOpCodes.IFNONNULL);
01439: i += 2;
01440:
01441: continue;
01442: case JvmOpCodes.IFNULL:
01443: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01444: JvmOpCodes.IFNULL);
01445: i += 2;
01446: continue;
01447: case JvmOpCodes.IINC:
01448: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01449: JvmOpCodes.IINC);
01450: i += 2;
01451: continue;
01452: case JvmOpCodes.ILOAD:
01453:
01454: skipBytes = handleComplexIload();
01455: i = i + skipBytes;
01456:
01457: continue;
01458: case JvmOpCodes.ILOAD_0:
01459:
01460: handleSimpleILoad(0, info);
01461:
01462: continue;
01463: case JvmOpCodes.ILOAD_1:
01464:
01465: handleSimpleILoad(1, info);
01466:
01467: continue;
01468: case JvmOpCodes.ILOAD_2:
01469:
01470: handleSimpleILoad(2, info);
01471:
01472: continue;
01473: case JvmOpCodes.ILOAD_3:
01474:
01475: handleSimpleILoad(3, info);
01476:
01477: continue;
01478: case JvmOpCodes.IMUL:
01479:
01480: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01481: JvmOpCodes.IMUL);
01482:
01483: continue;
01484: case JvmOpCodes.INEG:
01485: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01486: JvmOpCodes.INEG);
01487: continue;
01488: case JvmOpCodes.INSTANCEOF:
01489:
01490: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01491: JvmOpCodes.INSTANCEOF);
01492: i += 2;
01493: continue;
01494: case JvmOpCodes.INVOKEINTERFACE:
01495:
01496: skipBytes = execute(InstrConstants.METHOD_INSTR_TYPE, null,
01497: JvmOpCodes.INVOKEINTERFACE);
01498: i = i + skipBytes;
01499: continue;
01500: case JvmOpCodes.INVOKESPECIAL:
01501:
01502: // TODO:
01503: /***********************************************************
01504: * 1>check when result has to be pushed and when just
01505: * printed and when both 2>In case of method calls and b is
01506: * not null check whether this has to be added or super (no
01507: * other case possible ? ) 3> Need to handle new instruction
01508: * properly
01509: */
01510: skipBytes = execute(InstrConstants.METHOD_INSTR_TYPE, null,
01511: JvmOpCodes.INVOKESPECIAL);
01512: i = i + skipBytes;
01513:
01514: continue;
01515:
01516: case JvmOpCodes.INVOKESTATIC:
01517: skipBytes = execute(InstrConstants.METHOD_INSTR_TYPE, null,
01518: JvmOpCodes.INVOKESTATIC);
01519: i = i + skipBytes;
01520:
01521: continue;
01522: case JvmOpCodes.INVOKEVIRTUAL:
01523: skipBytes = execute(InstrConstants.METHOD_INSTR_TYPE, null,
01524: JvmOpCodes.INVOKEVIRTUAL);
01525: i = i + skipBytes;
01526:
01527: continue;
01528: case JvmOpCodes.IOR:
01529: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01530: JvmOpCodes.IOR);
01531:
01532: continue;
01533: case JvmOpCodes.IREM:
01534:
01535: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01536: JvmOpCodes.IREM);
01537:
01538: continue;
01539: case JvmOpCodes.IRETURN:
01540: handleIRETURN();
01541: // behaviour.getParentBehaviour().getOpStack().push(op);
01542: continue;
01543: case JvmOpCodes.ISHL:
01544:
01545: handleISHL(opStack);
01546: continue;
01547: case JvmOpCodes.ISHR:
01548:
01549: handleISHR(opStack);
01550:
01551: continue;
01552: case JvmOpCodes.ISTORE:
01553:
01554: skipBytes = handleISTORE(JvmOpCodes.ISTORE);
01555: i = i + skipBytes;
01556: continue;
01557: case JvmOpCodes.ISTORE_0:
01558:
01559: handleISTORE(JvmOpCodes.ISTORE_0);
01560: // Store the op.getOperandValue() in the local Variable;
01561: continue;
01562: case JvmOpCodes.ISTORE_1:
01563:
01564: handleISTORE(JvmOpCodes.ISTORE_1);
01565: continue;
01566: case JvmOpCodes.ISTORE_2:
01567:
01568: handleISTORE(JvmOpCodes.ISTORE_2);
01569:
01570: continue;
01571: case JvmOpCodes.ISTORE_3:
01572:
01573: handleISTORE(JvmOpCodes.ISTORE_3);
01574: continue;
01575: case JvmOpCodes.ISUB:
01576: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01577: JvmOpCodes.ISUB);
01578: continue;
01579: case JvmOpCodes.IUSHR:
01580:
01581: handleIUSHR();
01582:
01583: continue;
01584: case JvmOpCodes.IXOR:
01585: handleIXOR();
01586:
01587: continue;
01588: // LETTER J
01589:
01590: case JvmOpCodes.JSR_W:
01591:
01592: i = i + 4;
01593:
01594: continue;
01595:
01596: case JvmOpCodes.JSR:
01597:
01598: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01599: JvmOpCodes.JSR);
01600: i = i + skipBytes;
01601: continue;
01602:
01603: // Letter L
01604: case JvmOpCodes.L2D:
01605:
01606: handleL2D();
01607:
01608: continue;
01609: case JvmOpCodes.L2F:
01610:
01611: handleL2F();
01612:
01613: continue;
01614: case JvmOpCodes.L2I:
01615: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
01616: JvmOpCodes.L2I);
01617: continue;
01618: case JvmOpCodes.LADD:
01619: execute(InstrConstants.LOAD_INSTR_TYPE,
01620: InstrConstants.LONG, JvmOpCodes.LADD);
01621: continue;
01622: case JvmOpCodes.LALOAD:
01623:
01624: execute(InstrConstants.LOAD_INSTR_TYPE,
01625: InstrConstants.LONG, JvmOpCodes.LALOAD);
01626: continue;
01627: case JvmOpCodes.LAND:
01628:
01629: execute(InstrConstants.LOAD_INSTR_TYPE,
01630: InstrConstants.LONG, JvmOpCodes.LAND);
01631: continue;
01632: case JvmOpCodes.LASTORE:
01633:
01634: handleLASTORE(opStack);
01635: continue;
01636: case JvmOpCodes.LCMP:
01637: handleLCMP(opStack, info);
01638: continue;
01639:
01640: case JvmOpCodes.LCONST_0:
01641: handleLCONST(opStack, "0");
01642:
01643: continue;
01644: case JvmOpCodes.LCONST_1:
01645: handleLCONST(opStack, "1");
01646: continue;
01647: case JvmOpCodes.LDC:
01648: handleLDC(opStack, info, i);
01649: i++;
01650: continue;
01651: case JvmOpCodes.LDC_W:
01652:
01653: handleLDCW(opStack, info, i);
01654: i += 2;
01655: continue;
01656: case JvmOpCodes.LDC2_W:
01657: execute(InstrConstants.LOAD_INSTR_TYPE,
01658: InstrConstants.LONG, JvmOpCodes.LDC2_W);
01659: continue;
01660:
01661: case JvmOpCodes.LDIV:
01662: handleLDIV(opStack);
01663:
01664: continue;
01665: case JvmOpCodes.LLOAD:
01666: skipBytes = handleComplexLLOAD(opStack, info,
01667: currentForIndex);
01668: i = i + skipBytes;
01669: continue;
01670: case JvmOpCodes.LLOAD_0:
01671: //
01672: handleSIMPLELLOAD(opStack, 0);
01673:
01674: continue;
01675: case JvmOpCodes.LLOAD_1:
01676: handleSIMPLELLOAD(opStack, 1);
01677:
01678: continue;
01679: case JvmOpCodes.LLOAD_2:
01680: handleSIMPLELLOAD(opStack, 2);
01681:
01682: continue;
01683: case JvmOpCodes.LLOAD_3:
01684: handleSIMPLELLOAD(opStack, 3);
01685:
01686: continue;
01687: case JvmOpCodes.LMUL:
01688:
01689: execute(InstrConstants.LOAD_INSTR_TYPE,
01690: InstrConstants.LONG, JvmOpCodes.LMUL);
01691:
01692: continue;
01693: case JvmOpCodes.LNEG:
01694:
01695: execute(InstrConstants.LOAD_INSTR_TYPE,
01696: InstrConstants.LONG, JvmOpCodes.LNEG);
01697:
01698: continue;
01699: case JvmOpCodes.LOOKUPSWITCH:
01700: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01701: JvmOpCodes.LOOKUPSWITCH);
01702: i = i + skipBytes;
01703:
01704: continue;
01705: case JvmOpCodes.LOR:
01706:
01707: execute(InstrConstants.LOAD_INSTR_TYPE,
01708: InstrConstants.LONG, JvmOpCodes.LOR);
01709:
01710: continue;
01711: case JvmOpCodes.LREM:
01712:
01713: execute(InstrConstants.LOAD_INSTR_TYPE,
01714: InstrConstants.LONG, JvmOpCodes.LREM);
01715: continue;
01716: case JvmOpCodes.LRETURN:
01717: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01718: JvmOpCodes.LRETURN);
01719: // behaviour.getParentBehaviour().getOpStack().push(op);
01720: continue;
01721: case JvmOpCodes.LSHL:
01722:
01723: execute(InstrConstants.LOAD_INSTR_TYPE,
01724: InstrConstants.LONG, JvmOpCodes.LSHL);
01725:
01726: continue;
01727: case JvmOpCodes.LSHR:
01728:
01729: handleLSHR(info, opStack);
01730: continue;
01731: case JvmOpCodes.LSTORE:
01732:
01733: handleComplexLSTORE();
01734:
01735: continue;
01736: case JvmOpCodes.LSTORE_0:
01737:
01738: handleSimpleLStoreCase(opStack, info, 0);
01739:
01740: continue;
01741: case JvmOpCodes.LSTORE_1:
01742:
01743: handleSimpleLStoreCase(opStack, info, 1);
01744:
01745: continue;
01746: case JvmOpCodes.LSTORE_2:
01747:
01748: handleSimpleLStoreCase(opStack, info, 2);
01749:
01750: continue;
01751: case JvmOpCodes.LSTORE_3:
01752:
01753: handleSimpleLStoreCase(opStack, info, 3);
01754:
01755: continue;
01756: case JvmOpCodes.LSUB:
01757:
01758: handleLSUB(info, opStack);
01759: continue;
01760: case JvmOpCodes.LUSHR:
01761:
01762: handleLUSHR(info, opStack);
01763:
01764: continue;
01765: case JvmOpCodes.LXOR:
01766:
01767: handleLXOR(info, opStack);
01768:
01769: continue;
01770:
01771: // Letter M
01772: case JvmOpCodes.MONITORENTER:
01773:
01774: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01775: JvmOpCodes.MONITORENTER);
01776:
01777: continue;
01778: case JvmOpCodes.MONITOREXIT:
01779: execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01780: JvmOpCodes.MONITOREXIT);
01781:
01782: continue;
01783: case JvmOpCodes.MULTIANEWARRAY:
01784: skipBytes = execute(InstrConstants.LOAD_INSTR_TYPE,
01785: InstrConstants.OBJECT, JvmOpCodes.MULTIANEWARRAY);
01786: i = i + skipBytes;
01787: continue;
01788: // letter N
01789: case JvmOpCodes.NEW:
01790:
01791: handleNEW(info, opStack, i);
01792: i += 2;
01793:
01794: continue;
01795: case JvmOpCodes.NEWARRAY:
01796:
01797: handleNEWARRAYCase(info);
01798: i++;
01799:
01800: continue;
01801: case JvmOpCodes.NOP:
01802: execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
01803: JvmOpCodes.NOP);
01804: continue;
01805:
01806: // letter p
01807:
01808: case JvmOpCodes.POP:
01809: execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
01810: JvmOpCodes.POP);
01811: continue;
01812: case JvmOpCodes.POP2: // TODO: check this out
01813: execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
01814: JvmOpCodes.POP2);
01815: continue;
01816: case JvmOpCodes.PUTFIELD: // put
01817: handlePUTFIELD(info, i, opStack);
01818: i += 2;
01819: continue;
01820: case JvmOpCodes.PUTSTATIC:
01821: handlePUTSTATIC(info, i, opStack);
01822: i += 2;
01823: continue;
01824:
01825: // Letter R
01826: case JvmOpCodes.RET:
01827: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01828: JvmOpCodes.RET);
01829: i = i + skipBytes;
01830: continue;
01831: case JvmOpCodes.RETURN:
01832:
01833: handleSimpleReturn();
01834:
01835: continue;
01836:
01837: // Letter S
01838: case JvmOpCodes.SALOAD:
01839:
01840: handleSALOAD();
01841: continue;
01842: case JvmOpCodes.SASTORE:
01843: handleSASTORE();
01844: continue;
01845: case JvmOpCodes.SIPUSH:
01846:
01847: handleSIPUSH(info);
01848: i += 2;
01849:
01850: continue;
01851: case JvmOpCodes.SWAP:
01852: handleSwapInst(opStack);
01853: continue;
01854:
01855: // Letter T
01856: case JvmOpCodes.TABLESWITCH: // TODO
01857: skipBytes = execute(InstrConstants.BRANCH_INSTR_TYPE, null,
01858: JvmOpCodes.TABLESWITCH);
01859: i = i + skipBytes;
01860: continue;
01861:
01862: // Letter W
01863: case JvmOpCodes.WIDE:
01864: byte nextEntry = info[++i];
01865: int constant;
01866: java.lang.String temp;
01867: Operand operand;
01868: int pos;
01869: if (nextEntry == JvmOpCodes.IINC) {
01870: int localVarPos = getOffset(info, i);
01871: i += 2;
01872: constant = getOffset(info, i);
01873: i += 2;
01874:
01875: local = getLocalVariable(localVarPos, "load", "int",
01876: false, currentForIndex);
01877:
01878: if (local != null) {
01879: temp = local.getVarName() + " += (" + constant
01880: + ");";
01881: behaviour.appendToBuffer("\n"
01882: + Util.formatDecompiledStatement(temp)
01883: + "\n");
01884: }
01885:
01886: } else {
01887: // parsedString+="WIDE\n";
01888: switch (nextEntry) {
01889: case JvmOpCodes.ILOAD:
01890:
01891: handleComplexIload();
01892: i = i + 2;
01893: break;
01894: case JvmOpCodes.FLOAD:
01895: handleFLOAD(JvmOpCodes.FLOAD);
01896: i = i + 2;
01897:
01898: // parsedString+="FLOAD "+pos+"\n";
01899: break;
01900: case JvmOpCodes.ALOAD:
01901: handleAloadCase(info, i, opStack);
01902: i = i + 2;
01903: // parsedString+="ALOAD"+"\n";
01904: break;
01905: case JvmOpCodes.LLOAD:
01906:
01907: execute(InstrConstants.LOAD_INSTR_TYPE,
01908: InstrConstants.LONG, JvmOpCodes.LLOAD);
01909: i = i + 2;
01910:
01911: break;
01912: case JvmOpCodes.DLOAD:
01913: execute(InstrConstants.LOAD_INSTR_TYPE,
01914: InstrConstants.DOUBLE, JvmOpCodes.DLOAD);
01915: i = i + 2;
01916:
01917: break;
01918: case JvmOpCodes.ISTORE:
01919:
01920: execute(InstrConstants.STORE_INSTR_TYPE,
01921: InstrConstants.INT, JvmOpCodes.ISTORE);
01922: i = i + 2;
01923: break;
01924: case JvmOpCodes.FSTORE:
01925: i = i + 2;
01926: handleComplexFSTORE();
01927: break;
01928: case JvmOpCodes.ASTORE:
01929: execute(InstrConstants.STORE_INSTR_TYPE,
01930: InstrConstants.OBJECT, JvmOpCodes.ASTORE);
01931: i = i + 2;
01932: break;
01933: case JvmOpCodes.LSTORE:
01934: handleComplexLSTORE();
01935: i = i + 2;
01936: break;
01937: case JvmOpCodes.DSTORE:
01938: handleComplexDStore();
01939: i = i + 2;
01940: break;
01941: case JvmOpCodes.RET:
01942: i += 2;
01943: break;
01944: }
01945:
01946: }
01947: }
01948:
01949: }
01950:
01951: catch (Exception e) {
01952: AllExceptionHandler handler = new AllExceptionHandler(e);
01953: handler.setBehaviour(behaviour);
01954: handler.setCodePosition(currentForIndex);
01955: handler.reportException();
01956: }
01957:
01958: }
01959:
01960: behaviour.setLabels(GlobalVariableStore.getLABELS());
01961: behaviour
01962: .setVariablesAtFront(GlobalVariableStore.getVariablesatfront());
01963: closeDoWhile(behaviour.getCode().length);
01964: behaviour.filterCode(generatedIfTracker);
01965:
01966: }
01967:
01968: private int isLoopAfterTry(int loopend) {
01969:
01970: int after = 2;
01971: int loopstart = currentForIndex;
01972: List tries = behaviour.getAllTriesForMethod();
01973: for (int i = 0; i < tries.size(); i++) {
01974: TryBlock tryb = (TryBlock) tries.get(i);
01975: if (tryb.getStart() == loopstart) {
01976: if (tryb.getEnd() > loopend) {
01977: return 0;
01978: }
01979: if (tryb.getEnd() < loopend) {
01980: return 1;
01981: }
01982: }
01983:
01984: }
01985: return after;
01986: }
01987:
01988: private boolean isNextInstructionAnyInvoke(int nextinst, StringBuffer sb) {
01989: boolean b = isNextInstructionInvokeInterface(nextinst);
01990: if (b) {
01991: sb.append("interface");
01992: return b;
01993: }
01994: b = isNextInstructionInvokeSpecial(nextinst);
01995: if (b) {
01996: sb.append("special");
01997: return b;
01998: }
01999: b = isNextInstructionInvokeStatic(nextinst);
02000: if (b)
02001: return b;
02002: b = isNextInstructionInvokeVirtual(nextinst);
02003: if (b)
02004: return b;
02005: return false;
02006: }
02007:
02008: private boolean isNextInstructionInvokeInterface(int nextInst) {
02009:
02010: if (nextInst == JvmOpCodes.INVOKEINTERFACE)
02011: return true;
02012: else
02013: return false;
02014: }
02015:
02016: private boolean isNextInstructionInvokeSpecial(int nextInst) {
02017:
02018: if (nextInst == JvmOpCodes.INVOKESPECIAL)
02019: return true;
02020: else
02021: return false;
02022: }
02023:
02024: private boolean isNextInstructionInvokeStatic(int nextInst) {
02025:
02026: if (nextInst == JvmOpCodes.INVOKESTATIC)
02027: return true;
02028: else
02029: return false;
02030: }
02031:
02032: private int isNextInstructionConversionInst(int i, byte[] code) {
02033: if (isThisInstrStart(behaviour.getInstructionStartPositions(), i) == false)
02034: return -1;
02035: switch (code[i]) {
02036:
02037: case JvmOpCodes.D2L:
02038: case JvmOpCodes.D2I:
02039: case JvmOpCodes.D2F:
02040: case JvmOpCodes.I2B:
02041: case JvmOpCodes.I2C:
02042: case JvmOpCodes.I2D:
02043: case JvmOpCodes.I2F:
02044: case JvmOpCodes.I2L:
02045: case JvmOpCodes.I2S:
02046: case JvmOpCodes.L2D:
02047: case JvmOpCodes.L2F:
02048: case JvmOpCodes.L2I:
02049: case JvmOpCodes.F2D:
02050:
02051: case JvmOpCodes.F2I:
02052: case JvmOpCodes.F2L:
02053: return i;
02054: default:
02055: return -1;
02056:
02057: }
02058:
02059: }
02060:
02061: private boolean isNextInstructionInvokeVirtual(int nextInst) {
02062:
02063: if (nextInst == JvmOpCodes.INVOKEVIRTUAL)
02064: return true;
02065: else
02066: return false;
02067: }
02068:
02069: private boolean isNextInstructionConversionInst(int next) {
02070: boolean flag = false;
02071: switch (next) {
02072:
02073: case JvmOpCodes.D2L:
02074: case JvmOpCodes.D2I:
02075: case JvmOpCodes.D2F:
02076: case JvmOpCodes.I2B:
02077: case JvmOpCodes.I2C:
02078: case JvmOpCodes.I2D:
02079: case JvmOpCodes.I2F:
02080: case JvmOpCodes.I2L:
02081: case JvmOpCodes.I2S:
02082: case JvmOpCodes.L2D:
02083: case JvmOpCodes.L2F:
02084: case JvmOpCodes.L2I:
02085: case JvmOpCodes.F2D:
02086:
02087: case JvmOpCodes.F2I:
02088: case JvmOpCodes.F2L:
02089: return true;
02090: default:
02091: return false;
02092:
02093: }
02094:
02095: }
02096:
02097: private java.lang.String getSourceTypeForConversionInst(int i, byte[] code) {
02098: if (isThisInstrStart(behaviour.getInstructionStartPositions(), i) == false)
02099: return "";
02100: switch (code[i]) {
02101:
02102: case JvmOpCodes.D2L:
02103: return "double";
02104: case JvmOpCodes.D2I:
02105: return "double";
02106: case JvmOpCodes.D2F:
02107: return "double";
02108: case JvmOpCodes.I2B:
02109: return "int";
02110: case JvmOpCodes.I2C:
02111: return "int";
02112:
02113: case JvmOpCodes.I2D:
02114: return "int";
02115:
02116: case JvmOpCodes.I2F:
02117: return "int";
02118:
02119: case JvmOpCodes.I2L:
02120: return "int";
02121:
02122: case JvmOpCodes.I2S:
02123: return "int";
02124:
02125: case JvmOpCodes.L2D:
02126: return "long";
02127:
02128: case JvmOpCodes.L2F:
02129: return "long";
02130:
02131: case JvmOpCodes.L2I:
02132: return "long";
02133:
02134: case JvmOpCodes.F2D:
02135: return "float";
02136:
02137: case JvmOpCodes.F2I:
02138: return "float";
02139:
02140: case JvmOpCodes.F2L:
02141: return "float";
02142: default:
02143: return "";
02144:
02145: }
02146:
02147: }
02148:
02149: private java.lang.String getResulatantTypeForConversionInst(int i,
02150: byte[] code) {
02151: if (isThisInstrStart(behaviour.getInstructionStartPositions(), i) == false)
02152: return "";
02153: switch (code[i]) {
02154:
02155: case JvmOpCodes.D2L:
02156: return "long";
02157: case JvmOpCodes.D2I:
02158: return "int";
02159: case JvmOpCodes.D2F:
02160: return "float";
02161: case JvmOpCodes.I2B:
02162: return "byte";
02163: case JvmOpCodes.I2C:
02164: return "char";
02165:
02166: case JvmOpCodes.I2D:
02167: return "double";
02168:
02169: case JvmOpCodes.I2F:
02170: return "float";
02171:
02172: case JvmOpCodes.I2L:
02173: return "long";
02174:
02175: case JvmOpCodes.I2S:
02176: return "short";
02177:
02178: case JvmOpCodes.L2D:
02179: return "double";
02180:
02181: case JvmOpCodes.L2F:
02182: return "float";
02183:
02184: case JvmOpCodes.L2I:
02185: return "int";
02186:
02187: case JvmOpCodes.F2D:
02188: return "double";
02189:
02190: case JvmOpCodes.F2I:
02191: return "int";
02192:
02193: case JvmOpCodes.F2L:
02194: return "long";
02195: default:
02196: return "";
02197:
02198: }
02199:
02200: }
02201:
02202: private boolean isNextInstructionStore(int nextInstruction) {
02203: boolean flag = false;
02204:
02205: switch (nextInstruction) {
02206: /*
02207: * case JvmOpCodes.AASTORE : flag = true; break;
02208: */
02209: case JvmOpCodes.ASTORE:
02210: flag = true;
02211: break;
02212:
02213: case JvmOpCodes.ASTORE_0:
02214: flag = true;
02215: break;
02216: case JvmOpCodes.ASTORE_1:
02217: flag = true;
02218: break;
02219: case JvmOpCodes.ASTORE_2:
02220: flag = true;
02221: break;
02222: case JvmOpCodes.ASTORE_3:
02223: flag = true;
02224: break;
02225:
02226: case JvmOpCodes.DSTORE:
02227: flag = true;
02228: break;
02229: case JvmOpCodes.DSTORE_0:
02230: flag = true;
02231: break;
02232: case JvmOpCodes.DSTORE_1:
02233: flag = true;
02234: break;
02235: case JvmOpCodes.DSTORE_2:
02236: flag = true;
02237: break;
02238: case JvmOpCodes.DSTORE_3:
02239: flag = true;
02240: break;
02241:
02242: case JvmOpCodes.FSTORE:
02243: flag = true;
02244: break;
02245: case JvmOpCodes.FSTORE_0:
02246: flag = true;
02247: break;
02248: case JvmOpCodes.FSTORE_1:
02249: flag = true;
02250: break;
02251: case JvmOpCodes.FSTORE_2:
02252: flag = true;
02253: break;
02254: case JvmOpCodes.FSTORE_3:
02255: flag = true;
02256: break;
02257:
02258: case JvmOpCodes.ISTORE:
02259: flag = true;
02260: break;
02261: case JvmOpCodes.ISTORE_0:
02262: flag = true;
02263: break;
02264: case JvmOpCodes.ISTORE_1:
02265: flag = true;
02266: break;
02267: case JvmOpCodes.ISTORE_2:
02268: flag = true;
02269: break;
02270: case JvmOpCodes.ISTORE_3:
02271: flag = true;
02272: break;
02273:
02274: case JvmOpCodes.LSTORE:
02275: flag = true;
02276: break;
02277:
02278: case JvmOpCodes.LSTORE_0:
02279: flag = true;
02280: break;
02281: case JvmOpCodes.LSTORE_1:
02282: flag = true;
02283: break;
02284: case JvmOpCodes.LSTORE_2:
02285: flag = true;
02286: break;
02287: case JvmOpCodes.LSTORE_3:
02288: flag = true;
02289: break;
02290:
02291: default:
02292: flag = false;
02293: }
02294: return flag;
02295: }
02296:
02297: public boolean isNextInstructionReturn(int nextInstruction) {
02298: boolean flag = false;
02299: switch (nextInstruction) {
02300: case JvmOpCodes.RETURN:
02301: return true;
02302: default:
02303: return false;
02304:
02305: }
02306: }
02307:
02308: public boolean isNextInstructionPop(int nextInstruction) {
02309: boolean flag = false;
02310: switch (nextInstruction) {
02311: case JvmOpCodes.POP:
02312: case JvmOpCodes.POP2:
02313: return true;
02314: default:
02315: return false;
02316:
02317: }
02318: }
02319:
02320: public boolean isNextInstructionIf(int nextInstruction) {
02321: boolean flag = false;
02322:
02323: switch (nextInstruction) {
02324: case JvmOpCodes.IF_ACMPEQ:
02325: flag = true;
02326: break;
02327: case JvmOpCodes.IF_ACMPNE:
02328: flag = true;
02329: break;
02330: case JvmOpCodes.IF_ICMPEQ:
02331: flag = true;
02332: break;
02333: case JvmOpCodes.IF_ICMPGE:
02334: flag = true;
02335: break;
02336: case JvmOpCodes.IF_ICMPGT:
02337: flag = true;
02338: break;
02339: case JvmOpCodes.IF_ICMPLE:
02340: flag = true;
02341: break;
02342: case JvmOpCodes.IF_ICMPLT:
02343: flag = true;
02344: break;
02345: case JvmOpCodes.IF_ICMPNE:
02346: flag = true;
02347: break;
02348: case JvmOpCodes.IFEQ:
02349: flag = true;
02350: break;
02351: case JvmOpCodes.IFGE:
02352: flag = true;
02353: break;
02354: case JvmOpCodes.IFGT:
02355: flag = true;
02356: break;
02357: case JvmOpCodes.IFLE:
02358: flag = true;
02359: break;
02360: case JvmOpCodes.IFLT:
02361: flag = true;
02362: break;
02363: case JvmOpCodes.IFNE:
02364: flag = true;
02365: break;
02366: case JvmOpCodes.IFNONNULL:
02367: flag = true;
02368: break;
02369: case JvmOpCodes.IFNULL:
02370: flag = true;
02371: break;
02372: default:
02373: flag = false;
02374: }
02375: return flag;
02376: }
02377:
02378: // TODO: Write logic to poll for the end of the last catch
02379: private java.lang.String pollExcepionTables(int i, int instruction) {
02380: java.lang.String temp = "";
02381: // Algo
02382: // For Each ExceptionTable Do
02383: // 1> check whether = to start of Guard
02384: // If so Check Whether guardtype is try or catch
02385: // 2> Else check whether = to end of Guard
02386: // If so Just return a "}"
02387: // 3> Else check whether = to start of Handler
02388: // If so check whether type is catch or finally
02389: // Return appropriately
02390: // 4> Else check whether = to end of Handler
02391: // just Return "}"
02392: // Curszor
02393: // 5> Check for invalid Table values
02394: ArrayList alltables = this .behaviour.getExceptionTableList();
02395: byte code[] = behaviour.getCode();
02396: if (alltables != null) {
02397: for (int c = 0; c < alltables.size(); c++) {
02398: ExceptionTable table = (ExceptionTable) alltables.get(c);
02399: // System.out.println(i+"table.getEndOfHandlerForGuardRegion()"+table.getEndOfHandlerForGuardRegion());
02400:
02401: // Check for Invalid condition
02402:
02403: if (code != null
02404: && code[table.getStartOfGuardRegion() + 1] == JvmOpCodes.MONITOREXIT)
02405: continue;
02406:
02407: if (code != null
02408: && code[table.getEndOfGuardRegion() - 1] == JvmOpCodes.MONITOREXIT) {
02409:
02410: continue;
02411: }
02412:
02413: if (table.getStartOfGuardRegion() == table
02414: .getStartOfHandlerForGuardRegion())
02415: continue;
02416: // Another invalid to check
02417: if (table.getEndOfGuardRegion() > table
02418: .getStartOfHandlerForGuardRegion())
02419: continue;
02420:
02421: // Check 1
02422: if (table.getStartOfGuardRegion() == i) {
02423: if (table.getTypeOfGuardRegion().equals("try")) {
02424: ArrayList Al = new ArrayList();
02425: temp += "try\n{\n";
02426: Al.add(table);
02427: Iterator IT = behaviour.getExceptionTableList()
02428: .iterator();
02429: while (IT.hasNext()) {
02430: ExceptionTable etb = (ExceptionTable) IT.next();
02431: if (etb.getStartOfGuardRegion() == i
02432: && etb.getTypeOfGuardRegion().equals("try")) {
02433: boolean Present = alreadyPresent(Al, etb);
02434: if (Present == false) {
02435: temp += "\ntry\n{\n";
02436: Al.add(etb);
02437: }
02438:
02439: }
02440: }
02441:
02442: // Check from created Exception Table List.
02443: ArrayList createdList = behaviour.getCreatedTableList();
02444: if (createdList != null) {
02445: IT = createdList.iterator();
02446: while (IT.hasNext()) {
02447: ExceptionTable etb = (ExceptionTable) IT.next();
02448: if (etb.getStartOfGuardRegion() == i
02449: && etb.getTypeOfGuardRegion().equals(
02450: "try")) {
02451: boolean Present = alreadyPresent(Al, etb);
02452: if (Present == false) {
02453: temp += "\ntry\n{\n";
02454: Al.add(etb);
02455: }
02456:
02457: }
02458: }
02459: }
02460:
02461: break;
02462: }
02463: if (table.getTypeOfGuardRegion().equals("catch")) {
02464: // Need to Get Exception Name
02465: java.lang.String expName = "";
02466: for (int c2 = 0; c2 < alltables.size(); c2++) {
02467: ExceptionTable temptable = (ExceptionTable) alltables
02468: .get(c2);
02469: if (temptable.getEndOfGuardRegion() == i) {
02470: expName = temptable.getExceptionName();
02471: expName.replace('/', '.');
02472: LocalVariableStructure structure = this .behaviour
02473: .getLocalVariables();
02474: int indexPos = -1;
02475: boolean simple = true;
02476: switch (instruction) {
02477: case JvmOpCodes.ASTORE:
02478: indexPos = this .behaviour.getCode()[i + 1];
02479: simple = false;
02480: break;
02481: case JvmOpCodes.ASTORE_0:
02482: indexPos = 0;
02483: break;
02484: case JvmOpCodes.ASTORE_1:
02485: indexPos = 1;
02486: break;
02487: case JvmOpCodes.ASTORE_2:
02488: indexPos = 2;
02489: break;
02490: case JvmOpCodes.ASTORE_3:
02491: indexPos = 3;
02492: break;
02493: // TODO: Later check for wide instruction with
02494: // astore.
02495: // Need to Handle it.
02496:
02497: }
02498:
02499: LocalVariable expVar = getLocalVariable(
02500: indexPos, "store", "java.lang.Object",
02501: simple, i); //
02502: java.lang.String expVarName = "";
02503: if (expVar != null)
02504: expVarName = expVar.getVarName();
02505: if (expVar == null) {
02506: // TODO handle Later
02507: expVarName = "exception";
02508: }
02509: StringBuffer g = new StringBuffer("");
02510: checkForImport(expName.replace('/', '.'), g);
02511: temp += "\ncatch(" + g.toString() + " "
02512: + expVarName + ")\n{\n";
02513: break;
02514: }
02515: }
02516: temp += "";
02517: break;
02518:
02519: }
02520: }
02521: if (table.getEndOfGuardRegion() == i) {
02522: // Apply Rule For Try
02523: // Purpose of this rule is to check whether
02524: // i is actually the end for this try or not
02525: int startOfGuard = table.getStartOfGuardRegion();
02526: boolean alreadyEnded = false;
02527: if (table.getTypeOfGuardRegion().equals("try")) {
02528: ArrayList excepTables = this .behaviour
02529: .getExceptionTableList();
02530: ;
02531: for (int Start = 0; Start < excepTables.size(); Start++) {
02532: ExceptionTable tab = (ExceptionTable) excepTables
02533: .get(Start);
02534: if (tab.getStartOfGuardRegion() == startOfGuard) {
02535: int endOfGuard = tab.getEndOfGuardRegion();
02536: int beginofHandler = tab
02537: .getStartOfHandlerForGuardRegion();
02538: if (i > endOfGuard && i < beginofHandler) {
02539: alreadyEnded = true;
02540: break;
02541: }
02542: }
02543: }
02544: }
02545: boolean addGE = addGuardEnd(i);
02546: boolean b1 = isHandlerEndPresentAtGuardEnd(i);
02547: if (alreadyEnded == false
02548: && (table.getTypeOfGuardRegion().equals("") == false)
02549: && addGE && !b1) {
02550: temp += "}";
02551: guardEnds.put(new Integer(i), "true");
02552: } else
02553: temp += "";
02554: // Check for overlap
02555: ArrayList excepTables = this .behaviour
02556: .getExceptionTableList();
02557: ;
02558: for (int Start = 0; Start < excepTables.size(); Start++) {
02559: ExceptionTable tab = (ExceptionTable) excepTables
02560: .get(Start);
02561: if (tab.getStartOfHandlerForGuardRegion() == i
02562: && tab.getExceptionName().equals("<any>") == false) {
02563: // Added code for generating excepion Name
02564: LocalVariableStructure structure = this .behaviour
02565: .getLocalVariables();
02566: int indexPos = -1;
02567: boolean simple = true;
02568: switch (instruction) {
02569: case JvmOpCodes.ASTORE:
02570: indexPos = this .behaviour.getCode()[i + 1];
02571: simple = false;
02572: break;
02573: case JvmOpCodes.ASTORE_0:
02574: indexPos = 0;
02575: break;
02576: case JvmOpCodes.ASTORE_1:
02577: indexPos = 1;
02578: break;
02579: case JvmOpCodes.ASTORE_2:
02580: indexPos = 2;
02581: break;
02582: case JvmOpCodes.ASTORE_3:
02583: indexPos = 3;
02584: break;
02585: // TODO: Later check for wide instruction with
02586: // astore.
02587: // Need to Handle it.
02588:
02589: }
02590:
02591: LocalVariable expVar = getLocalVariable(indexPos,
02592: "store", "java.lang.Object", simple, i);
02593: java.lang.String expName = "";
02594: if (expVar != null)
02595: expName = expVar.getVarName();
02596: if (expVar == null) {
02597: // TODO
02598: expName = "exception";
02599: }
02600: StringBuffer g = new StringBuffer("");
02601: checkForImport(tab.getExceptionName().replace('/',
02602: '.'), g);
02603: temp += "\ncatch(" + g.toString() + " " + expName
02604: + ")\n{\n";
02605: break;
02606: }
02607: if (tab.getStartOfHandlerForGuardRegion() == i
02608: && tab.getExceptionName().equals("<any>") == true) {
02609: temp += "\nfinally\n{\n";
02610: break;
02611: }
02612: }
02613:
02614: // Check from newly created Table list
02615: ArrayList newexcepTables = this .behaviour
02616: .getCreatedTableList();
02617: if (newexcepTables != null) {
02618: for (int Start = 0; Start < newexcepTables.size(); Start++) {
02619: ExceptionTable tab = (ExceptionTable) newexcepTables
02620: .get(Start);
02621: boolean addG = addGuardEnd(i);
02622: boolean z = isHandlerEndPresentAtGuardEnd(i);
02623: if (tab.getEndOfGuardRegion() == i && addG && !z) {
02624: temp += "}\n";
02625: guardEnds.put(new Integer(i), "true");
02626: break;
02627: }
02628: }
02629: }
02630:
02631: // System.out.println();
02632: break;
02633: }
02634:
02635: if (table.getStartOfHandlerForGuardRegion() == i) {
02636:
02637: /*
02638: * Iterator
02639: * itz=behaviour.getExceptionTableList().iterator();
02640: * while(itz.hasNext()) { ExceptionTable
02641: * etb=(ExceptionTable)itz.next();
02642: * if(etb.getEndOfHandlerForGuardRegion()==i) { //
02643: * temp+="\n}// end of handler2\n"; } }
02644: */
02645:
02646: if (table.getTypeOfHandlerForGuardRegion().equals(
02647: "FinallyBlock")) {
02648: temp += "finally\n{\n";
02649: break;
02650: }
02651: if (table.getTypeOfHandlerForGuardRegion().equals(
02652: "CatchBlock")) {
02653: LocalVariableStructure structure = this .behaviour
02654: .getLocalVariables();
02655: int indexPos = -1;
02656: int blockIndexValue = -1;
02657: boolean simple = true;
02658: switch (instruction) {
02659: case JvmOpCodes.ASTORE:
02660: indexPos = this .behaviour.getCode()[i + 1];
02661: blockIndexValue = i + 2;
02662: simple = false;
02663: break;
02664: case JvmOpCodes.ASTORE_0:
02665: indexPos = 0;
02666: blockIndexValue = i + 1;
02667: break;
02668: case JvmOpCodes.ASTORE_1:
02669: blockIndexValue = i + 1;
02670: indexPos = 1;
02671: break;
02672: case JvmOpCodes.ASTORE_2:
02673: blockIndexValue = i + 1;
02674: indexPos = 2;
02675: break;
02676: case JvmOpCodes.ASTORE_3:
02677: blockIndexValue = i + 1;
02678: indexPos = 3;
02679: break;
02680: // TODO: Later check for wide instruction with astore.
02681: // Need to Handle it.
02682:
02683: }
02684:
02685: boolean add = addHandlerStart(i);
02686: if (add) {
02687: StringBuffer g = new StringBuffer("");
02688: checkForImport(table.getExceptionName().replace(
02689: '/', '.'), g);
02690: String tp = null;
02691: try {
02692: tp = table.getExceptionName().replace('/', '.');
02693: } catch (Exception e) {
02694: tp = "java.lang.Object";
02695: }
02696: LocalVariable expVar = getLocalVariable(indexPos,
02697: "store", tp, simple, i);
02698: java.lang.String expName = "";
02699: if (expVar != null)
02700: expName = expVar.getVarName();
02701: else
02702: expName = "exception";
02703: temp += "catch(" + g.toString() + " " + expName
02704: + ")\n{\n";
02705: handlerStarts.put(new Integer(i), "true");
02706: }
02707: break;
02708:
02709: }
02710: }
02711: if (table.getEndOfHandlerForGuardRegion() == i) {
02712:
02713: boolean b = addhandlerEnd(i, table);
02714: if (b) {
02715: addedHandlerEnds.add(new Integer(i));
02716: handlerEndLocationsAdded.add(new Integer(i));
02717:
02718: if (code[i] == JvmOpCodes.ATHROW) {
02719: if (opStack.size() > 0) {
02720:
02721: boolean emptyFinally = checkForEmptyFinally(
02722: code, i, table);
02723: if (!emptyFinally) {
02724: String s = opStack.pop().toString();
02725: if (s != null && !s.equals("this")) {
02726: IFinder basicFinder = FinderFactory
02727: .getFinder(IFinder.BASE);
02728: int prev = basicFinder
02729: .getPrevStartOfInst(i);
02730: boolean appendAthrow = true;
02731: if (prev > 0) {
02732: IFinder loadFinder = FinderFactory
02733: .getFinder(IFinder.LOAD);
02734:
02735: int aloadpos = loadFinder
02736: .isInstAload(prev,
02737: new StringBuffer());
02738: if (aloadpos == prev) {
02739: boolean exists = LocalVariableHelper
02740: .checkForVariableExistenceWithName(s);
02741: if (!exists) {
02742: appendAthrow = false;
02743: }
02744:
02745: }
02746: }
02747: if (appendAthrow)
02748: temp += "throw " + s + ";\n";
02749: }
02750:
02751: } else {
02752: opStack.pop();
02753: // temp+="/*Empty Handler Block*/\n";
02754: }
02755: GlobalVariableStore.getAthrowmap().put(
02756: new Integer(currentForIndex), "true");
02757: }
02758:
02759: }
02760: if (table.getHandlerBlockName().indexOf("Catch") != -1) {
02761: boolean emptyCatch = checkForEmptyCatch(table
02762: .getStartOfHandlerForGuardRegion(), table
02763: .getEndOfHandlerForGuardRegion());
02764: if (emptyCatch) {
02765: // temp+="/*Empty Handler Block*/\n";
02766: }
02767: }
02768: temp += "\n}\n";
02769: int s = table.getStartOfHandlerForGuardRegion();
02770: int e = table.getEndOfHandlerForGuardRegion();
02771: java.lang.String t = table
02772: .getTypeOfHandlerForGuardRegion();
02773: handlertracker.put(new Integer(i),
02774: new handlerEndTracker(s, e, t));
02775: // guardEnds.put(new Integer(i),"true");
02776: }
02777: Iterator tempIterator = null;
02778:
02779: // Check for End of Guard
02780: // TODO: Get the example for This...
02781: tempIterator = behaviour.getExceptionTableList().iterator();
02782: while (tempIterator.hasNext()) {
02783: ExceptionTable etb = (ExceptionTable) tempIterator
02784: .next();
02785: boolean addG = addGuardEnd(i);
02786: boolean z = isHandlerEndPresentAtGuardEnd(i, null);
02787: if (etb.getEndOfGuardRegion() == i && addG && !z) {
02788: temp += "\n}";
02789: guardEnds.put(new Integer(i), "true");
02790: break;
02791: }
02792: }
02793:
02794: // Check for overlap with Created Table List
02795: ArrayList newList = behaviour.getCreatedTableList();
02796: if (newList != null) {
02797: tempIterator = newList.iterator();
02798: while (tempIterator.hasNext()) {
02799: ExceptionTable etb = (ExceptionTable) tempIterator
02800: .next();
02801: boolean addG = addGuardEnd(i);
02802: boolean z = isHandlerEndPresentAtGuardEnd(i, null);
02803: if (etb.getEndOfGuardRegion() == i && addG && !z) {
02804: temp += "}\n";
02805: guardEnds.put(new Integer(i), "true");
02806: break;
02807: }
02808: }
02809: }
02810:
02811: // Check here for overlap condition
02812: tempIterator = behaviour.getExceptionTableList().iterator();
02813: while (tempIterator.hasNext()) {
02814: ExceptionTable etb = (ExceptionTable) tempIterator
02815: .next();
02816: if (etb.getStartOfHandlerForGuardRegion() == i
02817: && etb.getExceptionName().equals("<any>") == false) {
02818: java.lang.String ename = etb.getExceptionName();
02819: ename = ename.replace('/', '.');
02820: LocalVariableStructure structure = this .behaviour
02821: .getLocalVariables();
02822: int indexPos = -1;
02823: int blockIndexValue = -1;
02824: boolean simple = true;
02825: switch (instruction) {
02826: case JvmOpCodes.ASTORE:
02827: indexPos = this .behaviour.getCode()[i + 1];
02828: blockIndexValue = i + 2;
02829: simple = false;
02830: break;
02831: case JvmOpCodes.ASTORE_0:
02832: blockIndexValue = i + 1;
02833: indexPos = 0;
02834: break;
02835: case JvmOpCodes.ASTORE_1:
02836: blockIndexValue = i + 1;
02837: indexPos = 1;
02838: break;
02839: case JvmOpCodes.ASTORE_2:
02840: blockIndexValue = i + 1;
02841: indexPos = 2;
02842: break;
02843: case JvmOpCodes.ASTORE_3:
02844: blockIndexValue = i + 1;
02845: indexPos = 3;
02846: break;
02847: // TODO: Later check for wide instruction with
02848: // astore.
02849: // Need to Handle it.
02850:
02851: }
02852:
02853: LocalVariable expVar = getLocalVariable(indexPos,
02854: "store", "java.lang.Object", simple, i);
02855: java.lang.String expName = "";
02856: if (expVar != null)
02857: expName = expVar.getVarName();
02858: if (expVar == null) {
02859: // TODO handle Later
02860: expName = "exception";
02861: }
02862: boolean add = addHandlerStart(i);
02863: if (add) {
02864: StringBuffer g = new StringBuffer("");
02865: checkForImport(ename.replace('/', '.'), g);
02866: temp += "catch(" + g.toString() + " " + expName
02867: + ")\n{\n";
02868: handlerStarts.put(new Integer(i), "true");
02869: }
02870: break;
02871: }
02872: }
02873:
02874: // break;
02875: }
02876:
02877: }
02878:
02879: }
02880: // Check For End of Catch For Last Catch
02881: // Note Handled Here because This there is no entry in exception table
02882: // list for The end of last catch
02883: // as there is no finally for try
02884:
02885: // if(temp.length()==0) // Removing if because this was preventing last
02886: // catch's end of guard of to be printed
02887: // As that info was only held in a CatchBlock Object
02888: // {
02889: ArrayList allTryBlks = getAllTriesForBehaviour(); // All try blocks
02890: // for method
02891: if (allTryBlks != null) {
02892: Iterator it = allTryBlks.iterator();
02893: while (it.hasNext()) {
02894: TryBlock tryblock = (TryBlock) it.next(); // Get Each Try
02895: if (tryblock.hasFinallyBlk() == false) // Go in only if there
02896: // is no finally for
02897: // this try
02898: {
02899: ArrayList allcatches = tryblock.getAllCatchesForThisTry(); // Get
02900: // catches
02901: // for
02902: // this
02903: // try
02904: if (allcatches.size() > 0) // Try may not have any catches
02905: {
02906: CatchBlock LastCatch = (CatchBlock) allcatches
02907: .get(allcatches.size() - 1);
02908: int endOfCatch = LastCatch.getEnd(); // Get end of
02909: // last catch
02910: // block for
02911: // this try
02912: if (endOfCatch == i
02913: && LastCatch
02914: .isUsedForDeterminingTheEndOfLastCatch()) // compare
02915: // with
02916: // i
02917: {
02918:
02919: if (code[i] == JvmOpCodes.ATHROW) {
02920: if (opStack.size() > 0) {
02921: String s = opStack.pop().toString();
02922: if (!s.equals("this")) {
02923: IFinder basicFinder = FinderFactory
02924: .getFinder(IFinder.BASE);
02925: int prev = basicFinder
02926: .getPrevStartOfInst(i);
02927: boolean appendAthrow = true;
02928: if (prev > 0) {
02929: IFinder loadFinder = FinderFactory
02930: .getFinder(IFinder.LOAD);
02931:
02932: int aloadpos = loadFinder
02933: .isInstAload(prev,
02934: new StringBuffer());
02935: if (aloadpos == prev) {
02936: boolean exists = LocalVariableHelper
02937: .checkForVariableExistenceWithName(s);
02938: if (!exists) {
02939: appendAthrow = false;
02940: }
02941:
02942: }
02943: }
02944: if (appendAthrow)
02945: temp += "throw " + s + ";\n";
02946: }
02947: GlobalVariableStore.getAthrowmap().put(
02948: new Integer(currentForIndex),
02949: "true");
02950: }
02951:
02952: }
02953: temp += "}\n"; // end Catch and break
02954: break;
02955: }
02956: }
02957: }
02958:
02959: }
02960:
02961: }
02962:
02963: return temp;
02964:
02965: }
02966:
02967: private ArrayList getAllTriesForBehaviour() {
02968: ArrayList alltries = behaviour.getAllTriesForMethod();
02969: int size = alltries.size();
02970: if (size == 0)
02971: return null;
02972: else
02973: return alltries;
02974: }
02975:
02976: private boolean skipCurrentIteraton(int i, boolean includeEndOfGuard,
02977: byte[] info) {
02978: boolean skip = false;
02979: boolean exit = false;
02980: ArrayList tries = this .behaviour.getAllTriesForMethod();
02981: Iterator triesIT = tries.iterator();
02982: while (triesIT.hasNext()) {
02983: TryBlock TRY = (TryBlock) triesIT.next();
02984: ArrayList catches = TRY.getAllCatchesForThisTry();
02985: Iterator catchesIT = catches.iterator();
02986: TryCatchFinally prevBlock = TRY;
02987: while (catchesIT.hasNext()) {
02988: CatchBlock Catch = (CatchBlock) catchesIT.next();
02989: TryCatchFinally curBlock = Catch;
02990: if (includeEndOfGuard) {
02991: if (i >= prevBlock.getEnd() && i < curBlock.getStart()) {
02992: skip = true;
02993: boolean retStmt = checkForReturn(info, i);
02994: if (retStmt == true)
02995: skip = false;
02996: exit = true;
02997: break;
02998: }
02999: }
03000: if (!includeEndOfGuard && i > prevBlock.getEnd()
03001: && i < curBlock.getStart()) {
03002: skip = true;
03003: boolean retStmt = checkForReturn(info, i);
03004: if (retStmt == true)
03005: skip = false;
03006: exit = true;
03007: break;
03008: }
03009: prevBlock = curBlock;
03010: }
03011: if (exit)
03012: break;
03013: // Check for Finally Block
03014: FinallyBlock Finally = TRY.getFinallyBlock();
03015: if (Finally != null) {
03016: CatchBlock catchblock = TRY.getLastCatchBlock();
03017: if (catchblock != null) {
03018: if (!includeEndOfGuard && i > catchblock.getEnd()
03019: && i < Finally.getStart()) {
03020: boolean retStmt = checkForReturn(info, i);
03021: if (retStmt == true) {
03022: skip = false;
03023: } else {
03024: skip = true;
03025: }
03026: }
03027: if (includeEndOfGuard && i >= catchblock.getEnd()
03028: && i < Finally.getStart()) {
03029: boolean retStmt = checkForReturn(info, i);
03030: if (retStmt == true) {
03031: skip = false;
03032: } else {
03033: skip = true;
03034: }
03035: }
03036: } else {
03037: if (!includeEndOfGuard && i > TRY.getEnd()
03038: && i < Finally.getStart()) {
03039:
03040: boolean retStmt = checkForReturn(info, i);
03041: if (retStmt == true) {
03042: skip = false;
03043: } else {
03044: skip = true;
03045: }
03046: }
03047: if (includeEndOfGuard && i >= TRY.getEnd()
03048: && i < Finally.getStart()) {
03049: boolean retStmt = checkForReturn(info, i);
03050: if (retStmt == true) {
03051: skip = false;
03052: } else {
03053: skip = true;
03054: }
03055: }
03056: }
03057:
03058: }
03059: }
03060:
03061: /*
03062: * if(!skip && behaviour.getSynchronizedEntries()!=null &&
03063: * behaviour.getSynchronizedEntries().size() > 0) { ArrayList
03064: * synchEntries=behaviour.getSynchronizedEntries(); for(int s=0;s<synchEntries.size();s++) {
03065: * ExceptionTable synchTab=(ExceptionTable)synchEntries.get(s); int
03066: * endPC=synchTab.getEndPC(); int
03067: * athrowpos=getNextAthrowPos(endPC,info); if(athrowpos!=-1) { if(i
03068: * >=endPC && i<= athrowpos) { skip=true; break; } } } }
03069: */
03070: boolean skipDueToSynch = false;
03071: if (synchSkips != null && synchSkips.size() > 0) {
03072:
03073: Iterator it = synchSkips.entrySet().iterator();
03074: while (it.hasNext()) {
03075:
03076: Map.Entry e = (Map.Entry) it.next();
03077: Integer st = (Integer) e.getKey();
03078: Integer en = (Integer) e.getValue();
03079: if (i >= st.intValue() && i <= en.intValue()) {
03080: skip = true;
03081: skipDueToSynch = true;
03082: break;
03083: }
03084:
03085: }
03086:
03087: }
03088:
03089: if (skip == false) // Buggy
03090: {
03091:
03092: ArrayList tableList = Util
03093: .getAllTablesWithFinallyAsHandler(behaviour
03094: .getExceptionTableList());
03095: ArrayList subsetList = getFinallyCount(tableList);
03096: if (subsetList == null)
03097: return skip;
03098: ArrayList finList[] = new ArrayList[subsetList.size()];
03099: for (int x = 0; x < subsetList.size(); x++) {
03100: finList[x] = Util.getAllTablesWithFinallyAsHandler(behaviour
03101: .getExceptionTableList(), ((Integer) subsetList.get(x))
03102: .intValue());
03103: tableList = Util.getTablesSortedByGuardStart(finList[x]);
03104: if (tableList != null) {
03105: for (int z = 0; z < tableList.size(); z++) {
03106:
03107: ExceptionTable table1 = (ExceptionTable) tableList
03108: .get(z);
03109:
03110: if (info != null
03111: && info[table1.getStartOfGuardRegion() + 1] == JvmOpCodes.MONITOREXIT)
03112: continue;
03113:
03114: if (info != null
03115: && info[table1.getEndOfGuardRegion() - 1] == JvmOpCodes.MONITOREXIT) {
03116:
03117: continue;
03118: }
03119:
03120: if (table1.getStartOfGuardRegion() == table1
03121: .getStartOfHandlerForGuardRegion())
03122: continue;
03123: // Another invalid to check
03124: if (table1.getEndOfGuardRegion() > table1
03125: .getStartOfHandlerForGuardRegion())
03126: continue;
03127:
03128: int next = z + 1;
03129: if (next < tableList.size()) {
03130: ExceptionTable table2 = (ExceptionTable) tableList
03131: .get(next);
03132: int epc = table1.getEndPC();
03133: int spc = table2.getStartPC();
03134: if (i >= epc && i < spc)// &&
03135: // table2.getStartOfGuardRegion()
03136: // < table2.getS )
03137: {
03138: boolean sometrystart = isThisTryStart(i);
03139: ArrayList skipWithinSkip = checkForskipWithinSkip(
03140: epc, spc, info);
03141: if (!sometrystart
03142: && skipWithinSkip.contains(new Integer(
03143: i)) == false) {
03144:
03145: boolean endoftrycatch = checkForEndOfTryCatch(i);
03146:
03147: skip = true;
03148: break;
03149: }
03150: }
03151:
03152: } else
03153: break;
03154: }
03155: }
03156: }
03157:
03158: }
03159:
03160: // test case NativeExtensionInstaller.class in plugin.jar(j2sdk)
03161:
03162: if (skip) {
03163:
03164: ArrayList alist = behaviour.getExceptionTableList();
03165: if (alist != null && alist.size() > 0) {
03166: for (int j = 0; j < alist.size(); j++) {
03167: ExceptionTable xt = (ExceptionTable) alist.get(j);
03168: boolean invalid = false;
03169: if (xt.getStartPC() == xt.getStartOfHandler()) {
03170: invalid = true;
03171: }
03172: if (xt.getStartPC() > xt.getStartOfHandler()) {
03173: invalid = true;
03174: }
03175: if (xt.getStartPC() == i && !invalid) {
03176: skip = false;
03177: break;
03178: }
03179:
03180: }
03181:
03182: }
03183:
03184: }
03185: if (skip && skipDueToSynch) {
03186: String synchEntry = pollsynchblocks(currentForIndex);
03187: if (synchEntry != null && synchEntry.trim().length() > 0) {
03188: behaviour.appendToBuffer(Util
03189: .formatDecompiledStatement(synchEntry));
03190: }
03191:
03192: }
03193:
03194: return skip;
03195:
03196: }
03197:
03198: private boolean alreadyPresent(ArrayList AL, ExceptionTable etb) {
03199: boolean present = false;
03200: for (int jj = 0; jj < AL.size(); jj++) {
03201: ExceptionTable t = (ExceptionTable) AL.get(jj);
03202: int start = t.getStartOfGuardRegion();
03203: int end = t.getEndOfGuardRegion();
03204: if (start == etb.getStartOfGuardRegion()
03205: && end == etb.getEndOfGuardRegion()) {
03206: present = true;
03207: break;
03208: } else
03209: present = false;
03210: }
03211: if (present == false) {
03212:
03213: for (int jj = 0; jj < AL.size(); jj++) {
03214: ExceptionTable t = (ExceptionTable) AL.get(jj);
03215: int start = t.getStartOfGuardRegion();
03216: int endPC = t.getEndPC();
03217: int handlerPC = t.getStartOfHandler();
03218: if (start == etb.getStartPC()) {
03219: int etbendPC = etb.getEndPC();
03220: if (etbendPC > endPC && etbendPC < handlerPC) {
03221: // present=true; // NOTE: commented on 16 oct by belurs
03222: // As it was preventing a try from appearing
03223:
03224: // TODO: Continuous thoruough testing of
03225: // try/catch/finally
03226: break; // Necessary
03227: }
03228:
03229: }
03230: }
03231:
03232: }
03233: if (!present) {
03234: if (synchSkips != null && synchSkips.size() > 0) {
03235:
03236: Iterator it = synchSkips.entrySet().iterator();
03237: while (it.hasNext()) {
03238:
03239: Map.Entry e = (Map.Entry) it.next();
03240: Integer st = (Integer) e.getKey();
03241: Integer en = (Integer) e.getValue();
03242: if (etb.getStartOfHandlerForGuardRegion() >= st.intValue()
03243: && etb.getStartOfHandlerForGuardRegion() <= en
03244: .intValue()) {
03245: present = true;
03246: break;
03247: }
03248:
03249: }
03250:
03251: }
03252: }
03253:
03254: return present;
03255:
03256: }
03257:
03258: boolean casefound = false;
03259:
03260: private java.lang.String pollSwitchBlksForMethod(int i, byte[] info) {
03261:
03262: casefound = false;
03263: java.lang.String stmt = "";
03264: boolean processed = false;
03265: ArrayList allswitches = behaviour.getAllSwitchBlks();
03266: ArrayList starts = behaviour.getInstructionStartPositions();
03267: if (allswitches != null) {
03268:
03269: for (int start = 0; start < allswitches.size(); start++) {
03270: Switch switchblk = (Switch) allswitches.get(start);
03271: ArrayList allcases = switchblk.getAllCases();
03272: allcases = sortCasesByStart(allcases);
03273: if (allcases.size() > 0) {
03274: Case lc = switchblk.getLastBlockForSwitch();
03275: for (int c = 0; c < allcases.size(); c++) {
03276:
03277: Case caseblk = (Case) allcases.get(c);
03278: int defEnd = switchblk.getDefaultEnd();
03279: if (defEnd == i && lc == null) {
03280: if (switchblk.isDefaultStarted()) {
03281: if (switchblk.defaultToBeDisplayed()
03282: && !switchblk.isDefaultEnded()) {
03283: if (lc == null) {
03284: int howmany = checkForEmbeddedSwitches(
03285: allswitches, switchblk
03286: .getDefaultStart(),
03287: defEnd, switchblk, null);
03288: StringBuffer closebrackets = new StringBuffer(
03289: "");
03290: for (int t = 1; t <= howmany; t++) {
03291: closebrackets.append("\n}\n}\n");
03292: }
03293: stmt += Util
03294: .formatDecompiledStatement(closebrackets
03295: .toString());
03296: }
03297: StringBuffer S = new StringBuffer("");
03298: addAnyReurnAtDefaultEnd(i, opStack, info, S);
03299: stmt += Util.formatDecompiledStatement(S
03300: .toString()
03301: + "\n");
03302: S = new StringBuffer("");
03303: addAnyAThorwAtDefaultEnd(i, opStack, info,
03304: S);
03305: stmt += Util.formatDecompiledStatement(S
03306: .toString()
03307: + "\n");
03308: if (isThisInstrStart(starts,
03309: currentForIndex - 3)
03310: && info[currentForIndex - 3] == JvmOpCodes.GOTO) {
03311: stmt += Util
03312: .formatDecompiledStatement("break;\n");
03313: }
03314: stmt += Util.formatDecompiledStatement("}");
03315: switchblk.setDefaultEnded(true);
03316: if (switchblk.getEndOfSwitch() == i
03317: && !switchblk.hasBeenClosed()) {
03318: stmt += Util
03319: .formatDecompiledStatement("}");
03320: switchblk.setSwitchClosed(true);
03321: }
03322:
03323: }
03324: }
03325:
03326: }
03327:
03328: java.lang.String temp = "";
03329: if (caseblk.getCaseStart() == i) {
03330: if (caseblk.isFallsThru()) {
03331: // Util.forceBeginStartSpace=false;
03332: stmt += "\n ";
03333: // stmt+=Util.formatDecompiledStatement("// Case
03334: // Falls Through\n");
03335: Util.forceBeginStartSpace = true;
03336: }
03337:
03338: StringBuffer total = new StringBuffer("");
03339: boolean multiple = checkForMultipleCases(switchblk,
03340: allcases, i, total);
03341: if (multiple) {
03342: temp = getMultipleCaseStartAsString(switchblk,
03343: allcases, i, total);
03344: if (temp != null && temp.length() > 0) {
03345: casefound = true;
03346: }
03347: } else {
03348: if (!caseblk.isWasCaseStartedPrinted()) {
03349: temp = "case " + caseblk.getCaseLabel()
03350: + ":\n{\n";
03351: caseblk.setWasCaseStartedPrinted(true);
03352: }
03353: casefound = true;
03354: }
03355: processed = true;
03356: if (!temp.startsWith("\n")) {
03357: Util.forceTrimLines = false;
03358: temp = "\n" + temp;
03359: }
03360: stmt += Util.formatDecompiledStatement(temp);
03361: Util.forceTrimLines = true;
03362: temp = "";
03363: return stmt;
03364:
03365: }
03366: if (caseblk.getCaseEnd() == i
03367: && !caseblk.isDoNotClose()) {
03368:
03369: /*
03370: * if(caseblk.isGotoAsEndForCase()==false) { //TODO
03371: * detect break at case end }
03372: */
03373:
03374: if (caseblk.isFallsThru() == false
03375: && caseblk.isGotoAsEndForCase())
03376: temp += "break;\n";
03377: temp = Util.formatDecompiledStatement(temp);
03378: int howmany = 0;
03379: if (lc != null)
03380: howmany = checkForEmbeddedSwitches(allswitches,
03381: caseblk.getCaseEnd(), caseblk
03382: .getCaseStart(), switchblk, lc);
03383: StringBuffer closebrackets = new StringBuffer("");
03384: for (int t = 1; t <= howmany; t++) {
03385: closebrackets.append("\n}\n}\n");
03386: }
03387: temp += Util
03388: .formatDecompiledStatement(closebrackets
03389: .toString());
03390:
03391: // //Case End
03392: int caselabelpos = switchblk
03393: .getPositionForLabelInCaseGroupWithSameStarts(caseblk
03394: .getCaseLabel());
03395: java.lang.String tempString = "";
03396: if (caselabelpos > 1) {
03397: tempString = "\n";
03398: } else {
03399: tempString = "\n}\n";
03400: }
03401: caseblk.setClosed(true);
03402: temp += Util.formatDecompiledStatement(tempString);
03403: ArrayList allcasesDUP = switchblk.getAllCases();
03404: tempString = "";
03405: stmt += temp;
03406: temp = "";
03407: if (allcasesDUP.size() > 0) {
03408: for (int c2 = 0; c2 < allcasesDUP.size(); c2++) {
03409: Case caseblkDUP = (Case) allcasesDUP
03410: .get(c2);
03411: if (caseblkDUP.getCaseStart() == i) {
03412: if (caseblkDUP.isFallsThru()) {
03413: // tempString+=Util.formatDecompiledStatement("//
03414: // Case Falls Through\n");
03415: }
03416: StringBuffer total = new StringBuffer(
03417: "");
03418: boolean multiple = checkForMultipleCases(
03419: switchblk, allcases, i, total);
03420: if (multiple) {
03421: java.lang.String ms = getMultipleCaseStartAsString(
03422: switchblk, allcases, i,
03423: total);
03424: if (ms != null && ms.length() > 0) {
03425: tempString += ms;
03426: casefound = true;
03427: }
03428: } else {
03429: if (!caseblkDUP
03430: .isWasCaseStartedPrinted()) {
03431: tempString += "case "
03432: + caseblkDUP
03433: .getCaseLabel()
03434: + ": \n{\n";
03435: caseblkDUP
03436: .setWasCaseStartedPrinted(true);
03437: }
03438: casefound = true;
03439: }
03440:
03441: temp += Util
03442: .formatDecompiledStatement(tempString);
03443: stmt += temp;
03444: break;
03445: }
03446:
03447: }
03448: }
03449:
03450: temp = "";
03451: tempString = "";
03452: // Now check with default:
03453: if (i == switchblk.getDefaultStart()
03454: && switchblk.defaultToBeDisplayed()
03455: && i != switchblk.getDefaultEnd()
03456: && !switchblk.isDefaultStarted()) {
03457: boolean invalidDef = BranchHelper
03458: .checkForInvalidDefault(switchblk
03459: .getDefaultStart(), switchblk
03460: .getStartOfSwitch());
03461: if (!invalidDef) {
03462: tempString = "default:\n{\n";
03463: temp += Util
03464: .formatDecompiledStatement(tempString);
03465: switchblk.setDefaultStarted(true);
03466: } else {
03467: switchblk.setDisplayDefault(false);
03468: switchblk.setDefaultStarted(false);
03469: }
03470: }
03471: if (i == switchblk.getDefaultStart()
03472: && !switchblk.defaultToBeDisplayed()) {
03473: // Case end
03474: tempString = "\n}\n";
03475: temp += Util
03476: .formatDecompiledStatement(tempString);
03477: }
03478:
03479: // poll for switch end
03480: if (lc != null) {
03481: if (i == lc.getCaseEnd()) {
03482: // //switch end
03483: if (!switchblk.hasBeenClosed()) {
03484: tempString = "\n}\n";
03485: temp += Util
03486: .formatDecompiledStatement(tempString);
03487: switchblk.setSwitchClosed(true);
03488: }
03489:
03490: }
03491:
03492: }
03493: stmt += temp;
03494: temp = "";
03495: tempString = "";
03496: // return stmt;
03497: }
03498: }
03499: // check default
03500:
03501: }
03502: int defStart = switchblk.getDefaultStart();
03503: if (defStart == i && switchblk.defaultToBeDisplayed()
03504: && !switchblk.isDefaultStarted()) {
03505: boolean invalidDef = BranchHelper.checkForInvalidDefault(
03506: switchblk.getDefaultStart(), switchblk
03507: .getStartOfSwitch());
03508: if (!invalidDef) {
03509: stmt += Util.formatDecompiledStatement("default:\n{\n");
03510: // stmt=Util.formatDecompiledStatement(stmt);
03511: switchblk.setDefaultStarted(true);
03512: } else {
03513: switchblk.setDefaultStarted(false);
03514: switchblk.setDisplayDefault(false);
03515: }
03516: // return stmt;
03517: }
03518: int defEnd = switchblk.getDefaultEnd();
03519: if (defEnd == i) {
03520: if (switchblk.isDefaultStarted()) {
03521: if (switchblk.defaultToBeDisplayed()
03522: && !switchblk.isDefaultEnded()) {
03523: Case lc = switchblk.getLastBlockForSwitch();
03524: if (lc == null) {
03525: int howmany = checkForEmbeddedSwitches(
03526: allswitches, switchblk
03527: .getDefaultStart(), defEnd,
03528: switchblk, null);
03529: StringBuffer closebrackets = new StringBuffer(
03530: "");
03531: for (int t = 1; t <= howmany; t++) {
03532: closebrackets.append("\n}\n}\n");
03533: }
03534: stmt += Util
03535: .formatDecompiledStatement(closebrackets
03536: .toString());
03537: }
03538: StringBuffer S = new StringBuffer("");
03539: addAnyReurnAtDefaultEnd(i, opStack, info, S);
03540: stmt += Util.formatDecompiledStatement(S.toString()
03541: + "\n");
03542: S = new StringBuffer("");
03543: addAnyAThorwAtDefaultEnd(i, opStack, info, S);
03544: stmt += Util.formatDecompiledStatement(S.toString()
03545: + "\n");
03546: if (isThisInstrStart(starts, currentForIndex - 3)
03547: && info[currentForIndex - 3] == JvmOpCodes.GOTO) {
03548: stmt += Util
03549: .formatDecompiledStatement("break;\n");
03550: }
03551: if (!switchblk.isDoNotCloseDefault()) // otherwise
03552: // already
03553: // closed
03554: stmt += Util.formatDecompiledStatement("}\n");// Default
03555: // end
03556: if (!switchblk.hasBeenClosed())
03557: stmt += Util.formatDecompiledStatement("\n}\n");
03558: switchblk.setDefaultEnded(true);
03559: switchblk.setSwitchClosed(true);
03560: } else {
03561: // Switch end
03562: if (!switchblk.hasBeenClosed()) {
03563: stmt += Util.formatDecompiledStatement("}\n");
03564: switchblk.setSwitchClosed(true);
03565: }
03566: }
03567:
03568: switchblk.setDefaultEnded(true);
03569: }
03570: // return stmt;
03571: }
03572:
03573: }
03574:
03575: }
03576: return stmt;
03577: }
03578:
03579: public int checkForEmbeddedSwitches(ArrayList switches, int end, int start,
03580: Switch current, Case lastblk) {
03581:
03582: int counter = 0;
03583: for (int z = 0; z < switches.size(); z++) {
03584: Switch switchblk = (Switch) switches.get(z);
03585: Case currentLC = switchblk.getLastBlockForSwitch();
03586: int currentEnd = -1;
03587: if (currentLC != null) {
03588: currentEnd = currentLC.getCaseEnd();
03589: } else {
03590: currentEnd = switchblk.getDefaultEnd();
03591: }
03592: if (switchblk != current && currentEnd == end
03593: && switchblk.getStartOfSwitch() > start) {
03594: if (!switchblk.hasBeenClosed()) {
03595: counter++;
03596:
03597: switchblk.setSwitchClosed(true);
03598: if (currentLC != null) {
03599: currentLC.setClosed(true);
03600: } else {
03601: switchblk.setDefaultEnded(true);
03602: }
03603:
03604: }
03605: }
03606: }
03607: return counter;
03608: }
03609:
03610: private boolean isPrevInstructionAload(int pos, byte[] code, StringBuffer sb) {
03611: boolean present = false;
03612: int pos1 = pos - 1;
03613: int pos2 = pos - 2;
03614: int jvmInst_1 = -1;
03615: int jvmInst_2 = -1;
03616: if (pos1 >= 0)
03617: jvmInst_1 = code[pos1];
03618: if (pos2 >= 0)
03619: jvmInst_2 = code[pos2];
03620: if (pos1 != -1) {
03621: switch (jvmInst_1) {
03622:
03623: case JvmOpCodes.ALOAD_0:
03624: case JvmOpCodes.ALOAD_1:
03625: case JvmOpCodes.ALOAD_2:
03626: case JvmOpCodes.ALOAD_3:
03627: present = true;
03628: break;
03629: default:
03630: present = false;
03631: break;
03632:
03633: }
03634: }
03635: if (present)
03636: sb.append(pos1);
03637: if (present == false) {
03638:
03639: if (jvmInst_2 == JvmOpCodes.ALOAD) {
03640: present = true;
03641: sb.append(pos2);
03642: }
03643:
03644: }
03645:
03646: return present;
03647: }
03648:
03649: private boolean checkForReturn(byte[] code, int i) {
03650: boolean present = false;
03651: int jvmInst = code[i];
03652: boolean b = isThisInstrStart(behaviour.getInstructionStartPositions(),
03653: i);
03654: if (b == false)
03655: return false;
03656: switch (jvmInst) {
03657: case JvmOpCodes.ARETURN:
03658: case JvmOpCodes.IRETURN:
03659: case JvmOpCodes.FRETURN:
03660: case JvmOpCodes.DRETURN:
03661: case JvmOpCodes.LRETURN:
03662: case JvmOpCodes.RETURN:
03663: present = true;
03664: break;
03665: default:
03666: present = false;
03667: break;
03668: }
03669: return present;
03670: }
03671:
03672: private boolean isIEndOfGuard(int i, Behaviour behaviour) {
03673: boolean end = false;
03674:
03675: ArrayList alltries = behaviour.getAllTriesForMethod();
03676: Iterator it = alltries.iterator();
03677: while (it.hasNext()) {
03678:
03679: TryBlock Try = (TryBlock) it.next();
03680: if (Try != null) {
03681: int endoftry = Try.getEnd();
03682: if (endoftry == i) // check for try's end
03683: {
03684: end = true;
03685: break;
03686: } else // Check for catches
03687: {
03688: ArrayList catches = Try.getAllCatchesForThisTry();
03689: for (int s = 0; s < catches.size(); s++) {
03690:
03691: CatchBlock catchblk = (CatchBlock) catches.get(s);
03692: if (catchblk != null) {
03693: int catchend = catchblk.getEnd();
03694: if (catchend == i) {
03695: end = true;
03696: break;
03697: }
03698:
03699: }
03700:
03701: }
03702:
03703: }
03704:
03705: }
03706: }
03707:
03708: return end;
03709: }
03710:
03711: private java.lang.String isAnyReturnPresentInSkipRegion(byte[] info, int i,
03712: Behaviour behaviour, StringBuffer stb) {
03713: boolean exit = false;
03714: java.lang.String ret = "";
03715: ArrayList tries = this .behaviour.getAllTriesForMethod();
03716: Iterator triesIT = tries.iterator();
03717: while (triesIT.hasNext()) {
03718: TryBlock TRY = (TryBlock) triesIT.next();
03719: ArrayList catches = TRY.getAllCatchesForThisTry();
03720: Iterator catchesIT = catches.iterator();
03721: TryCatchFinally prevBlock = TRY;
03722: while (catchesIT.hasNext()) {
03723: CatchBlock Catch = (CatchBlock) catchesIT.next();
03724: TryCatchFinally curBlock = Catch;
03725:
03726: if (i >= prevBlock.getEnd() && i < curBlock.getStart()) {
03727:
03728: java.lang.String retStmt = getReturnInstinRange(info, i,
03729: curBlock.getStart(), stb);
03730: ret = retStmt;
03731: exit = true;
03732: break;
03733: }
03734: prevBlock = curBlock;
03735: }
03736: if (exit)
03737: break;
03738: // Check for Finally Block
03739: if (!exit) {
03740: FinallyBlock Finally = TRY.getFinallyBlock();
03741: if (Finally != null) {
03742: CatchBlock catchblock = TRY.getLastCatchBlock();
03743: if (catchblock != null) {
03744:
03745: if (i >= catchblock.getEnd() && i < Finally.getStart()) {
03746: java.lang.String retStmt = getReturnInstinRange(
03747: info, i, Finally.getStart(), stb);
03748: ret = retStmt;
03749: break;
03750: }
03751: } else {
03752: if (i >= TRY.getEnd() && i < Finally.getStart()) {
03753: java.lang.String retStmt = getReturnInstinRange(
03754: info, i, Finally.getStart(), stb);
03755: ret = retStmt;
03756: break;
03757: }
03758: }
03759:
03760: }
03761: }
03762:
03763: if (ret.length() == 0) {
03764:
03765: if (i == TRY.getEnd()) {
03766: java.lang.String retStmt = getReturnInstinRange(info, i,
03767: i + 1, stb);
03768: ret = retStmt;
03769: break;
03770: }
03771:
03772: }
03773: }
03774:
03775: return ret;
03776: }
03777:
03778: private java.lang.String getReturnInstinRange(byte[] info, int i,
03779: int blockstart, StringBuffer sb) {
03780:
03781: for (int s = i; s < blockstart; s++) {
03782: int jvmInst = info[s];
03783: switch (jvmInst) {
03784: case JvmOpCodes.IRETURN:
03785: sb.append(s);
03786: return "ireturn";
03787: case JvmOpCodes.LRETURN:
03788: sb.append(s);
03789: return "lreturn";
03790: case JvmOpCodes.FRETURN:
03791: sb.append(s);
03792: return "freturn";
03793: case JvmOpCodes.DRETURN:
03794: sb.append(s);
03795: return "dreturn";
03796: case JvmOpCodes.ARETURN:
03797: sb.append(s);
03798: return "areturn";
03799: case JvmOpCodes.RETURN:
03800: sb.append(s);
03801: return "return";
03802: default:
03803: continue;
03804:
03805: }
03806:
03807: }
03808: sb.append("-1");
03809: return null;
03810:
03811: }
03812:
03813: private int getReturnStringPosInCode(byte[] info, int i, Behaviour behaviour) {
03814: int pos = -1;
03815: boolean exit = false;
03816:
03817: ArrayList tries = this .behaviour.getAllTriesForMethod();
03818: Iterator triesIT = tries.iterator();
03819: while (triesIT.hasNext()) {
03820: TryBlock TRY = (TryBlock) triesIT.next();
03821: ArrayList catches = TRY.getAllCatchesForThisTry();
03822: Iterator catchesIT = catches.iterator();
03823: TryCatchFinally prevBlock = TRY;
03824: while (catchesIT.hasNext()) {
03825: CatchBlock Catch = (CatchBlock) catchesIT.next();
03826: TryCatchFinally curBlock = Catch;
03827:
03828: if (i >= prevBlock.getEnd() && i < curBlock.getStart()) {
03829:
03830: pos = getReturnInstPosInRange(info, i, curBlock.getStart());
03831: exit = true;
03832: break;
03833: }
03834: prevBlock = curBlock;
03835: }
03836: if (exit)
03837: break;
03838: // Check for Finally Block
03839: if (!exit) {
03840: FinallyBlock Finally = TRY.getFinallyBlock();
03841: if (Finally != null) {
03842: CatchBlock catchblock = TRY.getLastCatchBlock();
03843: if (catchblock != null) {
03844:
03845: if (i >= catchblock.getEnd() && i < Finally.getStart()) {
03846:
03847: pos = getReturnInstPosInRange(info, i, Finally
03848: .getStart());
03849: break;
03850: }
03851: } else {
03852: if (i >= TRY.getEnd() && i < Finally.getStart()) {
03853: pos = getReturnInstPosInRange(info, i, Finally
03854: .getStart());
03855:
03856: break;
03857: }
03858: }
03859:
03860: }
03861: }
03862: if (i == TRY.getEnd()) {
03863: pos = getReturnInstPosInRange(info, i, i + 1);
03864:
03865: break;
03866: }
03867: } // Shutdown d;
03868: return pos;
03869: }
03870:
03871: private int getReturnInstPosInRange(byte[] info, int i, int blockstart) {
03872:
03873: for (int s = i; s < blockstart; s++) {
03874: int jvmInst = info[s];
03875: switch (jvmInst) {
03876: case JvmOpCodes.IRETURN:
03877: case JvmOpCodes.LRETURN:
03878: case JvmOpCodes.FRETURN:
03879: case JvmOpCodes.DRETURN:
03880: case JvmOpCodes.ARETURN:
03881: case JvmOpCodes.RETURN:
03882: return s;
03883: default:
03884: continue;
03885:
03886: }
03887:
03888: }
03889:
03890: return -1;
03891:
03892: }
03893:
03894: private int findCodeIndexFromInfiniteLoop(IFBlock ifst,
03895: ArrayList LoopTable, int codeIndex) {
03896: Iterator iterInfLoop = LoopTable.iterator();
03897: int start = ifst.getIfStart();
03898: int loopstarts[] = new int[LoopTable.size()];
03899: int j = 0;
03900: boolean ok = false;
03901: while (iterInfLoop.hasNext()) {
03902: Loop iloop = (Loop) iterInfLoop.next();
03903: int lstart = iloop.getStartIndex();
03904: loopstarts[j] = lstart;
03905: j++;
03906: ok = true;
03907: /*
03908: * if(iloop.getStartIndex() == codeIndex) { return
03909: * iloop.getEndIndex(); }
03910: */
03911: }
03912: if (ok) {
03913: for (int z = loopstarts.length - 1; z >= 0; z--) {
03914:
03915: if (loopstarts[z] < start) {
03916: int end = getloopEndForStart(LoopTable, loopstarts[z]);
03917: if (end < start)
03918: return -1;
03919: return end;
03920: }
03921:
03922: }
03923: }
03924:
03925: return -1;
03926: }
03927:
03928: private boolean isIndexEndOfLoop(ArrayList list, int s) {
03929: boolean ok = false;
03930: for (int st = 0; st < list.size(); st++) {
03931: if (((Loop) list.get(st)).getEndIndex() == s)
03932: return true;
03933: }
03934: return ok;
03935: }
03936:
03937: private int getLoopStartForEnd(int s, ArrayList list) {
03938: for (int k = 0; k < list.size(); k++) {
03939: Loop l = (Loop) list.get(k);
03940: if (l.getEndIndex() == s)
03941: return l.getStartIndex();
03942: }
03943: return -1;
03944: }
03945:
03946: private Collection curentIFS;
03947:
03948: private Collection getCurrentIFStructues() {
03949: if (behaviour.getMethodIfs() != null
03950: && behaviour.getMethodIfs().size() > 0) {
03951: curentIFS = behaviour.getMethodIfs();
03952: return curentIFS;
03953: } else
03954: return null;
03955: }
03956:
03957: private Object[] sortIFStructures() {
03958: if (curentIFS != null && curentIFS.size() > 0) {
03959: Object o[] = curentIFS.toArray();
03960: Arrays.sort(o);
03961: return o;
03962: } else
03963: return null;
03964: }
03965:
03966: private IFBlock getParentBlock(Object o[], int startOfIf) {
03967:
03968: IFBlock parent = null;
03969: int reqdPos = -1;
03970: for (int s = 0; s < o.length; s++) {
03971: if (o[s] instanceof IFBlock) {
03972: IFBlock IF = (IFBlock) o[s];
03973: if (IF.getIfStart() == startOfIf) {
03974: recheck: while (true) {
03975: if (s > 0) {
03976: reqdPos = s - 1;
03977: IFBlock pif = (IFBlock) o[reqdPos];
03978: boolean n = isIFShortcutORComp(behaviour.getCode(),
03979: pif.getIfStart());
03980: if (n) {
03981: int first = sanalyser.getFirstIfInChain(pif
03982: .getIfStart());
03983: // Find the position in the array
03984: for (int p = o.length - 1; p >= 0; p--) {
03985: if (((IFBlock) o[p]).getIfStart() == first) {
03986: s = p;
03987: continue recheck;
03988: }
03989: }
03990: return null;
03991: }
03992: return pif;
03993: } else {
03994: return null;
03995: }
03996: }
03997: }
03998:
03999: } else {
04000: return null;
04001: }
04002: }
04003: return null;
04004: }
04005:
04006: // Primarily use it for goto and some special cases where appplicable
04007: private int getJumpAddress(byte[] info, int counter) {
04008:
04009: int b1 = info[++counter];
04010: int b2 = info[++counter];
04011: int z;
04012: if (b1 < 0)
04013: b1 = (256 + b1);
04014: if (b2 < 0)
04015: b2 = (256 + b2);
04016:
04017: int indexInst = ((((b1 << 8) | b2)) + (counter - 2));
04018: if (indexInst > 65535)
04019: indexInst = indexInst - 65536;
04020: if (indexInst < 0)
04021: indexInst = 256 + indexInst;
04022: return indexInst;
04023: }
04024:
04025: private int getOffset(byte[] info, int counter) {
04026:
04027: int b1 = info[++counter];
04028: int b2 = info[++counter];
04029: int z;
04030: if (b1 < 0)
04031: b1 = (256 + b1);
04032: if (b2 < 0)
04033: b2 = (256 + b2);
04034:
04035: int indexInst = (((b1 << 8) | b2));
04036: if (indexInst > 65535)
04037: indexInst = indexInst - 65536;
04038: if (indexInst < 0)
04039: indexInst = 256 + indexInst;
04040: return indexInst;
04041: }
04042:
04043: private int checkIfElseCloseNumber(int end, IFBlock ifs) {
04044: int ifend = -1;
04045: this .getCurrentIFStructues();
04046: Object ifsSorted[] = sortIFStructures();
04047: IFBlock parent = getParentBlock(ifsSorted, ifs.getIfStart());
04048: if (parent == null) {
04049:
04050: int temp = checkLoopsAndSwitchForIfEnd(end, ifs, behaviour);
04051: if (temp != -1)
04052: ifend = temp;
04053: else
04054: ifend = end;
04055: } else {
04056: ifend = reEvaluateIFStart(ifs, ifsSorted, parent, end);
04057: int temp2 = checkLoopsAndSwitchForIfEnd(ifend, ifs, behaviour);
04058: if (temp2 < ifend && temp2 != -1) {
04059: ifend = temp2;
04060: }
04061: }
04062: return ifend;
04063: }
04064:
04065: private int reEvaluateIFStart(IFBlock ifs, Object[] ifsSorted,
04066: IFBlock parent, int currentEnd) {
04067: int ifend = -1;
04068: int parentEnd = parent.getIfCloseLineNumber();
04069: int this Start = ifs.getIfStart();
04070: if (this Start < parentEnd) {
04071: if (currentEnd > parentEnd) {
04072: // belurs:
04073: // Test case BigInteger.class
04074: /***************************************************************
04075: * BasicallY this part of the code is not bug free. It assumes
04076: * that if the parentIF is ending before this if end is ending
04077: * then this ifend is wrong. Well, it worked for every case
04078: * until BigInteger ws decompiled. So basically resetting parent
04079: * if end to this if end if parent if end was not a GOTO
04080: * instruction.
04081: */
04082: // Test for The above case
04083: // found while testing XmlReader.class
04084: // Above Fix Affects XmlReader.class
04085: // SO test for bytecode ends for all ifs
04086: // if all are same dont go into IF
04087: boolean noif = false;
04088: if (ifs.getIfCloseFromByteCode() == parent
04089: .getIfCloseFromByteCode()) {
04090: noif = true;
04091: }
04092:
04093: if (noif == false
04094: && (behaviour.getCode()[parentEnd] != JvmOpCodes.GOTO)
04095: && (behaviour.getCode()[parentEnd] != JvmOpCodes.GOTO_W)) {
04096: ifend = currentEnd;
04097: parent.setIfCloseLineNumber(ifend);
04098:
04099: } else {
04100:
04101: ifend = parentEnd;
04102: }
04103:
04104: } else if (currentEnd < this Start) {
04105: ifend = parentEnd;
04106: } else
04107: ifend = currentEnd;
04108:
04109: } // Need to handle thisif end inside parent's else end
04110: /*
04111: * else if(thisStart > parentEnd) { boolean
04112: * doesParentHaveElse=parent.isHasElse(); if(doesParentHaveElse) { int
04113: * parentElseEnd=parent.getElseCloseLineNumber(); if(thisStart <
04114: * parentElseEnd) { // Within parent else block if(currentEnd >
04115: * parentElseEnd) { ifend=parentElseEnd; } else if(currentEnd <
04116: * thisStart) { ifend=parentElseEnd; } else { ifend=currentEnd; }
04117: *
04118: * BigInteger b; } } }
04119: */
04120: else {
04121:
04122: IFBlock super parent = getParentBlock(ifsSorted, parent.getIfStart());
04123: if (super parent == null) {
04124: int temp = checkLoopsAndSwitchForIfEnd(currentEnd, ifs,
04125: behaviour);
04126: if (temp != -1)
04127: ifend = temp;
04128: else
04129: ifend = currentEnd;
04130:
04131: } else {
04132: int tmp = reEvaluateIFStart(ifs, ifsSorted, super parent,
04133: currentEnd);
04134: ifend = tmp;
04135:
04136: }
04137:
04138: }
04139:
04140: return ifend;
04141:
04142: }
04143:
04144: private Object[] sortLoops(ArrayList list) {
04145: Object o[] = list.toArray();
04146: Arrays.sort(o);
04147: return o;
04148: }
04149:
04150: private int getParentLoopStartForIf(Object[] sortedloops, int ifbegin) {
04151: int reqdStart = -1;
04152: int max = -1;
04153: int pos = 0;
04154: int counter = sortedloops.length - 1;
04155: while (counter >= 0) {
04156: Object o = sortedloops[counter];
04157: if (o instanceof Loop) {
04158: Loop l = (Loop) o;
04159: int ls = l.getStartIndex();
04160: int this LoopEnd = getloopEndForStart(behaviour
04161: .getBehaviourLoops(), ls);
04162: if (ls < ifbegin && !(ifbegin > this LoopEnd)) {
04163: reqdStart = ls;
04164: break;
04165: }
04166:
04167: }
04168: counter--;
04169: }
04170: return reqdStart;
04171:
04172: }
04173:
04174: private Loop getParentLoopForIf(Object[] sortedloops, int ifbegin) {
04175: int reqdStart = -1;
04176: Loop reqdl = null;
04177: int max = -1;
04178: int pos = 0;
04179: int counter = sortedloops.length - 1;
04180: while (counter >= 0) {
04181: Object o = sortedloops[counter];
04182: if (o instanceof Loop) {
04183: Loop l = (Loop) o;
04184: int ls = l.getStartIndex();
04185: int this LoopEnd = getloopEndForStart(behaviour
04186: .getBehaviourLoops(), ls);
04187: if (ls < ifbegin && !(ifbegin > this LoopEnd)) {
04188: reqdStart = ls;
04189: reqdl = l;
04190: break;
04191: }
04192:
04193: }
04194: counter--;
04195: }
04196: return reqdl;
04197:
04198: }
04199:
04200: private java.lang.String getBranchTypeAtI(int i, IFBlock ifst,
04201: StringBuffer sb) {
04202: boolean skip = skipBranchCheck(i);
04203: if (skip)
04204: return "";
04205: Iterator it = GlobalVariableStore.getBranchLabels().entrySet()
04206: .iterator();
04207: while (it.hasNext()) {
04208: Map.Entry e = (Map.Entry) it.next();
04209: int end = ((Integer) (e.getValue())).intValue();
04210: if (end == i) {
04211: DecompilerHelper.BranchLabel b = (DecompilerHelper.BranchLabel) e
04212: .getKey();
04213: IFBlock IF = b.getIF();
04214: if (IF == ifst) {
04215:
04216: if (b.getLBL().trim().length() > 0) {
04217: GlobalVariableStore.getLabelAssociated().put(
04218: new Integer(i), "true");
04219: }
04220: int prev = i - 1;
04221: if (isThisInstrStart(behaviour
04222: .getInstructionStartPositions(), prev)) {
04223: if (behaviour.getCode()[prev] == JvmOpCodes.RETURN) {
04224: return "";
04225: }
04226: }
04227:
04228: sb.append(b.getBrlbl());
04229: return b.getLBL();
04230: }
04231: }
04232:
04233: }
04234:
04235: return "";
04236: }
04237:
04238: private boolean skipBranchCheck(int i) {
04239: boolean b = false;
04240: Iterator it = GlobalVariableStore.getLabelAssociated().entrySet()
04241: .iterator();
04242: while (it.hasNext()) {
04243: Map.Entry e = (Map.Entry) it.next();
04244: java.lang.String skip = ((java.lang.String) (e.getValue()));
04245: int end = ((Integer) e.getKey()).intValue();
04246: if (i == end && skip.equals("true"))
04247: b = true;
04248: }
04249: return b;
04250: }
04251:
04252: private boolean isNewEndValid(int newend, IFBlock ifs,
04253: java.lang.String type, int curend) {
04254:
04255: int end;
04256: if (type.equals("else"))
04257: end = ifs.getElseCloseLineNumber();
04258: else
04259: end = curend;
04260: if (newend == -1)
04261: return false;
04262: if (newend > end) {
04263: return false;
04264: }
04265:
04266: else
04267: return true;
04268: }
04269:
04270: private int resetEndofIFElseWRTSwitch(ArrayList switches, IFBlock anIf,
04271: int curend, int curStart, java.lang.String type) {
04272: int k = -1;
04273: ArrayList possibleCaseEnds = new ArrayList();
04274: ArrayList possibleCaseStarts = new ArrayList();
04275: for (int s = 0; s < switches.size(); s++) {
04276:
04277: Switch swblk = (Switch) switches.get(s);
04278: ArrayList cases = swblk.getAllCases();
04279: for (int c = 0; c < cases.size(); c++) {
04280: Case caseblk = (Case) cases.get(c);
04281: int end = caseblk.getCaseEnd();
04282: int ifelseStart = curStart;
04283: int ifelseEnd;
04284: if (type.equals("else"))
04285: ifelseEnd = anIf.getElseCloseLineNumber();
04286: else {
04287: ifelseEnd = curend;
04288: if (ifelseEnd == -1) {
04289: ifelseEnd = anIf.getIfCloseFromByteCode();
04290: }
04291: }
04292: if (end > ifelseStart && end < ifelseEnd) {
04293: possibleCaseEnds.add(new Integer(end));
04294: possibleCaseStarts.add(new Integer(caseblk.getCaseStart()));
04295: }
04296:
04297: }
04298:
04299: }
04300: int firststart = -1;
04301: if (possibleCaseEnds.size() > 0) {
04302: Integer inte[] = (Integer[]) possibleCaseEnds
04303: .toArray(new Integer[possibleCaseEnds.size()]);
04304: Arrays.sort(inte);
04305: k = inte[0].intValue();
04306:
04307: Integer ints[] = (Integer[]) possibleCaseStarts
04308: .toArray(new Integer[possibleCaseStarts.size()]);
04309: Arrays.sort(ints);
04310: firststart = ints[0].intValue();
04311:
04312: }
04313:
04314: if (firststart != -1 && firststart > anIf.getIfStart()) {
04315: k = -1;
04316: }
04317:
04318: return k;
04319: }
04320:
04321: private int getloopEndForStart(ArrayList list, int start) {
04322: for (int i = 0; i < list.size(); i++) {
04323: Loop l = (Loop) list.get(i);
04324: if (l.getStartIndex() == start) {
04325: return l.getEndIndex();
04326: }
04327: }
04328: return -1;
04329:
04330: }
04331:
04332: private ArrayList sortCasesByStart(ArrayList allcases) {
04333: ArrayList sorted = new ArrayList();
04334: int s[] = new int[allcases.size()];
04335: for (int i = 0; i < allcases.size(); i++) {
04336: s[i] = ((Case) allcases.get(i)).getCaseStart();
04337: }
04338: Arrays.sort(s);
04339: for (int j = 0; j < s.length; j++) {
04340: int c = s[j];
04341: for (int k = 0; k < allcases.size(); k++) {
04342: Case current = (Case) allcases.get(k);
04343: boolean present = caseObjectAddedToSortedArray(current, sorted);
04344: if (!present) {
04345: if (current.getCaseStart() == c) {
04346: sorted.add(current);
04347: break;
04348: }
04349: }
04350: }
04351: }
04352: return sorted;
04353: }
04354:
04355: private int checkLoopsAndSwitchForIfEnd(int end, IFBlock ifs,
04356: Behaviour behaviour) {
04357: byte[] info = behaviour.getCode();
04358: int reqdEnd = -1;
04359: ArrayList loops = behaviour.getBehaviourLoops();
04360: if (loops != null && loops.size() > 0) {
04361:
04362: Object[] sortedLoops = sortLoops(loops);
04363: int parentLoopStart = getParentLoopStartForIf(sortedLoops, ifs
04364: .getIfStart());
04365: int loopend = getloopEndForStart(loops, parentLoopStart);
04366: if (ifs.getIfStart() < loopend
04367: && (end > loopend || end < ifs.getIfStart()))
04368: ifs.setIfCloseLineNumber(loopend);
04369: reqdEnd = ifs.getIfCloseLineNumber();
04370:
04371: }
04372:
04373: ArrayList allswicthes = behaviour.getAllSwitchBlks();
04374: if (allswicthes != null && allswicthes.size() > 0) {
04375:
04376: int newifend = -1;
04377: newifend = resetEndofIFElseWRTSwitch(allswicthes, ifs, reqdEnd,
04378: currentForIndex, "if");
04379: boolean valid = isNewEndValid(newifend, ifs, "if", end);
04380: if (valid) {
04381: ifs.setIfCloseLineNumber(newifend);
04382: reqdEnd = ifs.getIfCloseLineNumber();
04383: // Need to check here for a goto before the case end
04384: int start = ifs.getIfStart();
04385: int bye = ifs.getIfCloseFromByteCode();
04386: ArrayList starts = behaviour.getInstructionStartPositions();
04387: for (int z = reqdEnd; z > start; z--) {
04388:
04389: int inst = info[z];
04390: boolean isSt = isThisInstrStart(starts, z);
04391: if (isSt && (inst == JvmOpCodes.GOTO)
04392: && (getJumpAddress(info, z) == bye)) {
04393: reqdEnd = z;
04394: break;
04395: }
04396:
04397: }
04398:
04399: } else {
04400: if (ifs.getElseCloseLineNumber() == -1) {
04401: ifs.setIfCloseLineNumber(ifs.getIfCloseFromByteCode());
04402: reqdEnd = ifs.getIfCloseLineNumber();// here
04403: } else {
04404: reqdEnd = ifs.getIfCloseLineNumber();
04405: }
04406: }
04407:
04408: }
04409: return reqdEnd;
04410:
04411: }
04412:
04413: private IFBlock getParentIFforLoop(Loop cur, Object ifsorted[]) {
04414: IFBlock par = null;
04415: for (int n = (ifsorted.length - 1); n >= 0; n--) {
04416: if (!(ifsorted[n] instanceof IFBlock))
04417: continue;
04418: IFBlock IF = (IFBlock) ifsorted[n];
04419: int s = IF.getIfStart();
04420: if (s < cur.getStartIndex()) {
04421: par = IF;
04422: break;
04423: }
04424: }
04425: return par;
04426: }
04427:
04428: private int checkEndofLoopWRTIF(IFBlock parentif, Object[] ifsorted,
04429: Loop cur) {
04430: int end = -1;
04431: int parentIFStart = parentif.getIfStart();
04432: int parentIFEnd = parentif.getIfCloseLineNumber();
04433: boolean doesParentHaveElse = parentif.isHasElse();
04434: boolean needToFindSuperParent = false;
04435:
04436: if (cur.getStartIndex() < parentIFEnd) // Yes it lies
04437: {
04438: if (cur.getEndIndex() > parentIFEnd) {
04439: end = parentIFEnd;
04440: return end;
04441: } else {
04442: end = cur.getEndIndex(); // Passes else was correct
04443: return end;
04444: }
04445:
04446: }
04447:
04448: if (cur.getStartIndex() > parentIFEnd) {
04449: if (doesParentHaveElse) {
04450: int parentElseEnd = parentif.getElseCloseLineNumber();
04451: if (cur.getStartIndex() < parentElseEnd) // Lies within the
04452: // else of parent IF
04453: {
04454: if (cur.getEndIndex() > parentElseEnd) {
04455: end = parentElseEnd;
04456: return end;
04457: } else {
04458: end = cur.getEndIndex();
04459: return end;
04460: }
04461: } else {
04462: needToFindSuperParent = true;
04463: }
04464:
04465: } else {
04466: needToFindSuperParent = true;
04467: }
04468:
04469: }
04470: if (needToFindSuperParent) {
04471: IFBlock super Parent = getParentBlock(ifsorted, parentIFStart);
04472: int tmp;
04473: if (super Parent != null)
04474: tmp = checkEndofLoopWRTIF(super Parent, ifsorted, cur);
04475: else {
04476: tmp = cur.getEndIndex();
04477: }
04478: return tmp;
04479: } else {
04480: return cur.getEndIndex(); // Should Never come here
04481: }
04482:
04483: }
04484:
04485: private boolean isThisLoopEndAlso(ArrayList loops, int i, int ifstart) {
04486: for (int s = 0; s < loops.size(); s++) {
04487: Loop l = (Loop) loops.get(s);
04488: int lend = (l).getEndIndex();
04489: if (lend == i && ifstart > l.getStartIndex())
04490: return true;
04491: }
04492: return false;
04493: }
04494:
04495: private boolean doesthis ClashWithCaseBegin(ArrayList switches, int i) {
04496: if (switches == null || switches.size() == 0)
04497: return false;
04498: boolean ret = false;
04499: for (int s = 0; s < switches.size(); s++) {
04500:
04501: Switch swblk = (Switch) switches.get(s);
04502: ArrayList cases = swblk.getAllCases();
04503: for (int k = 0; k < cases.size(); k++) {
04504: Case c = (Case) cases.get(k);
04505: if (c.getCaseStart() == i) {
04506: ret = true;
04507: break;
04508: }
04509: }
04510:
04511: }
04512: return ret;
04513: }
04514:
04515: private boolean isCurrentInstStore(int inst) {
04516: boolean flag;
04517: switch (inst) {
04518:
04519: case JvmOpCodes.ASTORE:
04520: flag = true;
04521: break;
04522:
04523: case JvmOpCodes.ASTORE_0:
04524: flag = true;
04525: break;
04526: case JvmOpCodes.ASTORE_1:
04527: flag = true;
04528: break;
04529: case JvmOpCodes.ASTORE_2:
04530: flag = true;
04531: break;
04532: case JvmOpCodes.ASTORE_3:
04533: flag = true;
04534: break;
04535: case JvmOpCodes.DSTORE:
04536: flag = true;
04537: break;
04538: case JvmOpCodes.DSTORE_0:
04539: flag = true;
04540: break;
04541: case JvmOpCodes.DSTORE_1:
04542: flag = true;
04543: break;
04544: case JvmOpCodes.DSTORE_2:
04545: flag = true;
04546: break;
04547: case JvmOpCodes.DSTORE_3:
04548: flag = true;
04549: break;
04550:
04551: case JvmOpCodes.FSTORE:
04552: flag = true;
04553: break;
04554: case JvmOpCodes.FSTORE_0:
04555: flag = true;
04556: break;
04557: case JvmOpCodes.FSTORE_1:
04558: flag = true;
04559: break;
04560: case JvmOpCodes.FSTORE_2:
04561: flag = true;
04562: break;
04563: case JvmOpCodes.FSTORE_3:
04564: flag = true;
04565: break;
04566:
04567: case JvmOpCodes.ISTORE:
04568: flag = true;
04569: break;
04570: case JvmOpCodes.ISTORE_0:
04571: flag = true;
04572: break;
04573: case JvmOpCodes.ISTORE_1:
04574: flag = true;
04575: break;
04576: case JvmOpCodes.ISTORE_2:
04577: flag = true;
04578: break;
04579: case JvmOpCodes.ISTORE_3:
04580: flag = true;
04581: break;
04582: case JvmOpCodes.LSTORE:
04583: flag = true;
04584: break;
04585:
04586: case JvmOpCodes.LSTORE_0:
04587: flag = true;
04588: break;
04589: case JvmOpCodes.LSTORE_1:
04590: flag = true;
04591: break;
04592: case JvmOpCodes.LSTORE_2:
04593: flag = true;
04594: break;
04595: case JvmOpCodes.LSTORE_3:
04596: flag = true;
04597: break;
04598:
04599: default:
04600: flag = false;
04601: }
04602: return flag;
04603: }
04604:
04605: /***************************************************************************
04606: * NOTE: This is not general purpose method tofind load index inst...Skips
04607: * ceratian loads see usages
04608: *
04609: * @param inst
04610: * @param info
04611: * @param s
04612: * @return
04613: */
04614: public int getLoadInstIndex(int inst, byte info[], int s) {
04615: // chkIndex is the index of the goto instruction.
04616:
04617: switch (inst) {
04618:
04619: case JvmOpCodes.ALOAD:
04620: return info[++s];
04621:
04622: case JvmOpCodes.ALOAD_0:
04623: return 0;
04624:
04625: case JvmOpCodes.ALOAD_1:
04626: return 1;
04627:
04628: case JvmOpCodes.ALOAD_2:
04629: return 2;
04630:
04631: case JvmOpCodes.ALOAD_3:
04632: return 3;
04633:
04634: case JvmOpCodes.DLOAD:
04635: return info[++s];
04636:
04637: case JvmOpCodes.DLOAD_0:
04638: return 0;
04639:
04640: case JvmOpCodes.DLOAD_1:
04641: return 1;
04642:
04643: case JvmOpCodes.DLOAD_2:
04644: return 2;
04645:
04646: case JvmOpCodes.DLOAD_3:
04647: return 3;
04648:
04649: case JvmOpCodes.FLOAD:
04650: return info[++s];
04651:
04652: case JvmOpCodes.FLOAD_0:
04653: return 0;
04654:
04655: case JvmOpCodes.FLOAD_1:
04656: return 1;
04657:
04658: case JvmOpCodes.FLOAD_2:
04659: return 2;
04660:
04661: case JvmOpCodes.FLOAD_3:
04662: return 3;
04663:
04664: case JvmOpCodes.ILOAD:
04665: return info[++s];
04666:
04667: case JvmOpCodes.ILOAD_0:
04668: return 0;
04669:
04670: case JvmOpCodes.ILOAD_1:
04671: return 1;
04672:
04673: case JvmOpCodes.ILOAD_2:
04674: return 2;
04675:
04676: case JvmOpCodes.ILOAD_3:
04677: return 3;
04678:
04679: case JvmOpCodes.LLOAD:
04680: return info[++s];
04681:
04682: case JvmOpCodes.LLOAD_0:
04683: return 0;
04684: case JvmOpCodes.LLOAD_1:
04685: return 1;
04686: case JvmOpCodes.LLOAD_2:
04687: return 2;
04688: case JvmOpCodes.LLOAD_3:
04689: return 3;
04690:
04691: }
04692:
04693: return -1;
04694: }
04695:
04696: private java.lang.String getAnyLabelAtI(Map labels, int i) {
04697: java.lang.String lbl = (java.lang.String) labels.get(new Integer(i));
04698: return lbl;
04699: }
04700:
04701: /***************************************************************************
04702: * NOTE: This is not general purpose method tofind load inst...Skips
04703: * ceratian loads see usages
04704: */
04705: public boolean continueFindingBranchType(int i, byte info[]) {
04706: // chkIndex is the index of the goto instruction.
04707:
04708: switch (info[i]) {
04709:
04710: case JvmOpCodes.ALOAD:
04711:
04712: case JvmOpCodes.ALOAD_0:
04713:
04714: case JvmOpCodes.ALOAD_1:
04715:
04716: case JvmOpCodes.ALOAD_2:
04717:
04718: case JvmOpCodes.ALOAD_3:
04719:
04720: case JvmOpCodes.DLOAD:
04721:
04722: case JvmOpCodes.DLOAD_0:
04723:
04724: case JvmOpCodes.DLOAD_1:
04725:
04726: case JvmOpCodes.DLOAD_2:
04727:
04728: case JvmOpCodes.DLOAD_3:
04729:
04730: case JvmOpCodes.FLOAD:
04731:
04732: case JvmOpCodes.FLOAD_0:
04733:
04734: case JvmOpCodes.FLOAD_1:
04735:
04736: case JvmOpCodes.FLOAD_2:
04737:
04738: case JvmOpCodes.FLOAD_3:
04739:
04740: case JvmOpCodes.ILOAD:
04741:
04742: case JvmOpCodes.ILOAD_0:
04743:
04744: case JvmOpCodes.ILOAD_1:
04745:
04746: case JvmOpCodes.ILOAD_2:
04747:
04748: case JvmOpCodes.ILOAD_3:
04749:
04750: case JvmOpCodes.LLOAD:
04751:
04752: case JvmOpCodes.LLOAD_0:
04753:
04754: case JvmOpCodes.LLOAD_1:
04755:
04756: case JvmOpCodes.LLOAD_2:
04757:
04758: case JvmOpCodes.LLOAD_3:
04759: return true;
04760:
04761: }
04762:
04763: return false;
04764: }
04765:
04766: private boolean isThisIfALoopCondition(IFBlock IF, byte[] info,
04767: ArrayList loops) {
04768: boolean b = true;
04769: int ifend = IF.getIfCloseLineNumber();
04770: int ifs = IF.getIfStart();
04771: boolean b1 = isThisLoopEndAlso(loops, ifend, ifs);
04772: ArrayList list = behaviour.getInstructionStartPositions();
04773: if (!b1)
04774: return false;
04775: if (b1) {
04776: int jump = getJumpAddress(info, ifend);
04777: if (jump >= ifs)
04778: return false;
04779: for (int s = jump; s < ifs; s++) {
04780: int inst = info[s];
04781: boolean b2 = isNextInstructionIf(inst);
04782: if (b2 && isThisInstrStart(list, s)) {
04783: b = false;
04784: return b;
04785: }
04786: }
04787:
04788: }
04789:
04790: return b;
04791:
04792: }
04793:
04794: private java.lang.String getReturnTypeInst(byte[] info, int i) {
04795: switch (info[i]) {
04796: case JvmOpCodes.IRETURN:
04797: return "ireturn";
04798: case JvmOpCodes.LRETURN:
04799: return "lreturn";
04800: case JvmOpCodes.FRETURN:
04801: return "freturn";
04802: case JvmOpCodes.DRETURN:
04803: return "dreturn";
04804: case JvmOpCodes.ARETURN:
04805: return "areturn";
04806: case JvmOpCodes.RETURN:
04807: return "return";
04808: default:
04809: return "";
04810:
04811: }
04812:
04813: }
04814:
04815: private Hashtable handlertracker = new Hashtable();
04816:
04817: private class handlerEndTracker {
04818:
04819: private int start = -1;
04820:
04821: private int end = -1;
04822:
04823: public int getStart() {
04824: return start;
04825: }
04826:
04827: public int getEnd() {
04828: return end;
04829: }
04830:
04831: public java.lang.String getType() {
04832: return type;
04833: }
04834:
04835: private java.lang.String type = "";
04836:
04837: private boolean closed = false;
04838:
04839: handlerEndTracker(int s, int e, java.lang.String t) {
04840: start = s;
04841: end = e;
04842: type = t;
04843: }
04844:
04845: void setClose(boolean c) {
04846: closed = c;
04847: }
04848:
04849: boolean getClosed() {
04850: return closed;
04851: }
04852:
04853: }
04854:
04855: private boolean addhandlerEnd(int i, ExceptionTable table) {
04856: boolean add = true;
04857: Object o = handlertracker.get(new Integer(i));
04858: if (o == null)
04859: return add;
04860: else {
04861: handlerEndTracker h = (handlerEndTracker) o;
04862: if (h.getType().equals(table.getTypeOfHandlerForGuardRegion())) {
04863: if (h.getStart() == table.getStartOfHandlerForGuardRegion()
04864: && h.getEnd() == table.getEndOfHandlerForGuardRegion()) {
04865: return false;
04866: }
04867: }
04868:
04869: }
04870:
04871: return add;
04872: }
04873:
04874: private Hashtable handlerStarts = new Hashtable();
04875:
04876: private boolean addHandlerStart(int i) {
04877: boolean add = true;
04878: if (handlerStarts.size() > 0) {
04879: java.lang.String s = (java.lang.String) handlerStarts
04880: .get(new Integer(i));
04881: if (s == null)
04882: return add;
04883: else
04884: return false;
04885: }
04886: return add;
04887: }
04888:
04889: private Hashtable guardEnds = new Hashtable();
04890:
04891: private boolean addGuardEnd(int i) {
04892:
04893: if (guardEnds.size() == 0)
04894: return true;
04895: else {
04896: java.lang.String s = (java.lang.String) guardEnds
04897: .get(new Integer(i));
04898: if (s == null)
04899: return true;
04900: else
04901: return false;
04902: }
04903:
04904: }
04905:
04906: /***************************************************************************
04907: *
04908: * @param index
04909: * localvarindex
04910: * @param insttype
04911: * pass it as store or load
04912: * @return
04913: */
04914:
04915: // [NOTE:] THIS METHOD CAN RETURN NULL: SO HANDLE WITH CARE IN CALLING
04916: // METHOD....[belurs]
04917: private LocalVariable getLocalVariable(int index,
04918: java.lang.String insttype, java.lang.String dataType,
04919: boolean simpleLoadStore, int instpos) {
04920: if (index < 0) {
04921: index += 256;
04922: }
04923: LocalVariable l = null;
04924: LocalVariableStructure structure = behaviour.getLocalVariables();
04925: if (cd.isClassCompiledWithMinusG()) {
04926: if (structure != null)// Just a double check.. Need not check
04927: // actually
04928: {
04929: int rangeIndex = -1;
04930: if (insttype.equals("store")) {
04931:
04932: if (simpleLoadStore == true)
04933: rangeIndex = instpos + 1;
04934: else
04935: rangeIndex = instpos + 2;
04936: LocalVariable var = structure.getVariabelAtIndex(index,
04937: rangeIndex);
04938: if (var == null) {
04939: Object o = cd.getMethod_name_storeNLoad_Map().get(
04940: this .behaviour.getBehaviourName().concat(
04941: behaviour.getStringifiedParameters()));
04942: if (o instanceof Hashtable) {
04943: Hashtable h = (Hashtable) o;
04944: if (h != null && h.size() > 0) {
04945: Integer il = (Integer) h.get(new Integer(
04946: instpos));
04947: if (il != null) {
04948: int loadpos = il.intValue();
04949: var = structure.getVariabelAtIndex(index,
04950: loadpos);
04951: }
04952: }
04953: }
04954: }
04955: if (var == null) {
04956: // Create a veriable here
04957: // This probably indicates the variables is unused in
04958: // code
04959: // TODO Fix Required over here
04960:
04961: var = new LocalVariable(behaviour.getBehaviourName()
04962: .concat(behaviour.getStringifiedParameters()),
04963: "Var_" + index, index);
04964: boolean duplicateVarName = isLocalVariableWithNameAlreadyPresent(
04965: "jdec_var_" + index, behaviour
04966: .getLocalVariables()
04967: .getMethodLocalVaribales());
04968: if (!duplicateVarName)
04969: var.setDeclarationGenerated(false);
04970: else
04971: var.setDeclarationGenerated(true);
04972: var.setDataType(dataType);
04973: var.setWasCreated(true);
04974: structure.addLocalVariable(var);
04975:
04976: }
04977: return var;
04978:
04979: } else // This is for load
04980: {
04981: LocalVariable var = structure.getVariabelAtIndex(index,
04982: instpos);
04983: if (var == null) {
04984: // NOT Sure what to do here// SHOULD NEVER COME
04985: // HERE.....
04986: // Possible due to a finally block
04987: try {
04988: Writer wr = Writer.getWriter("log");
04989: wr
04990: .writeLog("Could not obtain local variable While decompiling "
04991: + behaviour
04992: .getBehaviourName()
04993: .concat(
04994: behaviour
04995: .getStringifiedParameters()));
04996: wr.writeLog("\nDetails.......");
04997: wr.writeLog("\n[Index Pos " + index
04998: + ",Instruction Pos " + instpos
04999: + " INSTRUCTION CODE: "
05000: + behaviour.getCode()[instpos] + "]\n");
05001: wr.flush();
05002: } catch (Exception ex) {
05003: }
05004:
05005: }
05006: return var;
05007:
05008: }
05009:
05010: } else
05011: return null;
05012: } else {
05013: ConsoleLauncher.setCurrentClassCompiledWithDebugInfo(false);
05014: LocalVariable toreturn = null;
05015: if (behaviour.getLocalVariables() == null) // Again shud not
05016: // happen...
05017: {
05018: java.lang.String methodName = behaviour.getBehaviourName();
05019: structure = new LocalVariableStructure();
05020: behaviour.setMethodLocalVariables(structure);
05021: structure.setMethodDescription(methodName.concat(behaviour
05022: .getStringifiedParameters()));
05023: LocalVariableTable localVarTable = LocalVariableTable
05024: .getInstance();
05025: localVarTable.addEntry(methodName.concat(behaviour
05026: .getStringifiedParameters().concat(
05027: "" + behaviour.isMethodConstructor())),
05028: structure);
05029: }
05030: l = structure.getVariabelAtIndex(index, dataType,
05031: datatypesForParams);
05032:
05033: LocalVariable tmp = null;
05034: if (l == null) // Create and Add
05035: {
05036: java.lang.String variableName = "Var" + "_" + instpos + "_"
05037: + index;
05038: if ((this .behaviour.getUserFriendlyMethodAccessors().indexOf(
05039: "static") == -1 && !behaviour.getBehaviourName().trim()
05040: .equals("static"))
05041: && (index == 0))
05042: variableName = "this";
05043: l = new LocalVariable(behaviour.getBehaviourName().concat(
05044: behaviour.getStringifiedParameters()), variableName,
05045: index);
05046: l.setDeclarationGenerated(false);
05047: l.setDataType(dataType);
05048: l.setWasCreated(true);
05049: structure.addLocalVariable(l);
05050: toreturn = l;
05051: l.setPassedDataTypeWhileCreatingWithOutMinusG(dataType);
05052:
05053: } else {
05054:
05055: if (structure.getNumberOfSimilarIndexVars(index) > 1) {
05056: Object o = cd.getMethod_name_storeNLoad_Map().get(
05057: this .behaviour.getBehaviourName().concat(
05058: behaviour.getStringifiedParameters()));
05059: if (o instanceof Hashtable) {
05060: Hashtable h = (Hashtable) o;
05061: if (h != null && h.size() > 0) {
05062: Integer il = (Integer) h.get(new Integer(instpos));
05063: if (il != null) {
05064: int loadpos = il.intValue();
05065: tmp = structure.getVariableForLoadOrStorePos(
05066: index, loadpos);
05067: }
05068: }
05069: }
05070:
05071: }
05072:
05073: if (tmp == null)
05074: toreturn = l;
05075: else
05076: toreturn = tmp;
05077:
05078: } // BigInteger b
05079:
05080: java.lang.String dt = getStoredDataType(toreturn.getIndexPos());
05081: if (dt != null && dt.trim().length() != 0)
05082: toreturn.setDataType(dt.trim());
05083: if (this .behaviour.getUserFriendlyMethodAccessors().indexOf(
05084: "static") == -1
05085: && !behaviour.getBehaviourName().trim().equals("static")
05086: && (toreturn.getIndexPos() == 0)) {
05087: if (toreturn.getVarName().equals("this") == false) {
05088: toreturn.setVarName("this");
05089: }
05090: }
05091: return toreturn;
05092:
05093: }
05094:
05095: }
05096:
05097: private int getLoadIndexForReturn(byte[] info, int i, StringBuffer sb) {
05098: int index = -1;
05099: switch (info[(i - 1)]) {
05100:
05101: case JvmOpCodes.ALOAD_0:
05102:
05103: index = 0;
05104: break;
05105: case JvmOpCodes.ALOAD_1:
05106: index = 1;
05107: break;
05108: case JvmOpCodes.ALOAD_2:
05109: index = 2;
05110: break;
05111: case JvmOpCodes.ALOAD_3:
05112: index = 3;
05113: break;
05114:
05115: case JvmOpCodes.ILOAD_0:
05116: index = 0;
05117: break;
05118: case JvmOpCodes.ILOAD_1:
05119: index = 1;
05120: break;
05121: case JvmOpCodes.ILOAD_2:
05122: index = 2;
05123: break;
05124: case JvmOpCodes.ILOAD_3:
05125: index = 3;
05126: break;
05127:
05128: case JvmOpCodes.LLOAD_0:
05129: index = 0;
05130: break;
05131: case JvmOpCodes.LLOAD_1:
05132: index = 1;
05133: break;
05134: case JvmOpCodes.LLOAD_2:
05135: index = 2;
05136: break;
05137: case JvmOpCodes.LLOAD_3:
05138: index = 3;
05139: break;
05140:
05141: case JvmOpCodes.FLOAD_0:
05142: index = 0;
05143: break;
05144: case JvmOpCodes.FLOAD_1:
05145: index = 1;
05146: break;
05147: case JvmOpCodes.FLOAD_2:
05148: index = 2;
05149: break;
05150: case JvmOpCodes.FLOAD_3:
05151: index = 3;
05152: break;
05153:
05154: case JvmOpCodes.DLOAD_0:
05155: index = 0;
05156: break;
05157: case JvmOpCodes.DLOAD_1:
05158: index = 1;
05159: break;
05160: case JvmOpCodes.DLOAD_2:
05161: index = 2;
05162: break;
05163: case JvmOpCodes.DLOAD_3:
05164: index = 3;
05165: break;
05166: default:
05167: index = -1;
05168:
05169: }
05170: if (index != -1)
05171: sb.append((i - 1));
05172:
05173: if (index == -1) {
05174:
05175: switch (info[(i - 2)]) {
05176: case JvmOpCodes.ALOAD:
05177: index = info[(i - 1)];
05178: break;
05179:
05180: case JvmOpCodes.DLOAD:
05181: index = info[(i - 1)];
05182: break;
05183:
05184: case JvmOpCodes.FLOAD:
05185: index = info[(i - 1)];
05186: break;
05187: case JvmOpCodes.LLOAD:
05188: index = info[(i - 1)];
05189: break;
05190: case JvmOpCodes.ILOAD:
05191: index = info[(i - 1)];
05192: break;
05193:
05194: default:
05195: index = -1;
05196: }
05197:
05198: if (index != -1)
05199: sb.append((i - 2));
05200: }
05201:
05202: return index;
05203: }
05204:
05205: private Hashtable datatypesForParams = null;
05206:
05207: private void storeDataTypesForMethodParams(Behaviour b, ClassDescription cd) {
05208: datatypesForParams = new Hashtable();
05209: b.setDatatypesForParams(datatypesForParams);
05210:
05211: int count = 1;
05212: java.lang.String str = b.getUserFriendlyMethodParams();
05213: int staticPresent = b.getUserFriendlyMethodAccessors()
05214: .indexOf("static");
05215: if (staticPresent != -1) {
05216: count = 0;
05217: }
05218: int total = b.getNumberofparamters();
05219: if (total == 0)
05220: return;
05221: int s = 0;
05222: int endindex = str.indexOf(")");
05223: int startindex = str.indexOf("(");
05224: startindex += 1;
05225: if (startindex < endindex) {
05226: if (endindex > startindex) {
05227: java.lang.String reqdStr = str.substring(startindex, endindex);
05228: StringTokenizer tokenizer = new StringTokenizer(reqdStr, ",");
05229: while (tokenizer.hasMoreElements()) {
05230: Object o = tokenizer.nextElement();
05231: java.lang.String t = (java.lang.String) o;
05232: datatypesForParams.put(new Integer(count), t);
05233: if (t.trim().equals("long") || t.trim().equals("double"))
05234: count++;
05235: count++;
05236: }
05237:
05238: } else
05239: return;
05240:
05241: }
05242:
05243: }
05244:
05245: private java.lang.String getStoredDataType(int index) {
05246: java.lang.String dt = "";
05247: if (this .datatypesForParams != null && datatypesForParams.size() > 0) {
05248: return (java.lang.String) datatypesForParams
05249: .get(new Integer(index));
05250: }
05251: return dt;
05252:
05253: }
05254:
05255: private void storeDataTypesWRTConversionInst(Behaviour b,
05256: ClassDescription cd) {
05257:
05258: byte c[] = b.getCode();
05259: StringBuffer sb;
05260: LocalVariableStructure struc = b.getLocalVariables();
05261: for (int i = 0; i < c.length; i++) {
05262: sb = new StringBuffer("");
05263: int pos = isNextInstructionConversionInst(i, c);
05264:
05265: if (pos != -1) {
05266: java.lang.String resType = getResulatantTypeForConversionInst(
05267: i, c);
05268: java.lang.String srcType = getSourceTypeForConversionInst(i, c);
05269: StringBuffer varindex = new StringBuffer("");
05270: boolean store = isNextInstructionPrimitiveStoreInst(c,
05271: (pos + 1), varindex);
05272: if (store) {
05273: StringBuffer sb1 = new StringBuffer(""); // denotes type
05274: StringBuffer sb2 = new StringBuffer(""); // denotes index
05275: getIndexNTypeForNextInst(sb1, sb2, c, (pos + 1));
05276: int index = Integer.parseInt(sb2.toString());
05277: java.lang.String varName = "Var_" + (pos + 1) + "_" + index;
05278: LocalVariable local = new LocalVariable(b
05279: .getBehaviourName().concat(
05280: b.getStringifiedParameters()), varName,
05281: index);
05282: local.setDeclarationGenerated(false);
05283: if (resType == null || resType.trim().equals(""))
05284: local.setDataType(sb1.toString());
05285: else
05286: local.setDataType(resType);
05287: local.setWasCreated(true);
05288:
05289: LocalVariable l = struc.getVariabelAtIndex(index);
05290: if (l == null) {
05291: b.getLocalVariables().addLocalVariable(local);
05292: } else {
05293:
05294: LocalVariable l2 = struc.getVariableForLoadOrStorePos(
05295: index, (pos + 1));
05296: if (l2 != null) {
05297: if (resType == null || resType.trim().equals(""))
05298: local.setDataType(sb1.toString());
05299: else
05300: local.setDataType(resType);
05301: }
05302:
05303: }
05304: }
05305: StringBuffer sb3 = new StringBuffer("");
05306: boolean prev = isPrevInstPrimitiveLoad(c, (pos), sb3);
05307: if (prev) {
05308: StringBuffer sb1 = new StringBuffer(""); // denotes type
05309: StringBuffer sb2 = new StringBuffer(""); // denotes index
05310: getIndexNTypeForPrevInst(sb1, sb2, c, (Integer.parseInt(sb3
05311: .toString())));
05312: int index = Integer.parseInt(sb2.toString());
05313: java.lang.String varName = "Var_"
05314: + (Integer.parseInt(sb3.toString())) + "_" + index;
05315:
05316: LocalVariable local = new LocalVariable(b
05317: .getBehaviourName().concat(
05318: b.getStringifiedParameters()), varName,
05319: index);
05320: local.setDeclarationGenerated(false);
05321: if (srcType == null || srcType.trim().equals(""))
05322: local.setDataType(sb1.toString());
05323: else
05324: local.setDataType(srcType);
05325: local.setWasCreated(true);
05326:
05327: LocalVariable l = struc.getVariabelAtIndex(index);
05328: if (l == null) {
05329: b.getLocalVariables().addLocalVariable(local);
05330: } else {
05331:
05332: LocalVariable l2 = struc.getVariableForLoadOrStorePos(
05333: index, (Integer.parseInt(sb3.toString())));
05334: if (l2 != null) {
05335: if (srcType == null || srcType.trim().equals(""))
05336: local.setDataType(sb1.toString());
05337: else
05338: local.setDataType(srcType);
05339: }
05340:
05341: }
05342: }
05343: }
05344:
05345: }
05346:
05347: }
05348:
05349: private boolean isNextInstructionPrimitiveStoreInst(byte[] c, int pos,
05350: StringBuffer index) {
05351: boolean flag = false;
05352: if (isThisInstrStart(behaviour.getInstructionStartPositions(), pos) == false)
05353: return false;
05354: switch (c[(pos)]) {
05355: case JvmOpCodes.DSTORE:
05356: flag = true;
05357: index.append(c[(pos + 1)]);
05358: break;
05359: case JvmOpCodes.DSTORE_0:
05360: flag = true;
05361: index.append(0);
05362: break;
05363: case JvmOpCodes.DSTORE_1:
05364: flag = true;
05365: index.append(1);
05366: break;
05367: case JvmOpCodes.DSTORE_2:
05368: flag = true;
05369: index.append(2);
05370: break;
05371: case JvmOpCodes.DSTORE_3:
05372: flag = true;
05373: index.append(3);
05374: break;
05375:
05376: case JvmOpCodes.FSTORE:
05377: flag = true;
05378: index.append(c[(pos + 1)]);
05379: break;
05380: case JvmOpCodes.FSTORE_0:
05381: flag = true;
05382: index.append(0);
05383: break;
05384: case JvmOpCodes.FSTORE_1:
05385: flag = true;
05386: index.append(1);
05387: break;
05388: case JvmOpCodes.FSTORE_2:
05389: flag = true;
05390: index.append(2);
05391: break;
05392: case JvmOpCodes.FSTORE_3:
05393: flag = true;
05394: index.append(3);
05395: break;
05396:
05397: case JvmOpCodes.ISTORE:
05398: flag = true;
05399: index.append(c[(pos + 1)]);
05400: break;
05401: case JvmOpCodes.ISTORE_0:
05402: flag = true;
05403: index.append(0);
05404: break;
05405: case JvmOpCodes.ISTORE_1:
05406: flag = true;
05407: index.append(1);
05408: break;
05409: case JvmOpCodes.ISTORE_2:
05410: flag = true;
05411: index.append(2);
05412: break;
05413: case JvmOpCodes.ISTORE_3:
05414: flag = true;
05415: index.append(3);
05416: break;
05417:
05418: case JvmOpCodes.LSTORE:
05419: flag = true;
05420: index.append(c[(pos + 1)]);
05421: break;
05422:
05423: case JvmOpCodes.LSTORE_0:
05424: flag = true;
05425: index.append(0);
05426: break;
05427: case JvmOpCodes.LSTORE_1:
05428: flag = true;
05429: index.append(1);
05430: break;
05431: case JvmOpCodes.LSTORE_2:
05432: flag = true;
05433: index.append(2);
05434: break;
05435: case JvmOpCodes.LSTORE_3:
05436: flag = true;
05437: index.append(3);
05438: break;
05439:
05440: }
05441:
05442: return flag;
05443: }
05444:
05445: // sb1 type
05446: private void getIndexNTypeForNextInst(StringBuffer sb1, StringBuffer sb2,
05447: byte[] c, int pos) {
05448: switch (c[(pos)]) {
05449: case JvmOpCodes.DSTORE:
05450: sb1.append("double");
05451: sb2.append(c[(pos + 1)]);
05452: break;
05453: case JvmOpCodes.DSTORE_0:
05454: sb1.append("double");
05455: sb2.append(0);
05456: break;
05457: case JvmOpCodes.DSTORE_1:
05458: sb1.append("double");
05459: sb2.append(1);
05460: break;
05461: case JvmOpCodes.DSTORE_2:
05462: sb1.append("double");
05463: sb2.append(2);
05464: break;
05465: case JvmOpCodes.DSTORE_3:
05466: sb1.append("double");
05467: sb2.append(3);
05468: break;
05469:
05470: case JvmOpCodes.FSTORE:
05471: sb1.append("float");
05472: sb2.append(c[(pos + 1)]);
05473: break;
05474: case JvmOpCodes.FSTORE_0:
05475: sb1.append("float");
05476: sb2.append(0);
05477: break;
05478: case JvmOpCodes.FSTORE_1:
05479: sb1.append("float");
05480: sb2.append(1);
05481: break;
05482: case JvmOpCodes.FSTORE_2:
05483: sb1.append("float");
05484: sb2.append(2);
05485: break;
05486: case JvmOpCodes.FSTORE_3:
05487: sb1.append("float");
05488: sb2.append(3);
05489: break;
05490:
05491: case JvmOpCodes.ISTORE:
05492: sb1.append("int");
05493: sb2.append(c[(pos + 1)]);
05494: break;
05495: case JvmOpCodes.ISTORE_0:
05496: sb1.append("int");
05497: sb2.append(0);
05498: break;
05499: case JvmOpCodes.ISTORE_1:
05500: sb1.append("int");
05501: sb2.append(1);
05502: break;
05503: case JvmOpCodes.ISTORE_2:
05504: sb1.append("int");
05505: sb2.append(2);
05506: break;
05507: case JvmOpCodes.ISTORE_3:
05508: sb1.append("int");
05509: sb2.append(3);
05510: break;
05511:
05512: case JvmOpCodes.LSTORE:
05513: sb1.append("long");
05514: sb2.append(c[(pos + 1)]);
05515: break;
05516:
05517: case JvmOpCodes.LSTORE_0:
05518: sb1.append("long");
05519: sb2.append(0);
05520: break;
05521: case JvmOpCodes.LSTORE_1:
05522: sb1.append("long");
05523: sb2.append(1);
05524: break;
05525: case JvmOpCodes.LSTORE_2:
05526: sb1.append("long");
05527: sb2.append(2);
05528: break;
05529: case JvmOpCodes.LSTORE_3:
05530: sb1.append("long");
05531: sb2.append(3);
05532: break;
05533:
05534: }
05535:
05536: }
05537:
05538: // pos --> conversion inst
05539: private boolean isPrevInstPrimitiveLoad(byte c[], int pos, StringBuffer sb) {
05540: boolean flag = false;
05541:
05542: switch (c[(pos - 1)]) {
05543:
05544: case JvmOpCodes.ILOAD_0:
05545: flag = true;
05546: break;
05547: case JvmOpCodes.ILOAD_1:
05548: flag = true;
05549: break;
05550: case JvmOpCodes.ILOAD_2:
05551: flag = true;
05552: break;
05553: case JvmOpCodes.ILOAD_3:
05554: flag = true;
05555: break;
05556:
05557: case JvmOpCodes.LLOAD_0:
05558: flag = true;
05559: break;
05560: case JvmOpCodes.LLOAD_1:
05561: flag = true;
05562: break;
05563: case JvmOpCodes.LLOAD_2:
05564: flag = true;
05565: break;
05566: case JvmOpCodes.LLOAD_3:
05567: flag = true;
05568: break;
05569:
05570: case JvmOpCodes.FLOAD_0:
05571: flag = true;
05572: break;
05573: case JvmOpCodes.FLOAD_1:
05574: flag = true;
05575: break;
05576: case JvmOpCodes.FLOAD_2:
05577: flag = true;
05578: break;
05579: case JvmOpCodes.FLOAD_3:
05580: flag = true;
05581: break;
05582:
05583: case JvmOpCodes.DLOAD_0:
05584: flag = true;
05585: break;
05586: case JvmOpCodes.DLOAD_1:
05587: flag = true;
05588: break;
05589: case JvmOpCodes.DLOAD_2:
05590: flag = true;
05591: break;
05592: case JvmOpCodes.DLOAD_3:
05593: flag = true;
05594: break;
05595:
05596: default:
05597: flag = false;
05598: break;
05599:
05600: }
05601: if (flag)
05602: sb.append((pos - 1));
05603: if (!flag) {
05604: switch (c[(pos - 2)]) {
05605: case JvmOpCodes.ILOAD:
05606: flag = true;
05607: break;
05608: case JvmOpCodes.LLOAD:
05609: flag = true;
05610: break;
05611:
05612: case JvmOpCodes.FLOAD:
05613: flag = true;
05614: break;
05615:
05616: case JvmOpCodes.DLOAD:
05617: flag = true;
05618: break;
05619: default:
05620: flag = false;
05621: break;
05622: }
05623: if (flag)
05624: sb.append((pos - 2));
05625: }
05626:
05627: return flag;
05628: }
05629:
05630: private void getIndexNTypeForPrevInst(StringBuffer sb1, StringBuffer sb2,
05631: byte c[], int pos) {
05632:
05633: boolean flag = false;
05634: switch (c[(pos)]) {
05635:
05636: case JvmOpCodes.ILOAD_0:
05637: flag = true;
05638: sb1.append("int");
05639: sb2.append(0);
05640: break;
05641: case JvmOpCodes.ILOAD_1:
05642: flag = true;
05643: sb1.append("int");
05644: sb2.append(1);
05645: break;
05646: case JvmOpCodes.ILOAD_2:
05647: flag = true;
05648: sb1.append("int");
05649: sb2.append(2);
05650: break;
05651: case JvmOpCodes.ILOAD_3:
05652: flag = true;
05653: sb1.append("int");
05654: sb2.append(3);
05655: break;
05656:
05657: case JvmOpCodes.LLOAD_0:
05658: flag = true;
05659: sb1.append("long");
05660: sb2.append(0);
05661: break;
05662: case JvmOpCodes.LLOAD_1:
05663: flag = true;
05664: sb1.append("long");
05665: sb2.append(1);
05666: break;
05667: case JvmOpCodes.LLOAD_2:
05668: flag = true;
05669: sb1.append("long");
05670: sb2.append(2);
05671:
05672: break;
05673: case JvmOpCodes.LLOAD_3:
05674: flag = true;
05675: sb1.append("long");
05676: sb2.append(3);
05677: break;
05678:
05679: case JvmOpCodes.FLOAD_0:
05680: flag = true;
05681: sb1.append("float");
05682: sb2.append(0);
05683: break;
05684: case JvmOpCodes.FLOAD_1:
05685: flag = true;
05686: sb1.append("float");
05687: sb2.append(1);
05688: break;
05689: case JvmOpCodes.FLOAD_2:
05690: flag = true;
05691: sb1.append("float");
05692: sb2.append(2);
05693: break;
05694: case JvmOpCodes.FLOAD_3:
05695: flag = true;
05696: sb1.append("float");
05697: sb2.append(3);
05698: break;
05699:
05700: case JvmOpCodes.DLOAD_0:
05701: flag = true;
05702: sb1.append("double");
05703: sb2.append(0);
05704: break;
05705: case JvmOpCodes.DLOAD_1:
05706: flag = true;
05707: sb1.append("double");
05708: sb2.append(1);
05709: break;
05710: case JvmOpCodes.DLOAD_2:
05711: flag = true;
05712: sb1.append("double");
05713: sb2.append(2);
05714: break;
05715: case JvmOpCodes.DLOAD_3:
05716: flag = true;
05717: sb1.append("double");
05718: sb2.append(3);
05719: break;
05720:
05721: default:
05722: flag = false;
05723: break;
05724:
05725: }
05726:
05727: if (!flag) {
05728: switch (c[(pos)]) {
05729: case JvmOpCodes.ILOAD:
05730: flag = true;
05731: sb1.append("int");
05732: sb2.append(c[(pos + 1)]);
05733: break;
05734: case JvmOpCodes.LLOAD:
05735: flag = true;
05736: sb1.append("long");
05737: sb2.append(c[(pos + 1)]);
05738: break;
05739:
05740: case JvmOpCodes.FLOAD:
05741: flag = true;
05742: sb1.append("float");
05743: sb2.append(c[(pos + 1)]);
05744: break;
05745:
05746: case JvmOpCodes.DLOAD:
05747: flag = true;
05748: sb1.append("double");
05749: sb2.append(c[(pos + 1)]);
05750: break;
05751: default:
05752: flag = false;
05753: break;
05754: }
05755: if (!flag) {
05756: sb1.append("");
05757: sb2.append(-1);
05758: }
05759: }
05760:
05761: }
05762:
05763: private void storeDataTypesWRTMethodParams(Behaviour b, ClassDescription cd) {
05764: LocalVariableStructure struc = b.getLocalVariables();
05765: if (datatypesForParams != null && datatypesForParams.size() > 0) {
05766: byte[] code = b.getCode();
05767: for (int s = 0; s < code.length; s++) {
05768: StringBuffer sb = new StringBuffer("");
05769: boolean bo = isThisInstructionIStoreInst(code, s, sb);
05770: if (bo) {
05771: StringBuffer sb2 = new StringBuffer("");
05772: boolean bo2 = isPrevInstIloadInst(code, s, sb2);
05773: if (bo2) {
05774: int loadindex = Integer.parseInt(sb2.toString());
05775: java.lang.String type = (java.lang.String) datatypesForParams
05776: .get(new Integer(loadindex));
05777: LocalVariable var = struc.getVariabelAtIndex(Integer
05778: .parseInt(sb.toString()));
05779: if (var == null && type != null) {
05780: int this Index = Integer.parseInt(sb.toString());
05781: java.lang.String varName = "Var_" + s + "_"
05782: + this Index;
05783: LocalVariable local = new LocalVariable(b
05784: .getBehaviourName().concat(
05785: b.getStringifiedParameters()),
05786: varName, this Index);
05787: local.setDeclarationGenerated(false);
05788: local.setWasCreated(true);
05789: local.setDataType(type);
05790: struc.addLocalVariable(local);
05791: }
05792: }
05793: }
05794:
05795: // TODO: Handle astore and aload combinatiobn
05796: sb = new StringBuffer("");
05797: bo = isThisInstASTOREInst(code, s, sb);
05798: if (bo) {
05799: StringBuffer sb2 = new StringBuffer("");
05800: boolean bo2 = isPrevInstALOADInst(code, s, sb2);
05801: if (bo2) {
05802: int loadindex = Integer.parseInt(sb2.toString());
05803: java.lang.String type = (java.lang.String) datatypesForParams
05804: .get(new Integer(loadindex));
05805: LocalVariable var = struc.getVariabelAtIndex(Integer
05806: .parseInt(sb.toString()));
05807: if (var == null && type != null) {
05808: int this Index = Integer.parseInt(sb.toString());
05809: java.lang.String varName = "Var_" + s + "_"
05810: + this Index;
05811: LocalVariable local = new LocalVariable(b
05812: .getBehaviourName().concat(
05813: b.getStringifiedParameters()),
05814: varName, this Index);
05815: local.setDeclarationGenerated(false);
05816: local.setWasCreated(true);
05817: local.setDataType(type);
05818: struc.addLocalVariable(local);
05819: }
05820:
05821: }
05822: }
05823: }
05824: }
05825: }
05826:
05827: private boolean isThisInstructionIStoreInst(byte[] code, int s,
05828: StringBuffer sb) {
05829: boolean b = false;
05830: if (isThisInstrStart(behaviour.getInstructionStartPositions(), s) == false)
05831: return false;
05832: switch (code[s]) {
05833: case JvmOpCodes.ISTORE_0:
05834: b = true;
05835: sb.append(0);
05836: break;
05837: case JvmOpCodes.ISTORE_1:
05838: b = true;
05839: sb.append(1);
05840: break;
05841: case JvmOpCodes.ISTORE_2:
05842: b = true;
05843: sb.append(2);
05844: break;
05845: case JvmOpCodes.ISTORE_3:
05846: b = true;
05847: sb.append(3);
05848: break;
05849: case JvmOpCodes.ISTORE:
05850: b = true;
05851: sb.append(code[(s + 1)]);
05852: break;
05853: }
05854:
05855: return b;
05856: }
05857:
05858: private boolean isPrevInstIloadInst(byte[] code, int s, StringBuffer sb2) {
05859: ArrayList starts = behaviour.getInstructionStartPositions();
05860: boolean b = false;
05861: if (isThisInstrStart(starts, (s - 1))) {
05862: switch (code[(s - 1)]) {
05863: case JvmOpCodes.ILOAD_0:
05864: b = true;
05865: sb2.append(0);
05866: break;
05867: case JvmOpCodes.ILOAD_1:
05868: b = true;
05869: sb2.append(1);
05870: break;
05871: case JvmOpCodes.ILOAD_2:
05872: b = true;
05873: sb2.append(2);
05874: break;
05875:
05876: case JvmOpCodes.ILOAD_3:
05877: b = true;
05878: sb2.append(3);
05879: break;
05880:
05881: }
05882: }
05883:
05884: if (!b && (s - 2) >= 0 && isThisInstrStart(starts, (s - 2))) {
05885:
05886: switch (code[s - 2]) {
05887:
05888: case JvmOpCodes.ILOAD:
05889: b = true;
05890: sb2.append(code[s - 1]);
05891: break;
05892: default:
05893: b = false;
05894: break;
05895:
05896: }
05897: }
05898:
05899: return b;
05900: }
05901:
05902: private void storeDataTypesWRTLoadNStoreCombinations(Behaviour b,
05903: ClassDescription cd) {
05904: byte code[] = b.getCode();
05905: LocalVariableStructure struc = b.getLocalVariables();
05906: for (int s = 0; s < code.length; s++) {
05907: StringBuffer sb = new StringBuffer("");
05908: boolean bo = isThisInstructionIStoreInst(code, s, sb);
05909: if (bo) {
05910: StringBuffer sb2 = new StringBuffer("");
05911: boolean bo2 = isPrevInstIloadInst(code, s, sb2);
05912: if (bo2) {
05913: int loadindex = Integer.parseInt(sb2.toString());
05914: LocalVariable var = struc.getVariabelAtIndex(Integer
05915: .parseInt(sb.toString()));
05916: LocalVariable loadvar = struc.getVariabelAtIndex(Integer
05917: .parseInt(sb2.toString()));
05918: if (loadvar != null) {
05919:
05920: // author :belurs:
05921: // NOTE:
05922: // Possible source of error here.
05923: // There may be more than one localvariable with the
05924: // same index
05925: // And since this code is reachable from the option
05926: // -g:none
05927: // It is not really possible to determine the exact
05928: // variable
05929: // The below code is expected to give out the correct
05930: // data type
05931: // in most cases.
05932: // END OF NOTE:
05933:
05934: // TODO: FIX ME later
05935: // FIX THE ambiguity in local variable at this point
05936: // [Possible correction : If localvar is null for this
05937: // load
05938: // Index...Keep going back till a store occurs with same
05939: // index....Possibly recursive here..may have to serach
05940: // for
05941: // prev local/store till local is not null...Will have
05942: // to do
05943: // This carefully
05944:
05945: if (var == null) {
05946: int this Index = Integer.parseInt(sb.toString());
05947: java.lang.String varName = "Var_" + s + "_"
05948: + this Index;
05949: LocalVariable local = new LocalVariable(b
05950: .getBehaviourName().concat(
05951: b.getStringifiedParameters()),
05952: varName, this Index);
05953: local.setDeclarationGenerated(false);
05954: local.setWasCreated(true);
05955: local.setDataType(loadvar.getDataType());
05956: struc.addLocalVariable(local);
05957: }
05958: }
05959: }
05960: }
05961:
05962: // TODO: aload and astore
05963: sb = new StringBuffer("");
05964: boolean astore = isThisInstASTOREInst(code, s, sb);
05965: if (astore) {
05966: StringBuffer sb2 = new StringBuffer("");
05967: boolean aload = isPrevInstALOADInst(code, s, sb2);
05968: if (aload) {
05969:
05970: int loadindex = Integer.parseInt(sb2.toString());
05971: LocalVariable var = struc.getVariabelAtIndex(Integer
05972: .parseInt(sb.toString()));
05973: LocalVariable loadvar = struc.getVariabelAtIndex(Integer
05974: .parseInt(sb2.toString()));
05975: if (loadvar != null) {
05976: if (var == null) {
05977: int this Index = Integer.parseInt(sb.toString());
05978: java.lang.String varName = "Var_" + s + "_"
05979: + this Index; //
05980: LocalVariable local = new LocalVariable(b
05981: .getBehaviourName().concat(
05982: b.getStringifiedParameters()),
05983: varName, this Index);
05984: local.setDeclarationGenerated(false);
05985: local.setWasCreated(true);
05986: local.setDataType(loadvar.getDataType());
05987: struc.addLocalVariable(local);
05988: }
05989: }
05990: }
05991:
05992: }
05993:
05994: }
05995: }
05996:
05997: private void createLocalVariablesForMethodParams(Behaviour b,
05998: ClassDescription cd) {
05999: byte[] code = b.getCode();
06000: ArrayList loadStoreIndexes = new ArrayList();
06001:
06002: if (datatypesForParams != null && datatypesForParams.size() > 0) {
06003: Set set = datatypesForParams.keySet();
06004: /*
06005: * for(int s=0;s<code.length;s++) {
06006: *
06007: * StringBuffer sb=new StringBuffer(""); boolean
06008: * anyIndex=getAnyLoadStoreIndex(code,s,sb); if(anyIndex) { Integer
06009: * i=new Integer(sb.toString()); loadStoreIndexes.add(i); } }
06010: */
06011: Iterator it = set.iterator();
06012: LocalVariableStructure struc = b.getLocalVariables();
06013: while (it.hasNext()) {
06014: Integer pos = (Integer) it.next();
06015: if (pos != null) // Just a check ...
06016: {
06017: int ipos = pos.intValue();
06018:
06019: LocalVariable var = struc.getVariabelAtIndex(ipos);
06020: if (var == null) // Create dummy variable
06021: {
06022: java.lang.String vname = "Var_" + ipos;
06023: LocalVariable lv = new LocalVariable(b
06024: .getBehaviourName().concat(
06025: b.getStringifiedParameters()), vname,
06026: ipos);
06027: lv.setDeclarationGenerated(false);
06028: lv.setWasCreated(true);
06029: lv.setMethodParameterVariable(true);
06030: lv.setDataType((java.lang.String) datatypesForParams
06031: .get(pos));
06032: struc.addLocalVariable(lv);
06033:
06034: } else {
06035: java.lang.String vname = "param_" + ipos;
06036: var.setVarName(vname);
06037: var.setMethodParameterVariable(true);
06038: var.setDataType((java.lang.String) datatypesForParams
06039: .get(pos));
06040: }
06041:
06042: }
06043:
06044: }
06045:
06046: }
06047:
06048: }
06049:
06050: private Hashtable invokeStart_StackStart = null;
06051:
06052: private Hashtable invokespecialpos = null;
06053:
06054: private ArrayList getField = null;
06055:
06056: private ArrayList getStatic = null;
06057:
06058: private Hashtable invokeinstrefpos = null;
06059:
06060: private Hashtable invokeinstrefretTypes = null;
06061:
06062: private void storeDataTypesWRTInvokeInst(Behaviour b, ClassDescription cd) {
06063: // if(cd.isClassCompiledWithMinusG()==false)
06064: // {
06065: GlobalVariableStore.setVariableDimAss(new Hashtable());
06066: invokeStart_StackStart = new Hashtable();
06067: GlobalVariableStore.setInvokeStartEnd(new Hashtable());
06068: invokespecialpos = new Hashtable();
06069: getField = new ArrayList();
06070: getStatic = new ArrayList();
06071: invokeinstrefpos = new Hashtable();
06072: invokeinstrefretTypes = new Hashtable();
06073:
06074: // }
06075: GlobalVariableStore.setPushTypes(new Hashtable());
06076: byte code[] = b.getCode();
06077: LocalVariableStructure struc = b.getLocalVariables();
06078: label: for (int s = 0; s < code.length; s++) {
06079: // System.out.println(s+" In method "+b.getBehaviourName());
06080: StringBuffer sb = new StringBuffer("");
06081: boolean invoke = isNextInstructionAnyInvoke(code[s], sb);
06082: Integer skip = (Integer) ConsoleLauncher.getInstructionMap().get(
06083: new Integer(code[s]));
06084: boolean skipthis invoke = false;
06085: if (skip == null)
06086: continue;
06087: else {
06088: if (invoke) {
06089:
06090: int newpresent = s - 3;
06091: if (code[s] == JvmOpCodes.INVOKESPECIAL) {
06092: if (newpresent >= 0
06093: && code[newpresent] == JvmOpCodes.INVOKESPECIAL) {
06094: // int prevpos=
06095: ArrayList statpos = behaviour
06096: .getInstructionStartPositions();
06097: Integer z = (Integer) invokeinstrefpos
06098: .get(new Integer(newpresent));
06099: if (z != null) {
06100: int prevpos = z.intValue() - 1;
06101: ArrayList startpos = behaviour
06102: .getInstructionStartPositions();
06103: for (int k = prevpos; k >= 0; k--) {
06104: boolean st = isThisInstrStart(startpos, k);
06105: while (st == false && k >= 0) {
06106: k--;
06107: st = isThisInstrStart(startpos, k);
06108: }
06109:
06110: // some start pos found
06111: if (k >= 0) {
06112: if (code[k] == JvmOpCodes.NEW) {
06113: invokespecialpos.put(
06114: new Integer(s),
06115: new Integer(k));
06116: invokeinstrefpos.put(
06117: new Integer(s),
06118: new Integer(k));
06119: break;
06120: }
06121: }
06122:
06123: }
06124: }
06125:
06126: } else {
06127: int prevpos = s - 1;
06128: ArrayList startpos = behaviour
06129: .getInstructionStartPositions();
06130: for (int k = prevpos; k >= 0; k--) {
06131: boolean st = isThisInstrStart(startpos, k);
06132: while (st == false && k >= 0) {
06133: k--;
06134: st = isThisInstrStart(startpos, k);
06135: }
06136:
06137: // some start pos found
06138: boolean needtocontinue = false;
06139: if (k >= 0 && code[k] == JvmOpCodes.GETFIELD) {
06140: Iterator it = invokeinstrefpos.entrySet()
06141: .iterator();
06142: while (it.hasNext()) {
06143: Map.Entry en = (Map.Entry) it.next();
06144: Integer i1 = (Integer) en.getKey();
06145: Integer i2 = (Integer) en.getValue();
06146:
06147: if (i2.intValue() == (k - 1)
06148: && i1.intValue() != s) {
06149: needtocontinue = true;
06150: break;
06151: }
06152: if (i2.intValue() == (k - 2)
06153: && i1.intValue() != s) {
06154: needtocontinue = true;
06155: break;
06156: }
06157:
06158: }
06159:
06160: if (!needtocontinue)
06161: break;
06162:
06163: }
06164: if (k >= 0 && (code[k] == JvmOpCodes.NEW)) {
06165: invokespecialpos.put(new Integer(s),
06166: new Integer(k));
06167: invokeinstrefpos.put(new Integer(s),
06168: new Integer(k));
06169: break;
06170: }
06171:
06172: }
06173:
06174: }
06175:
06176: }
06177:
06178: }
06179:
06180: // ?
06181: if (!invoke) {
06182:
06183: /*
06184: * if(code[s]==JvmOpCodes.ANEWARRAY) {
06185: *
06186: * StringBuffer invokepos=new StringBuffer(""); boolean
06187: * process=processANEWARRAYb4Invoke(code,s,invokepos);
06188: * if(process) { stackHandler=new Stack(); InstParam
06189: * first=new InstParam(); first.setNumberOfParamsLeft(1);
06190: * first.setCurrentParamOffsetInCode(-1);
06191: * stackHandler.push(first);
06192: * handleBasicPrimitiveLoadOp(code,s-1); InstParam
06193: * obj=(InstParam)stackHandler.pop(); int
06194: * offset=obj.getCurrentParamOffsetInCode();
06195: * anewarrayrefpos.put(new
06196: * Integer(Integer.parseInt(invokepos.toString())),new
06197: * Integer(offset)); } }
06198: */
06199:
06200: if (code[s] == JvmOpCodes.GETSTATIC) {
06201: getStatic.add(new Integer(s));
06202: }
06203: if (code[s] == JvmOpCodes.GETFIELD) {
06204: getField.add(new Integer(s));
06205: }
06206: int toskip = skip.intValue();
06207: boolean xx = false;
06208: if (toskip == -1) // lookup // TODO: verify increment
06209: {
06210: xx = true;
06211: int lookupSwitchPos = s;
06212: int leave_bytes = (4 - (s % 4)) - 1;
06213: for (int indx = 0; indx < leave_bytes; indx++) {
06214: s++;
06215: }
06216: // Read Default
06217: int Default = getSwitchOffset(code, s, "");// info[++i]
06218: // << 24) |
06219: // (info[++i]
06220: // << 16) |
06221: // (info[++i]
06222: // << 8)
06223: // |info[++i];
06224: s += 4;
06225: int numberOfLabels = (getSwitchOffset(code, s, "")); // info[++i]
06226: // <<
06227: // 24)
06228: // |
06229: // (info[++i]
06230: // <<
06231: // 16)
06232: // |
06233: // (info[++i]
06234: // <<
06235: // 8)
06236: // |info[++i];
06237: // int high=(info[++i] << 24) | (info[++i] << 16) |
06238: // (info[++i] << 8) |info[++i];
06239: // int numberOfOffsets=(high-low)+1;
06240: int offsetValues[] = new int[numberOfLabels];
06241: int labels[] = new int[numberOfLabels];
06242: s += 4;
06243: for (int start = 0; start < numberOfLabels; start++) {
06244: int label = getSwitchOffset(code, s, "label");
06245: s += 4;
06246: int offsetVal = getSwitchOffset(code, s, "");// (info[++i]
06247: // <<
06248: // 24)
06249: // |
06250: // (info[++i]
06251: // <<
06252: // 16)
06253: // |
06254: // (info[++i]
06255: // <<
06256: // 8)
06257: // |info[++i];
06258: s += 4;
06259: labels[start] = label;
06260: offsetValues[start] = offsetVal;
06261:
06262: }
06263:
06264: }
06265: if (toskip == -2) // table
06266: {
06267: xx = true;
06268: int tableSwitchPos = s;
06269: int leave_bytes = (4 - (s % 4)) - 1;
06270: for (int indx = 0; indx < leave_bytes; indx++) {
06271: s++;
06272: }
06273: // Read Default
06274: int Default = getSwitchOffset(code, s, "");// (info[++i]
06275: // << 24) |
06276: // (info[++i]
06277: // << 16) |
06278: // (info[++i]
06279: // << 8)
06280: // |info[++i];
06281: s += 4;
06282: int low = getSwitchOffset(code, s, "label");// (info[++i]
06283: // << 24) |
06284: // (info[++i]
06285: // << 16) |
06286: // (info[++i]
06287: // << 8)
06288: // |info[++i];
06289: s += 4;
06290: int high = getSwitchOffset(code, s, "label");// (info[++i]
06291: // <<
06292: // 24) |
06293: // (info[++i]
06294: // <<
06295: // 16) |
06296: // (info[++i]
06297: // << 8)
06298: // |info[++i];
06299: s += 4;
06300: int numberOfOffsets = (high - low) + 1;
06301: int[] offsetValues = new int[numberOfOffsets];
06302: for (int start = 0; start < numberOfOffsets; start++) {
06303: int offsetVal = getSwitchOffset(code, s, "");
06304: s += 4;
06305: offsetValues[start] = offsetVal;
06306:
06307: }
06308:
06309: }
06310: if (toskip == -3) // wide // TODO ?
06311: {
06312:
06313: }
06314: if (!xx)
06315: s = s + toskip;
06316: else
06317: s = s + 1;
06318:
06319: continue;
06320: }
06321:
06322: }
06323:
06324: java.lang.String belongingClassName = "";
06325: java.lang.String returnTypeName = "";
06326: if (invoke) // && !(sb.toString().equalsIgnoreCase("special")))
06327: {
06328: int classIndex = getOffset(code, s);
06329: java.lang.String methodSignature = "";
06330: if (sb.toString().indexOf("interface") == -1) {
06331: MethodRef mref = cd.getMethodRefAtCPoolPosition(classIndex);
06332: methodSignature = mref.getTypeofmethod();
06333: belongingClassName = mref.getClassname();
06334: returnTypeName = mref.getTypeofmethod();
06335: int brk = returnTypeName.indexOf(")");
06336: if (brk != -1) {
06337: returnTypeName = returnTypeName.substring((brk + 1));
06338: brk = returnTypeName.indexOf("L");
06339: if (brk != -1) {
06340: returnTypeName = returnTypeName.substring(brk + 1,
06341: returnTypeName.indexOf(";"));
06342:
06343: }
06344: }
06345: invokeinstrefretTypes.put(new Integer(s),
06346: belongingClassName + "::" + returnTypeName);
06347: } else {
06348: InterfaceMethodRef mref = cd
06349: .getInterfaceMethodAtCPoolPosition(classIndex);
06350: methodSignature = mref.getTypeofmethod();
06351: belongingClassName = mref.getClassname();
06352: returnTypeName = mref.getTypeofmethod();
06353: int brk = returnTypeName.indexOf(")");
06354: if (brk != -1) {
06355: returnTypeName = returnTypeName.substring((brk + 1));
06356: brk = returnTypeName.indexOf("L");
06357: if (brk != -1) {
06358: returnTypeName = returnTypeName.substring(brk + 1,
06359: returnTypeName.indexOf(";"));
06360:
06361: }
06362: }
06363: invokeinstrefretTypes.put(new Integer(s),
06364: belongingClassName + "::" + returnTypeName);
06365: }
06366:
06367: Util.parseDescriptor(methodSignature);
06368: ArrayList list = Util.getParsedSignatureAsList();
06369:
06370: int num = list.size();
06371: int z = (num - 1);
06372: StringBuffer pos = null;
06373: int start = s - 1;
06374: int ipos = -1; // where local var occurs
06375: boolean skiploop = false;
06376: while (z >= 0) {
06377: StringBuffer index = new StringBuffer("");
06378: StringBuffer dim = new StringBuffer("");
06379:
06380: pos = new StringBuffer(""); // where local var occurs
06381: java.lang.String type = (java.lang.String) list.get(z);
06382:
06383: //
06384: Integer isinvokestart = (Integer) GlobalVariableStore
06385: .getInvokeStartEnd().get(new Integer(start));
06386: while (isinvokestart != null) {
06387: int invokestart = isinvokestart.intValue();
06388: Integer stackstart = (Integer) invokeStart_StackStart
06389: .get(new Integer(invokestart));
06390: Integer refstart = (Integer) invokeinstrefpos
06391: .get(new Integer(invokestart));
06392: int istart = -1;
06393: if (refstart == null) {
06394: GlobalVariableStore.getProblematicInvokes().add(
06395: new Integer(s));
06396: skipthis invoke = true;
06397: skiploop = true;
06398: break;
06399: }
06400: if (refstart != null) {
06401:
06402: istart = refstart.intValue();
06403: StringBuffer buffer = new StringBuffer("");
06404: if (isNextInstructionAnyInvoke(code[istart], buffer)) {
06405: java.lang.String sTR = (java.lang.String) invokeinstrefretTypes
06406: .get(new Integer(istart));
06407: if (sTR != null) {
06408: int sep = sTR.indexOf("::");
06409: java.lang.String rEF = sTR
06410: .substring(0, sep);
06411: java.lang.String rET = sTR
06412: .substring(sep + 2);
06413: if (rEF.trim().equalsIgnoreCase(rET.trim())) {
06414: ipos = istart;
06415: } else {
06416: refstart = (Integer) invokeinstrefpos
06417: .get(new Integer(istart));
06418: if (refstart != null)
06419: ipos = refstart.intValue();
06420: }
06421: }
06422:
06423: }
06424: start = refstart.intValue() - 1;
06425: }
06426:
06427: z--;
06428: int h = -1;
06429: if (ipos == -1)
06430: h = istart - 1;
06431: else
06432: h = ipos - 1;
06433: isinvokestart = (Integer) GlobalVariableStore
06434: .getInvokeStartEnd().get(new Integer(h));
06435:
06436: if (z == -1) {
06437: skiploop = true;
06438: break;
06439: }
06440: }
06441:
06442: if (skiploop)
06443: break;
06444: //
06445: type = (java.lang.String) list.get(z);
06446: try {
06447: getCorrespondingLoadInst(index, dim, start, pos,
06448: this .behaviour, this .cd, type, s);
06449:
06450: Integer.parseInt(pos.toString());
06451: } catch (Exception ne) {
06452: // Skip This invoke
06453: // Because the current rules are not sufficient to track
06454: // the beginning
06455: // of a prameter load for a method
06456: GlobalVariableStore.getProblematicInvokes().add(
06457: new Integer(s));
06458: skipthis invoke = true;
06459: break;
06460:
06461: }
06462:
06463: ipos = Integer.parseInt(pos.toString());
06464: start = (ipos - 1);
06465: int in = Integer.parseInt(index.toString());
06466: int dimensions = Integer.parseInt(dim.toString());
06467: LocalVariable l = struc.getVariabelAtIndex(in);
06468:
06469: if (cd.isClassCompiledWithMinusG() == false) {
06470: if (l != null) {
06471:
06472: int bracket = type.indexOf("[");
06473: if (bracket != -1) {
06474: int brackets = 0;
06475: for (int d = bracket; d < type.length(); d++) {
06476: if (type.charAt(d) == '[')
06477: brackets++;
06478: else
06479: break;
06480: }
06481:
06482: int totalDimenForVar = dimensions + brackets;
06483: // Assocaite here
06484: if (GlobalVariableStore.getVariableDimAss() != null)
06485: GlobalVariableStore.getVariableDimAss()
06486: .put(
06487: new Integer(in),
06488: new Integer(
06489: totalDimenForVar));
06490: } else {
06491: int L = type.indexOf("L");
06492: if (L != -1) {
06493: type = type.substring((L + 1));
06494: }
06495: int semi = type.indexOf(";");
06496: if (semi != -1) {
06497: type = type.substring(0, (semi));
06498: }
06499: // l.setDataType(type); // NOTE: commented this
06500: // line as it was resetting already set correct
06501: // datatype
06502: }
06503: }
06504: if (l == null && in != -100 && in != -200) {
06505: int bracket = type.indexOf("[");
06506: if (bracket == -1) {
06507: int L = type.indexOf("L");
06508: if (L != -1) {
06509: type = type.substring((L + 1));
06510: }
06511: int semi = type.indexOf(";");
06512: if (semi != -1) {
06513: type = type.substring(0, (semi));
06514: }
06515:
06516: java.lang.String varName = "Var_" + ipos + "_"
06517: + in;
06518: if (this .behaviour
06519: .getUserFriendlyMethodAccessors()
06520: .indexOf("static") == -1
06521: && (in == 0))
06522: varName = "this";
06523: LocalVariable newl = new LocalVariable(b
06524: .getBehaviourName().concat(
06525: b.getStringifiedParameters()),
06526: varName, in);
06527: newl.setDeclarationGenerated(false);
06528: newl.setWasCreated(true);
06529: newl.setDataType(type);
06530: struc.addLocalVariable(newl);
06531:
06532: }
06533: if (bracket != -1) {
06534: int brackets = 0;
06535: for (int d = bracket; d < type.length(); d++) {
06536: if (type.charAt(d) == '[')
06537: brackets++;
06538: else
06539: break;
06540: }
06541:
06542: int totalDimenForVar = dimensions + brackets;
06543: // Assocaite here
06544: if (GlobalVariableStore.getVariableDimAss() != null)
06545: GlobalVariableStore.getVariableDimAss()
06546: .put(
06547: new Integer(in),
06548: new Integer(
06549: totalDimenForVar));
06550: }
06551: }
06552: }
06553: if (in == -200) {
06554: GlobalVariableStore.getPushTypes().put(
06555: new Integer(ipos), type);
06556: }
06557:
06558: z--;
06559:
06560: }
06561: boolean ok = false;
06562: if (invoke && !skipthis invoke) {
06563: StringBuffer S = new StringBuffer("");
06564: ok = checkForAssociatedGetField(getField, s, S, code);
06565: if (ok) {
06566: int iS = Integer.parseInt(S.toString());
06567: int refpos = getObjectRefForGetField(iS, code);
06568: if (refpos != -1) {
06569: if (invokeinstrefpos.get(new Integer(s)) == null) {
06570: invokeinstrefpos.put(new Integer(s),
06571: new Integer(refpos));
06572: }
06573:
06574: }
06575: }
06576: if (!ok) {
06577: S = new StringBuffer("");
06578: ok = checkForAssociatedGetStatic(getStatic, s, S, code); // TODO:
06579: // possible
06580: // bug
06581: // :
06582: // check
06583: // for
06584: // pop
06585: // and
06586: // aload
06587: // then
06588: if (ok) {
06589: int iS = Integer.parseInt(S.toString());
06590: if ((iS - 1) >= 0 && code[iS - 1] == JvmOpCodes.POP) {
06591: StringBuffer s2 = new StringBuffer("");
06592: boolean bb = isPrevInstructionAload(iS - 1,
06593: code, s2);
06594: if (bb) {
06595: iS = Integer.parseInt(s2.toString());
06596: }
06597: }
06598: if (invokeinstrefpos.get(new Integer(s)) == null) {
06599: invokeinstrefpos.put(new Integer(s),
06600: new Integer(iS));
06601: }
06602: }
06603: }
06604: if (!ok) {
06605: S = new StringBuffer("");
06606: ok = checkForAssociatedInvokeSpecial(invokespecialpos,
06607: s, S, code);
06608: if (ok) {
06609: int iS = Integer.parseInt(S.toString());
06610: if (invokeinstrefpos.get(new Integer(s)) == null) {
06611: invokeinstrefpos.put(new Integer(s),
06612: new Integer(iS));
06613: }
06614: }
06615:
06616: }
06617:
06618: }
06619: boolean skip2 = false;
06620: if (!ok && code[s] == JvmOpCodes.INVOKESTATIC && ipos == -1
06621: && !skipthis invoke) {
06622: ipos = s;
06623: if (invokeinstrefpos.get(new Integer(s)) == null) {
06624: invokeinstrefpos.put(new Integer(s), new Integer(ipos));
06625: }
06626: skip2 = true;
06627:
06628: }
06629: if (!ok && code[s] == JvmOpCodes.INVOKESTATIC && ipos != -1
06630: && !skipthis invoke) {
06631: if (invokeinstrefpos.get(new Integer(s)) == null) {
06632: invokeinstrefpos.put(new Integer(s), new Integer(ipos));
06633: }
06634: skip2 = true;
06635:
06636: }
06637:
06638: int prev = s - 1;
06639: if (ipos != -1)
06640: prev = ipos - 1;
06641: if (!ok && prev >= 0 && !skip2 && !skipthis invoke) {
06642: Integer pr = new Integer(prev);
06643: Integer be = (Integer) GlobalVariableStore
06644: .getInvokeStartEnd().get(pr);
06645: if (be != null) {
06646: int Ibe = be.intValue();
06647: if (code[Ibe] == JvmOpCodes.INVOKEVIRTUAL
06648: || code[Ibe] == JvmOpCodes.INVOKEINTERFACE) {
06649: java.lang.String sTR = (java.lang.String) invokeinstrefretTypes
06650: .get(new Integer(Ibe));
06651: if (sTR != null) {
06652: int sep = sTR.indexOf("::");
06653: java.lang.String rEF = sTR.substring(0, sep);
06654: java.lang.String rET = sTR.substring(sep + 2);
06655: if (rEF.trim().equalsIgnoreCase(rET.trim())) {
06656: Integer refpos = (Integer) invokeinstrefpos
06657: .get(new Integer(Ibe));
06658: if (refpos != null) {
06659: int irefpos = refpos.intValue();
06660: Integer reftemp = (Integer) invokeinstrefpos
06661: .get(new Integer(s));
06662: if (reftemp == null) {
06663: invokeinstrefpos.put(
06664: new Integer(s),
06665: new Integer(irefpos));
06666: }
06667: }
06668: } else {
06669: Integer refpos = (Integer) invokeinstrefpos
06670: .get(new Integer(s));
06671: if (refpos == null) {
06672: invokeinstrefpos.put(new Integer(s),
06673: new Integer(Ibe));
06674: }
06675: }
06676: }
06677: }
06678: if (code[Ibe] == JvmOpCodes.INVOKESTATIC
06679: || code[Ibe] == JvmOpCodes.INVOKESPECIAL) {
06680: Integer refpos = (Integer) invokeinstrefpos
06681: .get(new Integer(Ibe));
06682: if (invokeinstrefpos.get(new Integer(s)) == null) {
06683: invokeinstrefpos.put(new Integer(s),
06684: new Integer(refpos.intValue()));
06685: }
06686:
06687: }
06688: } else {
06689: StringBuffer sfb = new StringBuffer("");
06690: boolean bol = isPrevInstructionAload(prev + 1, code,
06691: sfb);
06692: if (bol) {
06693: int aloadpos = Integer.parseInt(sfb.toString());
06694: if (invokeinstrefpos.get(new Integer(s)) == null) {
06695: invokeinstrefpos.put(new Integer(s),
06696: new Integer(aloadpos));
06697:
06698: }
06699: } else {
06700: if (code[prev] == JvmOpCodes.AALOAD) {
06701: int x = prev;
06702: do {
06703: sfb = new StringBuffer("");
06704: x--;
06705: bol = isPrevInstructionAload(x, code, sfb);
06706: } while (!bol);
06707: int aloadpos = Integer.parseInt(sfb.toString());
06708: if (invokeinstrefpos.get(new Integer(s)) == null) {
06709: invokeinstrefpos.put(new Integer(s),
06710: new Integer(aloadpos));
06711: }
06712:
06713: }
06714: }
06715: }
06716:
06717: }
06718:
06719: if (invokeStart_StackStart != null)
06720: invokeStart_StackStart.put(new Integer(s),
06721: new Integer(ipos)); // modify for special/static
06722:
06723: int end = -1;
06724: if (GlobalVariableStore.getInvokeStartEnd() != null) {
06725: end = findWhereThisInvokeEnds(s, code);
06726: GlobalVariableStore.getInvokeStartEnd().put(
06727: new Integer(end), new Integer(s));
06728: }
06729: if (end != -1) {
06730: int next = end + 1;
06731: s = end; // changed from next to end
06732: }
06733:
06734: }
06735: }
06736:
06737: }
06738:
06739: private boolean isInstAAload(int inst) {
06740: return inst == JvmOpCodes.AALOAD;
06741: }
06742:
06743: private int isInstAload(int i, byte[] code, StringBuffer bf) {
06744: if (isThisInstrStart(behaviour.getInstructionStartPositions(), i)) {
06745: switch (code[i]) {
06746:
06747: case JvmOpCodes.ALOAD_0:
06748: bf.append(0);
06749: return i;
06750: case JvmOpCodes.ALOAD_1:
06751: bf.append(1);
06752: return i;
06753: case JvmOpCodes.ALOAD_2:
06754: bf.append(2);
06755: return i;
06756: case JvmOpCodes.ALOAD_3:
06757: bf.append(3);
06758: return i;
06759: case JvmOpCodes.ALOAD:
06760: bf.append(code[(i + 1)]);
06761: return i;
06762:
06763: }
06764: }
06765:
06766: int temp = i - 1;
06767: if (isThisInstrStart(behaviour.getInstructionStartPositions(), temp)) {
06768: if (code[temp] == JvmOpCodes.ALOAD) {
06769: bf.append(code[i]);
06770: return temp;
06771: }
06772: }
06773: return -1;
06774:
06775: }
06776:
06777: // todo: // Search For StringBuffer from here
06778:
06779: private void getCorrespondingLoadInst(StringBuffer index, StringBuffer dim,
06780: int start, StringBuffer pos, Behaviour b, ClassDescription cd,
06781: java.lang.String type, int this invokestart) throws Exception {
06782:
06783: ArrayList starts = b.getInstructionStartPositions();
06784: boolean primitive = isPrimitive(type);
06785:
06786: byte[] code = b.getCode();
06787: int number = 0;
06788: boolean aaloadFound = false;
06789: int k = start;
06790: int orig = k;
06791: // Find out the instuction start here
06792: boolean istart = isThisInstrStart(starts, k);
06793: while (istart == false && k >= 0) {
06794: k = k - 1;
06795: istart = isThisInstrStart(starts, k);
06796: }
06797:
06798: // Now k must be inst start
06799:
06800: if (primitive) {
06801:
06802: if (code[k] == JvmOpCodes.ARRAYLENGTH) // TODO: TEST IT THOROUhLY
06803: {
06804:
06805: StringBuffer s6 = new StringBuffer("");
06806: boolean aloadp = isPrevInstructionAload(k, code, s6);
06807: if (aloadp) {
06808: index.append(-200);
06809: dim.append(0);
06810: pos.append(Integer.parseInt(s6.toString()));
06811: return;
06812: }
06813: if ((k - 1) >= 0) {
06814: boolean aaloadp = isInstAAload(code[k - 1]); // BUG check
06815: // for
06816: // getstatic
06817: // alos.:TODO
06818: if (aaloadp) {
06819: s6 = new StringBuffer("");
06820: int in = k - 1;
06821: int posFound = isInstAload(in, code, s6);
06822: while (posFound == -1) {
06823: in = in - 1;
06824: posFound = isInstAload(in, code, s6);
06825: if (posFound == -1) {
06826: if (code[in] == JvmOpCodes.GETSTATIC) // TODO:
06827: // Need
06828: // to
06829: // check
06830: // at
06831: // all
06832: // such
06833: // places
06834: // whether
06835: // the
06836: // index
06837: // is
06838: // start
06839: // of
06840: // instruction
06841: {
06842:
06843: if (code[in - 1] == JvmOpCodes.POP) // TODO:
06844: // Possible
06845: // bug
06846: // with
06847: // pop2
06848: {
06849: StringBuffer s3 = new StringBuffer("");
06850: boolean bb = isPrevInstructionAload(
06851: in - 1, code, s3);
06852: if (bb) {
06853: index.append(-200);
06854: dim.append(0);
06855: pos.append(Integer.parseInt(s3
06856: .toString()));
06857: return;
06858: }
06859: } else {
06860: index.append(-200);
06861: dim.append(0);
06862: pos.append(in);
06863: return;
06864: }
06865:
06866: }
06867: if (code[in] == JvmOpCodes.GETFIELD) {
06868: s6 = new StringBuffer("");
06869: aloadp = isPrevInstructionAload(in, code,
06870: s6);
06871: index.append(-200);
06872: dim.append(0);
06873: pos.append(Integer.parseInt(s6.toString()));
06874: return;
06875: }
06876:
06877: }
06878:
06879: }
06880: index.append(-200);
06881: dim.append(0);
06882: pos.append(posFound);
06883: return;
06884:
06885: }
06886: }
06887: if ((k - 3) >= 0) {
06888: boolean getfield = (code[k - 3] == JvmOpCodes.GETFIELD);
06889: if (getfield) {
06890: s6 = new StringBuffer("");
06891: aloadp = isPrevInstructionAload(k - 3, code, s6);
06892: index.append(-200);
06893: dim.append(0);
06894: pos.append(Integer.parseInt(s6.toString()));
06895: return;
06896: }
06897: }
06898: if ((k - 3) >= 0) {
06899: boolean getS = (code[k - 3] == JvmOpCodes.GETSTATIC);
06900: if (getS) {
06901: if (code[k - 4] == JvmOpCodes.POP) // TODO: Possible
06902: // bug with pop2
06903: {
06904: StringBuffer s3 = new StringBuffer("");
06905: boolean bb = isPrevInstructionAload(k - 4, code, s3);
06906: if (bb) {
06907: index.append(-200);
06908: dim.append(0);
06909: pos.append(Integer.parseInt(s3.toString()));
06910: return;
06911: }
06912: }
06913: index.append(-200);
06914: dim.append(0);
06915: pos.append(k - 3);
06916: return;
06917:
06918: }
06919: }
06920:
06921: // TODO:newarray ?
06922:
06923: if ((k - 4) >= 0) {
06924: boolean multi = (code[k - 4] == JvmOpCodes.MULTIANEWARRAY);
06925: if (multi) {
06926: stackHandler = new Stack();
06927: InstParam first = new InstParam();
06928: first.setNumberOfParamsLeft(code[k - 4 + 3]);
06929: first.setCurrentParamOffsetInCode(-1);
06930: stackHandler.push(first);
06931: handleBasicPrimitiveLoadOp(code, k - 5);
06932: index.append(-100);
06933: dim.append(0);
06934: InstParam obj = (InstParam) stackHandler.pop(); // should
06935: // be
06936: // first
06937: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
06938: // check
06939: // whether
06940: // this
06941: // is
06942: // correct
06943: return;
06944:
06945: }
06946: }
06947: if ((k - 3) >= 0) {
06948:
06949: boolean multi = (code[k - 3] == JvmOpCodes.ANEWARRAY);
06950: if (multi) {
06951:
06952: stackHandler = new Stack();
06953: InstParam first = new InstParam();
06954: first.setNumberOfParamsLeft(1);
06955: first.setCurrentParamOffsetInCode(-1);
06956: stackHandler.push(first);
06957: handleBasicPrimitiveLoadOp(code, k - 3 - 1);
06958: index.append(-100);
06959: dim.append(0);
06960: InstParam obj = (InstParam) stackHandler.pop(); // should
06961: // be
06962: // first
06963: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
06964: // check
06965: // whether
06966: // this
06967: // is
06968: // correct
06969: return;
06970:
06971: }
06972: }
06973:
06974: if ((k - 2) >= 0) {
06975:
06976: boolean multi = (code[k - 2] == JvmOpCodes.NEWARRAY);
06977: if (multi) {
06978:
06979: stackHandler = new Stack();
06980: InstParam first = new InstParam();
06981: first.setNumberOfParamsLeft(1);
06982: first.setCurrentParamOffsetInCode(-1);
06983: stackHandler.push(first);
06984: handleBasicPrimitiveLoadOp(code, k - 3);
06985: index.append(-100);
06986: dim.append(0);
06987: InstParam obj = (InstParam) stackHandler.pop(); // should
06988: // be
06989: // first
06990: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
06991: // check
06992: // whether
06993: // this
06994: // is
06995: // correct
06996: return;
06997:
06998: }
06999: }
07000:
07001: }
07002:
07003: }
07004:
07005: if (!primitive && k >= 0) // TODO: Need to check for getstatic and
07006: // getfield also
07007: {
07008: boolean prevAAload = isInstAAload(code[k]); // TODO !!! Can there be
07009: // any other option???
07010: boolean prevaload = false;
07011: if (prevAAload) {
07012: number++;
07013: k = k - 1;
07014: prevAAload = isInstAAload(code[k]);
07015: StringBuffer sb = new StringBuffer("");
07016: int posFound = isInstAload(k, code, sb);
07017: while (posFound == -1) {
07018: if (prevAAload)
07019: number++;
07020: k = k - 1;
07021: prevAAload = isInstAAload(code[k]);
07022: sb = new StringBuffer("");
07023: posFound = isInstAload(k, code, sb);
07024: // ///////////////////
07025: if (posFound == -1) {
07026: if (code[k] == JvmOpCodes.GETSTATIC) // TODO: Need to
07027: // check at all
07028: // such places
07029: // whether the
07030: // index is
07031: // start of
07032: // instruction
07033: {
07034:
07035: if (isThisInstrStart(behaviour
07036: .getInstructionStartPositions(), (k - 1))
07037: && code[k - 1] == JvmOpCodes.POP) // TODO:
07038: // Possible
07039: // bug
07040: // with
07041: // pop2
07042: {
07043: StringBuffer s3 = new StringBuffer("");
07044: boolean bb = isPrevInstructionAload(k - 1,
07045: code, s3);
07046: if (bb) {
07047: index.append(-200);
07048: dim.append(0);
07049: pos.append(Integer.parseInt(s3.toString()));
07050: return;
07051: }
07052: } else {
07053: index.append(-200);
07054: dim.append(0);
07055: pos.append(k);
07056: return;
07057: }
07058:
07059: }
07060: if (code[k] == JvmOpCodes.GETFIELD) {
07061: StringBuffer s6 = new StringBuffer("");
07062: boolean aloadp = isPrevInstructionAload(k, code, s6);
07063: if (aloadp) {
07064: index.append(-200);
07065: dim.append(0);
07066: pos.append(Integer.parseInt(s6.toString()));
07067: return;
07068: }
07069: }
07070:
07071: }
07072: // ///////
07073:
07074: }
07075:
07076: index.append(Integer.parseInt(sb.toString()));
07077: dim.append(number);
07078: pos.append(posFound);
07079: return;
07080:
07081: }
07082: }
07083: if (primitive) {
07084: if (code[k] == JvmOpCodes.BALOAD || code[k] == JvmOpCodes.CALOAD
07085: || code[k] == JvmOpCodes.DALOAD
07086: || code[k] == JvmOpCodes.FALOAD
07087: || code[k] == JvmOpCodes.LALOAD
07088: || code[k] == JvmOpCodes.IALOAD
07089: || code[k] == JvmOpCodes.SALOAD) {
07090: StringBuffer sb = new StringBuffer("");
07091: int posFound = isInstAload(k, code, sb);
07092: while (posFound == -1) {
07093:
07094: k = k - 1;
07095: sb = new StringBuffer("");
07096: posFound = isInstAload(k, code, sb);
07097:
07098: }
07099: index.append(Integer.parseInt(sb.toString()));
07100: dim.append(0);
07101: pos.append(posFound);
07102: return;
07103:
07104: }
07105: }
07106: if (primitive) {
07107: if (code[k] == JvmOpCodes.BIPUSH) {
07108: index.append(-200);
07109: dim.append(0);
07110: pos.append(k);
07111: return;
07112: }
07113: }
07114:
07115: if (primitive) {
07116: if (code[k] == JvmOpCodes.SIPUSH) {
07117: index.append(-200);
07118: dim.append(0);
07119: pos.append(k);
07120: return;
07121: }
07122: }
07123: StringBuffer sfb;
07124: if (!primitive) {
07125: sfb = new StringBuffer("");
07126: int y = isInstAload(k, code, sfb);
07127: if (y != -1) {
07128: index.append(Integer.parseInt(sfb.toString()));
07129: dim.append(0);
07130: pos.append(y);
07131: return;
07132: }
07133: }
07134:
07135: if (primitive) {
07136: sfb = new StringBuffer("");
07137: int y = isInstIloadInst(code, k, sfb);
07138: if (y != -1) {
07139: index.append(Integer.parseInt(sfb.toString()));
07140: dim.append(0);
07141: pos.append(y);
07142: return;
07143: }
07144: }
07145:
07146: if (type.equals("float") || type.equals("double")) {
07147: sfb = new StringBuffer("");
07148: int y = isInstFloadInst(code, k, sfb);
07149: if (y != -1) {
07150: index.append(Integer.parseInt(sfb.toString()));
07151: dim.append(0);
07152: pos.append(y);
07153: return;
07154: }
07155: }
07156:
07157: if (type.equals("double")) {
07158: sfb = new StringBuffer("");
07159: int y = isInstDloadInst(code, k, sfb);
07160: if (y != -1) {
07161: index.append(Integer.parseInt(sfb.toString()));
07162: dim.append(0);
07163: pos.append(y);
07164: return;
07165: }
07166: }
07167:
07168: if (type.equals("float") || type.equals("double")) {
07169: if (code[k] == JvmOpCodes.D2F)// || code[k]==JvmOpCodes.D2I ||
07170: // code[k]==JvmOpCodes.D2L)
07171: {
07172:
07173: int t = k - 1;
07174: StringBuffer strb = new StringBuffer("");
07175: int dload = isInstDloadInst(code, t, strb);
07176: if (dload != -1) {
07177: index.append(-100);
07178: dim.append(0);
07179: pos.append(dload);
07180: return;
07181: } else {
07182: strb = new StringBuffer("");
07183: int loadin = traceLoadInst(t, code, strb);
07184: if (loadin != -1) {
07185: index.append(-100);
07186: dim.append(0);
07187: pos.append(loadin);
07188: return;
07189: }
07190:
07191: }
07192: stackHandler = new Stack();
07193: InstParam first = new InstParam();
07194: first.setNumberOfParamsLeft(1);
07195: first.setCurrentParamOffsetInCode(-1);
07196: stackHandler.push(first);
07197: handleBasicPrimitiveLoadOp(code, k - 1);
07198: index.append(-100);
07199: dim.append(0);
07200: InstParam obj = (InstParam) stackHandler.pop(); // should be
07201: // first
07202: pos.append(obj.getCurrentParamOffsetInCode());
07203: return;
07204:
07205: }
07206: }
07207: if (primitive) {
07208: if (code[k] == JvmOpCodes.D2I)// || code[k]==JvmOpCodes.D2L)
07209: {
07210:
07211: int t = k - 1;
07212: StringBuffer strb = new StringBuffer("");
07213: int dload = isInstDloadInst(code, t, strb);
07214: if (dload != -1) {
07215: index.append(-100);
07216: dim.append(0);
07217: pos.append(dload);
07218: return;
07219: } else {
07220: strb = new StringBuffer("");
07221: int loadin = traceLoadInst(t, code, strb);
07222: if (loadin != -1) {
07223: index.append(-100);
07224: dim.append(0);
07225: pos.append(loadin);
07226: return;
07227: }
07228:
07229: }
07230: stackHandler = new Stack();
07231: InstParam first = new InstParam();
07232: first.setNumberOfParamsLeft(1);
07233: first.setCurrentParamOffsetInCode(-1);
07234: stackHandler.push(first);
07235: handleBasicPrimitiveLoadOp(code, k - 1);
07236: index.append(-100);
07237: dim.append(0);
07238: InstParam obj = (InstParam) stackHandler.pop(); // should be
07239: // first
07240: pos.append(obj.getCurrentParamOffsetInCode());
07241: return;
07242: }
07243: }
07244: if (type.equals("long") || type.equals("float")
07245: || type.equals("double")) {
07246: if (code[k] == JvmOpCodes.D2L) {
07247:
07248: int t = k - 1;
07249: StringBuffer strb = new StringBuffer("");
07250: int dload = isInstDloadInst(code, t, strb);
07251: if (dload != -1) {
07252: index.append(-100);
07253: dim.append(0);
07254: pos.append(dload);
07255: return;
07256: } else {
07257: strb = new StringBuffer("");
07258: int loadin = traceLoadInst(t, code, strb);
07259: if (loadin != -1) {
07260: index.append(-100);
07261: dim.append(0);
07262: pos.append(loadin);
07263: return;
07264: }
07265:
07266: }
07267: stackHandler = new Stack();
07268: InstParam first = new InstParam();
07269: first.setNumberOfParamsLeft(1);
07270: first.setCurrentParamOffsetInCode(-1);
07271: stackHandler.push(first);
07272: handleBasicPrimitiveLoadOp(code, k - 1);
07273: index.append(-100);
07274: dim.append(0);
07275: InstParam obj = (InstParam) stackHandler.pop(); // should be
07276: // first
07277: pos.append(obj.getCurrentParamOffsetInCode());
07278: return;
07279:
07280: }
07281: }
07282:
07283: if (primitive) {
07284: if (code[k] == JvmOpCodes.I2B || code[k] == JvmOpCodes.I2C
07285: || code[k] == JvmOpCodes.I2S)// ||
07286: // code[k]==JvmOpCodes.I2D
07287: // ||
07288: // code[k]==JvmOpCodes.I2F
07289: // ||
07290: // code[k]==JvmOpCodes.I2L
07291: // ||
07292: // code[k]==JvmOpCodes.I2S )
07293: {
07294:
07295: int t = k - 1;
07296: StringBuffer strb = new StringBuffer("");
07297: int Iload = isInstIloadInst(code, t, strb);
07298: if (Iload != -1) {
07299: index.append(-100);
07300: dim.append(0);
07301: pos.append(Iload);
07302: return;
07303: } else {
07304: strb = new StringBuffer("");
07305: int loadin = traceLoadInst(t, code, strb);
07306: if (loadin != -1) {
07307: index.append(-100);
07308: dim.append(0);
07309: pos.append(loadin);
07310: return;
07311: }
07312:
07313: }
07314: stackHandler = new Stack();
07315: InstParam first = new InstParam();
07316: first.setNumberOfParamsLeft(1);
07317: first.setCurrentParamOffsetInCode(-1);
07318: stackHandler.push(first);
07319: handleBasicPrimitiveLoadOp(code, k - 1);
07320: index.append(-100);
07321: dim.append(0);
07322: InstParam obj = (InstParam) stackHandler.pop(); // should be
07323: // first
07324: pos.append(obj.getCurrentParamOffsetInCode());
07325: return;
07326:
07327: }
07328: }
07329:
07330: if (type.equals("double")) {
07331: if (code[k] == JvmOpCodes.I2D)// || code[k]==JvmOpCodes.I2F ||
07332: // code[k]==JvmOpCodes.I2L ||
07333: // code[k]==JvmOpCodes.I2S )
07334: {
07335:
07336: int t = k - 1;
07337: StringBuffer strb = new StringBuffer("");
07338: int Iload = isInstIloadInst(code, t, strb);
07339: if (Iload != -1) {
07340: index.append(-100);
07341: dim.append(0);
07342: pos.append(Iload);
07343: return;
07344: } else {
07345: strb = new StringBuffer("");
07346: int loadin = traceLoadInst(t, code, strb);
07347: if (loadin != -1) {
07348: index.append(-100);
07349: dim.append(0);
07350: pos.append(loadin);
07351: return;
07352: }
07353:
07354: }
07355: stackHandler = new Stack();
07356: InstParam first = new InstParam();
07357: first.setNumberOfParamsLeft(1);
07358: first.setCurrentParamOffsetInCode(-1);
07359: stackHandler.push(first);
07360: handleBasicPrimitiveLoadOp(code, k - 1);
07361: index.append(-100);
07362: dim.append(0);
07363: InstParam obj = (InstParam) stackHandler.pop(); // should be
07364: // first
07365: pos.append(obj.getCurrentParamOffsetInCode());
07366: return;
07367:
07368: }
07369:
07370: }
07371:
07372: if (type.equals("double") || type.equals("float")) {
07373: if (code[k] == JvmOpCodes.I2F)// || code[k]==JvmOpCodes.I2L ||
07374: // code[k]==JvmOpCodes.I2S )
07375: {
07376:
07377: int t = k - 1;
07378: StringBuffer strb = new StringBuffer("");
07379: int Iload = isInstIloadInst(code, t, strb);
07380: if (Iload != -1) {
07381: index.append(-100);
07382: dim.append(0);
07383: pos.append(Iload);
07384: return;
07385: } else {
07386: strb = new StringBuffer("");
07387: int loadin = traceLoadInst(t, code, strb);
07388: if (loadin != -1) {
07389: index.append(-100);
07390: dim.append(0);
07391: pos.append(loadin);
07392: return;
07393: }
07394:
07395: }
07396: stackHandler = new Stack();
07397: InstParam first = new InstParam();
07398: first.setNumberOfParamsLeft(1);
07399: first.setCurrentParamOffsetInCode(-1);
07400: stackHandler.push(first);
07401: handleBasicPrimitiveLoadOp(code, k - 1);
07402: index.append(-100);
07403: dim.append(0);
07404: InstParam obj = (InstParam) stackHandler.pop(); // should be
07405: // first
07406: pos.append(obj.getCurrentParamOffsetInCode());
07407: return;
07408: }
07409: }
07410:
07411: if (type.equals("double") || type.equals("float")
07412: || type.equals("long")) {
07413: if (code[k] == JvmOpCodes.I2L) {
07414:
07415: int t = k - 1;
07416: StringBuffer strb = new StringBuffer("");
07417: int Iload = isInstIloadInst(code, t, strb);
07418: if (Iload != -1) {
07419: index.append(-100);
07420: dim.append(0);
07421: pos.append(Iload);
07422: return;
07423: } else {
07424: strb = new StringBuffer("");
07425: int loadin = traceLoadInst(t, code, strb);
07426: if (loadin != -1) {
07427: index.append(-100);
07428: dim.append(0);
07429: pos.append(loadin);
07430: return;
07431: }
07432:
07433: }
07434: stackHandler = new Stack();
07435: InstParam first = new InstParam();
07436: first.setNumberOfParamsLeft(1);
07437: first.setCurrentParamOffsetInCode(-1);
07438: stackHandler.push(first);
07439: handleBasicPrimitiveLoadOp(code, k - 1);
07440: index.append(-100);
07441: dim.append(0);
07442: InstParam obj = (InstParam) stackHandler.pop(); // should be
07443: // first
07444: pos.append(obj.getCurrentParamOffsetInCode());
07445: return;
07446: }
07447: }
07448:
07449: if (type.equals("double")) {
07450: if (code[k] == JvmOpCodes.F2D)// || code[k]==JvmOpCodes.F2I ||
07451: // code[k]==JvmOpCodes.F2L)
07452: {
07453:
07454: int t = k - 1;
07455: StringBuffer strb = new StringBuffer("");
07456: int Fload = isInstFloadInst(code, t, strb);
07457: if (Fload != -1) {
07458: index.append(-100);
07459: dim.append(0);
07460: pos.append(Fload);
07461: return;
07462: } else {
07463: strb = new StringBuffer("");
07464: int loadin = traceLoadInst(t, code, strb);
07465: if (loadin != -1) {
07466: index.append(-100);
07467: dim.append(0);
07468: pos.append(loadin);
07469: return;
07470: }
07471:
07472: }
07473: stackHandler = new Stack();
07474: InstParam first = new InstParam();
07475: first.setNumberOfParamsLeft(1);
07476: first.setCurrentParamOffsetInCode(-1);
07477: stackHandler.push(first);
07478: handleBasicPrimitiveLoadOp(code, k - 1);
07479: index.append(-100);
07480: dim.append(0);
07481: InstParam obj = (InstParam) stackHandler.pop(); // should be
07482: // first
07483: pos.append(obj.getCurrentParamOffsetInCode());
07484: return;
07485: }
07486: }
07487:
07488: if (type.equals("double") || type.equals("float")
07489: || type.equals("long")) {
07490: if (code[k] == JvmOpCodes.F2L)// || code[k]==JvmOpCodes.F2I ||
07491: // code[k]==JvmOpCodes.F2L)
07492: {
07493:
07494: int t = k - 1;
07495: StringBuffer strb = new StringBuffer("");
07496: int Fload = isInstFloadInst(code, t, strb);
07497: if (Fload != -1) {
07498: index.append(-100);
07499: dim.append(0);
07500: pos.append(Fload);
07501: return;
07502: } else {
07503: strb = new StringBuffer("");
07504: int loadin = traceLoadInst(t, code, strb);
07505: if (loadin != -1) {
07506: index.append(-100);
07507: dim.append(0);
07508: pos.append(loadin);
07509: return;
07510: }
07511:
07512: }
07513: stackHandler = new Stack();
07514: InstParam first = new InstParam();
07515: first.setNumberOfParamsLeft(1);
07516: first.setCurrentParamOffsetInCode(-1);
07517: stackHandler.push(first);
07518: handleBasicPrimitiveLoadOp(code, k - 1);
07519: index.append(-100);
07520: dim.append(0);
07521: InstParam obj = (InstParam) stackHandler.pop(); // should be
07522: // first
07523: pos.append(obj.getCurrentParamOffsetInCode());
07524: return;
07525: }
07526: }
07527: if (primitive) {
07528: if (code[k] == JvmOpCodes.F2I) {
07529:
07530: int t = k - 1;
07531: StringBuffer strb = new StringBuffer("");
07532: int Fload = isInstFloadInst(code, t, strb);
07533: if (Fload != -1) {
07534: index.append(-100);
07535: dim.append(0);
07536: pos.append(Fload);
07537: return;
07538: } else {
07539: strb = new StringBuffer("");
07540: int loadin = traceLoadInst(t, code, strb);
07541: if (loadin != -1) {
07542: index.append(-100);
07543: dim.append(0);
07544: pos.append(loadin);
07545: return;
07546: }
07547:
07548: }
07549: stackHandler = new Stack();
07550: InstParam first = new InstParam();
07551: first.setNumberOfParamsLeft(1);
07552: first.setCurrentParamOffsetInCode(-1);
07553: stackHandler.push(first);
07554: handleBasicPrimitiveLoadOp(code, k - 1);
07555: index.append(-100);
07556: dim.append(0);
07557: InstParam obj = (InstParam) stackHandler.pop(); // should be
07558: // first
07559: pos.append(obj.getCurrentParamOffsetInCode());
07560: return;
07561: }
07562: }
07563:
07564: if (type.equals("double")) {
07565: if (code[k] == JvmOpCodes.L2D)// || code[k]==JvmOpCodes.L2F ||
07566: // code[k]==JvmOpCodes.L2I)
07567: {
07568:
07569: int t = k - 1;
07570: StringBuffer strb = new StringBuffer("");
07571: int Fload = isInstLloadInst(code, t, strb);
07572: if (Fload != -1) {
07573: index.append(-100);
07574: dim.append(0);
07575: pos.append(Fload);
07576: return;
07577: } else {
07578: strb = new StringBuffer("");
07579: int loadin = traceLoadInst(t, code, strb);
07580: if (loadin != -1) {
07581: index.append(-100);
07582: dim.append(0);
07583: pos.append(loadin);
07584: return;
07585: }
07586:
07587: }
07588: stackHandler = new Stack();
07589: InstParam first = new InstParam();
07590: first.setNumberOfParamsLeft(1);
07591: first.setCurrentParamOffsetInCode(-1);
07592: stackHandler.push(first);
07593: handleBasicPrimitiveLoadOp(code, k - 1);
07594: index.append(-100);
07595: dim.append(0);
07596: InstParam obj = (InstParam) stackHandler.pop(); // should be
07597: // first
07598: pos.append(obj.getCurrentParamOffsetInCode());
07599: return;
07600:
07601: }
07602: }
07603:
07604: if (type.equals("double") || type.equals("float")) {
07605: if (code[k] == JvmOpCodes.L2F)// || code[k]==JvmOpCodes.L2I)
07606: {
07607:
07608: int t = k - 1;
07609: StringBuffer strb = new StringBuffer("");
07610: int Fload = isInstLloadInst(code, t, strb);
07611: if (Fload != -1) {
07612: index.append(-100);
07613: dim.append(0);
07614: pos.append(Fload);
07615: return;
07616: } else {
07617: strb = new StringBuffer("");
07618: int loadin = traceLoadInst(t, code, strb);
07619: if (loadin != -1) {
07620: index.append(-100);
07621: dim.append(0);
07622: pos.append(loadin);
07623: return;
07624: }
07625:
07626: }
07627: stackHandler = new Stack();
07628: InstParam first = new InstParam();
07629: first.setNumberOfParamsLeft(1);
07630: first.setCurrentParamOffsetInCode(-1);
07631: stackHandler.push(first);
07632: handleBasicPrimitiveLoadOp(code, k - 1);
07633: index.append(-100);
07634: dim.append(0);
07635: InstParam obj = (InstParam) stackHandler.pop(); // should be
07636: // first
07637: pos.append(obj.getCurrentParamOffsetInCode());
07638: return;
07639:
07640: }
07641: }
07642:
07643: if (primitive) {
07644: if (code[k] == JvmOpCodes.L2I) {
07645:
07646: int t = k - 1;
07647: StringBuffer strb = new StringBuffer("");
07648: int Fload = isInstLloadInst(code, t, strb);
07649: if (Fload != -1) {
07650: index.append(-100);
07651: dim.append(0);
07652: pos.append(Fload);
07653: return;
07654: } else {
07655: strb = new StringBuffer("");
07656: int loadin = traceLoadInst(t, code, strb);
07657: if (loadin != -1) {
07658: index.append(-100);
07659: dim.append(0);
07660: pos.append(loadin);
07661: return;
07662: }
07663:
07664: }
07665: stackHandler = new Stack();
07666: InstParam first = new InstParam();
07667: first.setNumberOfParamsLeft(1);
07668: first.setCurrentParamOffsetInCode(-1);
07669: stackHandler.push(first);
07670: handleBasicPrimitiveLoadOp(code, k - 1);
07671: index.append(-100);
07672: dim.append(0);
07673: InstParam obj = (InstParam) stackHandler.pop(); // should be
07674: // first
07675: pos.append(obj.getCurrentParamOffsetInCode());
07676: return;
07677:
07678: }
07679: }
07680: int tmp = k;
07681: if (tmp >= 0 && code[tmp] == JvmOpCodes.LDC) {
07682: index.append(-100);
07683: dim.append(0);
07684: pos.append(tmp);
07685: return;
07686: }
07687:
07688: if (tmp >= 0 && code[tmp] == JvmOpCodes.LDC_W)// ||
07689: // code[tmp]==JvmOpCodes.LDC2_W)
07690: {
07691: index.append(-100);
07692: dim.append(0);
07693: pos.append(tmp);
07694: return;
07695: }
07696: if (type.equals("long") || type.equals("float")
07697: || type.equals("double")) {
07698: tmp = k;
07699: if (tmp >= 0 && code[tmp] == JvmOpCodes.LDC2_W) {
07700: index.append(-100);
07701: dim.append(0);
07702: pos.append(tmp);
07703: return;
07704: }
07705: }
07706:
07707: if (!primitive && k >= 0) {
07708: if (code[k] == JvmOpCodes.ACONST_NULL) {
07709: index.append(-100);
07710: dim.append(0);
07711: pos.append(k);
07712: return;
07713: }
07714: }
07715: if (primitive && k >= 0) {
07716: if (isInstIConstInst(code, k) != -1) //
07717: {
07718: index.append(-100);
07719: dim.append(0);
07720: pos.append(k);
07721: return;
07722: }
07723: }
07724: if (type.equals("float") || type.equals("double")) {
07725: if (k >= 0 && isInstFConstInst(code, k) != -1) {
07726: index.append(-100);
07727: dim.append(0);
07728: pos.append(k);
07729: return;
07730: }
07731: }
07732:
07733: if (type.equals("double")) {
07734: if (k >= 0 && isInstdConstInst(code, k) != -1) {
07735: index.append(-100);
07736: dim.append(0);
07737: pos.append(k);
07738: return;
07739: }
07740: }
07741: if (type.equals("float") || type.equals("double")
07742: || type.equals("long")) {
07743: if (k >= 0 && isInstLConstInst(code, k) != -1) {
07744: index.append(-100);
07745: dim.append(0);
07746: pos.append(k);
07747: return;
07748: }
07749: }
07750:
07751: if (!primitive) {
07752:
07753: if (k >= 0 && code[k] == JvmOpCodes.MULTIANEWARRAY) {
07754: stackHandler = new Stack();
07755: InstParam first = new InstParam();
07756: first.setNumberOfParamsLeft(code[k + 3]);
07757: first.setCurrentParamOffsetInCode(-1);
07758: stackHandler.push(first);
07759: handleBasicPrimitiveLoadOp(code, k - 1);
07760: index.append(-100);
07761: dim.append(0);
07762: InstParam obj = (InstParam) stackHandler.pop(); // should be
07763: // first
07764: pos.append(obj.getCurrentParamOffsetInCode()); // TODO: check
07765: // whether this
07766: // is correct
07767: return;
07768: }
07769: if (k >= 0
07770: && (code[k] == JvmOpCodes.ANEWARRAY || code[k] == JvmOpCodes.NEWARRAY)) {
07771:
07772: stackHandler = new Stack();
07773: InstParam first = new InstParam();
07774: first.setNumberOfParamsLeft(1);
07775: first.setCurrentParamOffsetInCode(-1);
07776: stackHandler.push(first);
07777: handleBasicPrimitiveLoadOp(code, k - 1);
07778: index.append(-100);
07779: dim.append(0);
07780: InstParam obj = (InstParam) stackHandler.pop(); // should be
07781: // first
07782: pos.append(obj.getCurrentParamOffsetInCode()); // TODO: check
07783: // whether this
07784: // is correct
07785: return;
07786:
07787: }
07788:
07789: }
07790:
07791: if (primitive) {
07792:
07793: if (k >= 0 && (code[k] == JvmOpCodes.INSTANCEOF)) {
07794: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
07795: (k - 2))
07796: && code[k - 2] == JvmOpCodes.NEWARRAY) {
07797:
07798: stackHandler = new Stack();
07799: InstParam first = new InstParam();
07800: first.setNumberOfParamsLeft(1);
07801: first.setCurrentParamOffsetInCode(-1);
07802: stackHandler.push(first);
07803: handleBasicPrimitiveLoadOp(code, k - 3);
07804: index.append(-100);
07805: dim.append(0);
07806: InstParam obj = (InstParam) stackHandler.pop(); // should be
07807: // first
07808: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
07809: // check
07810: // whether
07811: // this is
07812: // correct
07813: return;
07814:
07815: }
07816: StringBuffer s8 = new StringBuffer("");
07817: boolean aloadp = isPrevInstructionAload(k, code, s8);
07818: if (aloadp) {
07819:
07820: index.append(-100);
07821: dim.append(0);
07822: pos.append(Integer.parseInt(s8.toString()));
07823: return;
07824: }
07825: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
07826: (k - 3))
07827: && code[k - 3] == JvmOpCodes.ANEWARRAY) {
07828:
07829: stackHandler = new Stack();
07830: InstParam first = new InstParam();
07831: first.setNumberOfParamsLeft(1);
07832: first.setCurrentParamOffsetInCode(-1);
07833: stackHandler.push(first);
07834: handleBasicPrimitiveLoadOp(code, k - 4);
07835: index.append(-100);
07836: dim.append(0);
07837: InstParam obj = (InstParam) stackHandler.pop(); // should be
07838: // first
07839: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
07840: // check
07841: // whether
07842: // this is
07843: // correct
07844: return;
07845: }
07846: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
07847: (k - 4))
07848: && code[k - 4] == JvmOpCodes.MULTIANEWARRAY) {
07849: stackHandler = new Stack();
07850: InstParam first = new InstParam();
07851: first.setNumberOfParamsLeft(code[k - 4 + 3]);
07852: first.setCurrentParamOffsetInCode(-1);
07853: stackHandler.push(first);
07854: handleBasicPrimitiveLoadOp(code, k - 5);
07855: index.append(-100);
07856: dim.append(0);
07857: InstParam obj = (InstParam) stackHandler.pop(); // should be
07858: // first
07859: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
07860: // check
07861: // whether
07862: // this is
07863: // correct
07864: return;
07865: }
07866:
07867: }
07868:
07869: }
07870:
07871: if (!primitive) {
07872: if (k >= 0 && code[k] == JvmOpCodes.CHECKCAST) {
07873: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
07874: (k - 4))
07875: && code[k - 4] == JvmOpCodes.MULTIANEWARRAY) {
07876: stackHandler = new Stack();
07877: InstParam first = new InstParam();
07878: first.setNumberOfParamsLeft(code[k - 4 + 3]);
07879: first.setCurrentParamOffsetInCode(-1);
07880: stackHandler.push(first);
07881: handleBasicPrimitiveLoadOp(code, k - 5);
07882: index.append(-100);
07883: dim.append(0);
07884: InstParam obj = (InstParam) stackHandler.pop(); // should be
07885: // first
07886: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
07887: // check
07888: // whether
07889: // this is
07890: // correct
07891: return;
07892: } else if (isThisInstrStart(behaviour
07893: .getInstructionStartPositions(), (k - 3))
07894: && code[k - 3] == JvmOpCodes.ANEWARRAY) {
07895:
07896: stackHandler = new Stack();
07897: InstParam first = new InstParam();
07898: first.setNumberOfParamsLeft(1);
07899: first.setCurrentParamOffsetInCode(-1);
07900: stackHandler.push(first);
07901: handleBasicPrimitiveLoadOp(code, k - 4);
07902: index.append(-100);
07903: dim.append(0);
07904: InstParam obj = (InstParam) stackHandler.pop(); // should be
07905: // first
07906: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
07907: // check
07908: // whether
07909: // this is
07910: // correct
07911: return;
07912:
07913: } else if (isThisInstrStart(behaviour
07914: .getInstructionStartPositions(), (k - 2))
07915: && code[k - 2] == JvmOpCodes.NEWARRAY) {
07916:
07917: stackHandler = new Stack();
07918: InstParam first = new InstParam();
07919: first.setNumberOfParamsLeft(1);
07920: first.setCurrentParamOffsetInCode(-1);
07921: stackHandler.push(first);
07922: handleBasicPrimitiveLoadOp(code, k - 3);
07923: index.append(-100);
07924: dim.append(0);
07925: InstParam obj = (InstParam) stackHandler.pop(); // should be
07926: // first
07927: pos.append(obj.getCurrentParamOffsetInCode()); // TODO:
07928: // check
07929: // whether
07930: // this is
07931: // correct
07932: return;
07933:
07934: } else {
07935: StringBuffer s5 = new StringBuffer("");
07936: boolean aload = isPrevInstructionAload(k, code, s5);
07937: if (aload) {
07938: index.append(-100);
07939: dim.append(0);
07940: pos.append(Integer.parseInt(s5.toString()));
07941: return;
07942: }
07943:
07944: }
07945:
07946: // Check for other object refs....
07947: if ((k - 1) >= 0) {
07948: boolean aaloadp = isInstAAload(code[k - 1]); // BUG check
07949: // for
07950: // getstatic
07951: // alos.:TODO
07952: if (aaloadp) {
07953: StringBuffer s6 = new StringBuffer("");
07954: int in = k - 1;
07955: int posFound = isInstAload(in, code, s6);
07956: while (posFound == -1) {
07957: in = in - 1;
07958: posFound = isInstAload(in, code, s6);
07959: if (posFound == -1) {
07960: if (code[in] == JvmOpCodes.GETSTATIC) // TODO:
07961: // Need
07962: // to
07963: // check
07964: // at
07965: // all
07966: // such
07967: // places
07968: // whether
07969: // the
07970: // index
07971: // is
07972: // start
07973: // of
07974: // instruction
07975: {
07976:
07977: if (isThisInstrStart(behaviour
07978: .getInstructionStartPositions(),
07979: (in - 1))
07980: && code[in - 1] == JvmOpCodes.POP) // TODO:
07981: // Possible
07982: // bug
07983: // with
07984: // pop2
07985: {
07986: StringBuffer s3 = new StringBuffer("");
07987: boolean bb = isPrevInstructionAload(
07988: in - 1, code, s3);
07989: if (bb) {
07990: index.append(-200);
07991: dim.append(0);
07992: pos.append(Integer.parseInt(s3
07993: .toString()));
07994: return;
07995: }
07996: } else {
07997: index.append(-200);
07998: dim.append(0);
07999: pos.append(in);
08000: return;
08001: }
08002:
08003: }
08004: if (code[in] == JvmOpCodes.GETFIELD) {
08005: s6 = new StringBuffer("");
08006: boolean aloadp = isPrevInstructionAload(in,
08007: code, s6);
08008: if (aloadp) {
08009: index.append(-200);
08010: dim.append(0);
08011: pos.append(Integer.parseInt(s6
08012: .toString()));
08013: return;
08014: }
08015: }
08016:
08017: }
08018:
08019: }
08020: index.append(-200);
08021: dim.append(0);
08022: pos.append(posFound);
08023: return;
08024:
08025: }
08026: } // here
08027: if ((k - 3) >= 0) {
08028: boolean getfield = (code[k - 3] == JvmOpCodes.GETFIELD);
08029: if (getfield) {
08030: StringBuffer s6 = new StringBuffer("");
08031: boolean aloadp = isPrevInstructionAload(k - 3, code, s6);
08032: if (aloadp) {
08033: index.append(-200);
08034: dim.append(0);
08035: pos.append(Integer.parseInt(s6.toString()));
08036: return;
08037: }
08038: }
08039: }
08040: if ((k - 3) >= 0) {
08041: boolean getS = (code[k - 3] == JvmOpCodes.GETSTATIC);
08042: if (getS) {
08043: if (code[k - 4] == JvmOpCodes.POP) // TODO: Possible
08044: // bug with pop2
08045: {
08046: StringBuffer s3 = new StringBuffer("");
08047: boolean bb = isPrevInstructionAload(k - 4, code, s3);
08048: if (bb) {
08049: index.append(-200);
08050: dim.append(0);
08051: pos.append(Integer.parseInt(s3.toString()));
08052: return;
08053: }
08054: }
08055: index.append(-200);
08056: dim.append(0);
08057: pos.append(k - 3);
08058: return;
08059:
08060: }
08061: }
08062:
08063: // if(isNextInstructionAnyInvoke(code))
08064: Integer isinvokestart = (Integer) GlobalVariableStore
08065: .getInvokeStartEnd().get(new Integer(k - 1));
08066: if (isinvokestart != null) {
08067:
08068: Integer refpos = (Integer) invokeinstrefpos
08069: .get(new Integer(isinvokestart.intValue()));
08070: if (refpos != null) {
08071: index.append(-200);
08072: dim.append(0);
08073: pos.append(refpos.intValue());
08074: return;
08075: }
08076:
08077: }
08078:
08079: }
08080:
08081: }
08082:
08083: if (primitive) {
08084: StringBuffer sb = new StringBuffer("");
08085: boolean p = isInstAnyBasicPrimitiveOperation(code, k, sb);
08086:
08087: if (p) {
08088: // belurs:
08089:
08090: // Here need to call a function which will handle tyes like
08091: // imul,lmul,ldiv etc
08092: // This function needs to be recursive. Handle this function
08093: // with care
08094: // In this case the code will not set the index position because
08095: // any complex sequence of jvm blocks can be present for this
08096: // instruction itself. so for time being , what is important is
08097: // that
08098: // this function should return load position for this jvm instr
08099: // so that
08100: // for the next parameter the code will know from where to
08101: // continue.
08102:
08103: stackHandler = new Stack();
08104: InstParam first = new InstParam();
08105: first.setNumberOfParamsLeft(Integer.parseInt(sb.toString()));
08106: first.setCurrentParamOffsetInCode(-1);
08107: stackHandler.push(first);
08108: handleBasicPrimitiveLoadOp(code, k - 1);
08109: index.append(-100);
08110: dim.append(0);
08111: InstParam obj = (InstParam) stackHandler.pop(); // should be
08112: // first
08113: pos.append(obj.getCurrentParamOffsetInCode()); // TODO: check
08114: // whether this
08115: // is correct
08116: return;
08117:
08118: }
08119:
08120: }
08121:
08122: // This 2 should be last.
08123: // Any new thing should come before this 2
08124: if (k >= 0 && code[k] == JvmOpCodes.GETFIELD) {
08125: StringBuffer sb1 = new StringBuffer("");
08126:
08127: int pos2 = isInstAload(k - 1, code, sb1);
08128: if (pos2 != -1) {
08129: index.append(Integer.parseInt(sb1.toString()));
08130: dim.append(0);
08131: pos.append(pos2);
08132: return;
08133: }
08134: }
08135: if (k >= 0 && code[k] == JvmOpCodes.GETSTATIC) // POSSIBLE BUG: todo
08136: {
08137:
08138: index.append(-100);
08139: dim.append(0);
08140: pos.append(k);
08141: return;
08142:
08143: }
08144:
08145: // }
08146:
08147: }
08148:
08149: private int isInstIloadInst(byte[] code, int s, StringBuffer sb2) {
08150: if (isThisInstrStart(behaviour.getInstructionStartPositions(), s)) {
08151: switch (code[(s)]) {
08152: case JvmOpCodes.ILOAD_0:
08153: sb2.append(0);
08154: return s;
08155:
08156: case JvmOpCodes.ILOAD_1:
08157:
08158: sb2.append(1);
08159: return s;
08160:
08161: case JvmOpCodes.ILOAD_2:
08162:
08163: sb2.append(2);
08164: return s;
08165:
08166: case JvmOpCodes.ILOAD_3:
08167:
08168: sb2.append(3);
08169: return s;
08170:
08171: case JvmOpCodes.ILOAD:
08172: sb2.append(code[s + 1]);
08173: return s;
08174:
08175: }
08176: }
08177: int temp = s - 1;
08178: if (temp >= 0
08179: && isThisInstrStart(behaviour.getInstructionStartPositions(),
08180: temp) && code[temp] == JvmOpCodes.ILOAD) {
08181: sb2.append(code[s]);
08182: return temp;
08183:
08184: }
08185:
08186: return -1;
08187:
08188: }
08189:
08190: private int isInstFloadInst(byte[] code, int s, StringBuffer sb2) {
08191: if (isThisInstrStart(behaviour.getInstructionStartPositions(), s)) {
08192: switch (code[(s)]) {
08193: case JvmOpCodes.FLOAD_0:
08194: sb2.append(0);
08195: return s;
08196:
08197: case JvmOpCodes.FLOAD_1:
08198:
08199: sb2.append(1);
08200: return s;
08201:
08202: case JvmOpCodes.FLOAD_2:
08203:
08204: sb2.append(2);
08205: return s;
08206:
08207: case JvmOpCodes.FLOAD_3:
08208:
08209: sb2.append(3);
08210: return s;
08211:
08212: case JvmOpCodes.FLOAD:
08213:
08214: sb2.append(code[(s + 1)]);
08215: return s;
08216:
08217: }
08218: }
08219:
08220: int temp = s - 1;
08221: if (isThisInstrStart(behaviour.getInstructionStartPositions(), temp)
08222: && code[temp] == JvmOpCodes.FLOAD) {
08223: sb2.append(code[s]);
08224: return temp;
08225:
08226: }
08227:
08228: return -1;
08229:
08230: }
08231:
08232: private int isInstDloadInst(byte[] code, int s, StringBuffer sb2) {
08233: if (isThisInstrStart(behaviour.getInstructionStartPositions(), s)) {
08234:
08235: switch (code[(s)]) {
08236: case JvmOpCodes.DLOAD_0:
08237: sb2.append(0);
08238: return s;
08239:
08240: case JvmOpCodes.DLOAD_1:
08241:
08242: sb2.append(1);
08243: return s;
08244:
08245: case JvmOpCodes.DLOAD_2:
08246:
08247: sb2.append(2);
08248: return s;
08249:
08250: case JvmOpCodes.DLOAD_3:
08251:
08252: sb2.append(3);
08253: return s;
08254:
08255: case JvmOpCodes.DLOAD:
08256: sb2.append(code[s + 1]);
08257: return s;
08258:
08259: }
08260: }
08261: int temp = s - 1;
08262: if (isThisInstrStart(behaviour.getInstructionStartPositions(), temp)
08263: && code[temp] == JvmOpCodes.DLOAD) {
08264: sb2.append(code[s]);
08265: return temp;
08266:
08267: }
08268:
08269: return -1;
08270:
08271: }
08272:
08273: private int isInstLloadInst(byte[] code, int s, StringBuffer sb2) {
08274: if (isThisInstrStart(behaviour.getInstructionStartPositions(), s)) {
08275: switch (code[(s)]) {
08276: case JvmOpCodes.LLOAD_0:
08277: sb2.append(0);
08278: return s;
08279:
08280: case JvmOpCodes.LLOAD_1:
08281:
08282: sb2.append(1);
08283: return s;
08284:
08285: case JvmOpCodes.LLOAD_2:
08286:
08287: sb2.append(2);
08288: return s;
08289:
08290: case JvmOpCodes.LLOAD_3:
08291:
08292: sb2.append(3);
08293: return s;
08294:
08295: /*
08296: * case JvmOpCodes.ILOAD: sb2.append(code[s+1]); return s;
08297: */
08298:
08299: }
08300: }
08301: int temp = s - 1;
08302: if (isThisInstrStart(behaviour.getInstructionStartPositions(), temp)) {
08303: if (code[temp] == JvmOpCodes.LLOAD) {
08304: sb2.append(code[s]);
08305: return temp;
08306:
08307: }
08308: }
08309:
08310: return -1;
08311:
08312: }
08313:
08314: private int isInstIConstInst(byte[] code, int k) {
08315: if (isThisInstrStart(behaviour.getInstructionStartPositions(), k)) {
08316: switch (code[k]) {
08317: case JvmOpCodes.ICONST_0:
08318: case JvmOpCodes.ICONST_1:
08319: case JvmOpCodes.ICONST_2:
08320: case JvmOpCodes.ICONST_3:
08321: case JvmOpCodes.ICONST_M1:
08322: case JvmOpCodes.ICONST_4:
08323: case JvmOpCodes.ICONST_5:
08324: return k;
08325:
08326: }
08327: }
08328: return -1;
08329: }
08330:
08331: private int isInstLConstInst(byte[] code, int k) {
08332: if (isThisInstrStart(behaviour.getInstructionStartPositions(), k)) {
08333: switch (code[k]) {
08334: case JvmOpCodes.LCONST_0:
08335: case JvmOpCodes.LCONST_1:
08336: return k;
08337: }
08338: }
08339: return -1;
08340:
08341: }
08342:
08343: private int isInstFConstInst(byte[] code, int k) {
08344: if (isThisInstrStart(behaviour.getInstructionStartPositions(), k)) {
08345: switch (code[k]) {
08346: case JvmOpCodes.FCONST_0:
08347: case JvmOpCodes.FCONST_1:
08348: case JvmOpCodes.FCONST_2:
08349: return k;
08350: }
08351: }
08352: return -1;
08353: }
08354:
08355: private int isInstdConstInst(byte[] code, int k) {
08356: if (isThisInstrStart(behaviour.getInstructionStartPositions(), k)) {
08357: switch (code[k]) {
08358: case JvmOpCodes.DCONST_0:
08359: case JvmOpCodes.DCONST_1:
08360: return k;
08361: }
08362: }
08363: return -1;
08364: }
08365:
08366: private boolean isPrimitive(java.lang.String type) {
08367: if (type.equals("int") || type.equals("short") || type.equals("char")
08368: || type.equals("byte") || type.equals("long")
08369: || type.equals("float") || type.equals("long")
08370: || type.equals("double") || type.equals("boolean"))
08371: return true;
08372: else
08373: return false;
08374: }
08375:
08376: private int traceLoadInst(int t, byte[] code, StringBuffer strb) {
08377: int pos = -1;
08378: int k = t;
08379:
08380: int getFieldPos = k - 2;
08381:
08382: int invokebegin = -1;
08383: if (GlobalVariableStore.getInvokeStartEnd() != null) {
08384: Integer in = new Integer(k);
08385: Integer invs = (Integer) GlobalVariableStore.getInvokeStartEnd()
08386: .get(in);
08387: if (invs != null) {
08388: invokebegin = invs.intValue();
08389: }
08390: }
08391:
08392: if (isThisInstrStart(behaviour.getInstructionStartPositions(), k)
08393: && code[k] == JvmOpCodes.BALOAD || code[k] == JvmOpCodes.CALOAD
08394: || code[k] == JvmOpCodes.DALOAD || code[k] == JvmOpCodes.FALOAD
08395: || code[k] == JvmOpCodes.LALOAD || code[k] == JvmOpCodes.IALOAD
08396: || code[k] == JvmOpCodes.SALOAD) {
08397:
08398: int posFound = isInstAload(k, code, strb);
08399: while (posFound == -1) {
08400:
08401: k = k - 1;
08402: strb = new StringBuffer("");
08403: posFound = isInstAload(k, code, strb);
08404:
08405: }
08406: return posFound;
08407:
08408: } else if (invokebegin != -1
08409: && isThisInstrStart(behaviour.getInstructionStartPositions(),
08410: invokebegin)) {
08411: if (isNextInstructionAnyInvoke(code[invokebegin], new StringBuffer(
08412: ""))) {
08413: if (invokeinstrefpos != null) {
08414: Integer in = (Integer) invokeinstrefpos.get(new Integer(
08415: invokebegin));
08416: if (in != null) {
08417: int start = (in).intValue();
08418: return start;
08419: }
08420:
08421: }
08422: }
08423: }
08424:
08425: else if (code[getFieldPos] == JvmOpCodes.GETFIELD
08426: && isThisInstrStart(behaviour.getInstructionStartPositions(),
08427: getFieldPos)) {
08428: StringBuffer sb = new StringBuffer("");
08429: boolean ok = isPrevInstructionAload(getFieldPos, code, sb);
08430: if (ok) {
08431: int ref = Integer.parseInt(sb.toString());
08432: return ref;
08433: }
08434:
08435: } else if (isThisInstrStart(behaviour.getInstructionStartPositions(),
08436: getFieldPos)
08437: && code[getFieldPos] == JvmOpCodes.GETSTATIC) {
08438:
08439: if (code[getFieldPos - 1] == JvmOpCodes.POP) // TODO: Possible
08440: // bug with pop2
08441: {
08442: StringBuffer s3 = new StringBuffer("");
08443: boolean bb = isPrevInstructionAload(getFieldPos - 1, code, s3);
08444: if (bb) {
08445: return Integer.parseInt(s3.toString());
08446: }
08447: }
08448:
08449: return getFieldPos;
08450: } else {
08451:
08452: // NOTE: The name is slightly misleading....what we want here is
08453: // actually the previous inst...
08454: // Using this as it serves the pupose
08455: if (isNextInstructionConversionInst(code[k])) {
08456:
08457: int g = k - 1;
08458: int invokened = -1;
08459: while (isNextInstructionConversionInst(code[g])) {
08460: g = g - 1;
08461: }
08462: invokebegin = -1;
08463: if (GlobalVariableStore.getInvokeStartEnd() != null) {
08464: Integer in = new Integer(g);
08465: Integer invs = (Integer) GlobalVariableStore
08466: .getInvokeStartEnd().get(in);
08467: if (invs != null) {
08468: invokebegin = invs.intValue();
08469: }
08470: }
08471: StringBuffer sbf = new StringBuffer("");
08472: if (isPrevInstPrimitiveLoad(code, (g + 1), sbf)) {
08473: pos = Integer.parseInt(sbf.toString());
08474: return pos;
08475: } else if (invokebegin != -1) {
08476: if (isNextInstructionAnyInvoke(code[invokebegin],
08477: new StringBuffer(""))) {
08478: if (invokeinstrefpos != null) {
08479: Integer in = (Integer) invokeinstrefpos
08480: .get(new Integer(invokebegin));
08481: if (in != null) {
08482: int start = (in).intValue();
08483: return start;
08484: }
08485:
08486: }
08487: }
08488: } else {
08489: k = g;
08490: if (isThisInstrStart(behaviour
08491: .getInstructionStartPositions(), k)
08492: && (code[k] == JvmOpCodes.BALOAD
08493: || code[k] == JvmOpCodes.CALOAD
08494: || code[k] == JvmOpCodes.DALOAD
08495: || code[k] == JvmOpCodes.FALOAD
08496: || code[k] == JvmOpCodes.LALOAD
08497: || code[k] == JvmOpCodes.IALOAD || code[k] == JvmOpCodes.SALOAD)) {
08498:
08499: int posFound = isInstAload(k, code, strb);
08500: while (posFound == -1) {
08501:
08502: k = k - 1;
08503: strb = new StringBuffer("");
08504: posFound = isInstAload(k, code, strb);
08505:
08506: }
08507: return posFound;
08508:
08509: }
08510: }
08511:
08512: }
08513:
08514: }
08515:
08516: return pos;
08517: }
08518:
08519: private int findWhereThisInvokeEnds(int s, byte[] code) {
08520: int temp = s;
08521: if (code[s] == JvmOpCodes.INVOKEINTERFACE) {
08522: temp = temp + 4;
08523: } else {
08524: temp += 2;
08525: }
08526: return temp;
08527:
08528: }
08529:
08530: private boolean checkForAssociatedGetField(ArrayList getField, int s,
08531: StringBuffer str, byte[] code) {
08532: boolean ret = false;
08533:
08534: HashMap map = ConsoleLauncher.getInstructionMap();
08535: if (getField == null || getField.size() == 0)
08536: return ret;
08537: else {
08538: for (int z = getField.size() - 1; z >= 0; z--) {
08539: Integer in = (Integer) getField.get(z);
08540: int Iin = in.intValue();
08541: if (s > Iin) // REQD getField
08542: {
08543: int temp1 = Iin;
08544: int temp2 = s;
08545: if (map != null) {
08546: Integer skip = (Integer) map.get(new Integer(temp1));
08547: if (skip != null) {
08548:
08549: int iskip = skip.intValue();
08550: int next = temp1 + iskip + 1;
08551: if (next < code.length)
08552: temp1 = next;
08553: }
08554:
08555: }
08556:
08557: for (int x = temp1; x < temp2; x++) {
08558: int inst = code[x];
08559: switch (inst) {
08560: case JvmOpCodes.INVOKEVIRTUAL:
08561: case JvmOpCodes.INVOKESTATIC:
08562: case JvmOpCodes.INVOKESPECIAL:
08563: case JvmOpCodes.INVOKEINTERFACE:
08564: return false;
08565:
08566: default:
08567: ret = true;
08568: }
08569: }
08570:
08571: if (ret) {
08572: str.append(Iin);
08573: return ret;
08574:
08575: }
08576: }
08577:
08578: }
08579:
08580: }
08581: return ret;
08582: }
08583:
08584: private boolean checkForAssociatedGetStatic(ArrayList getStatic, int s,
08585: StringBuffer str, byte[] code) {
08586:
08587: boolean ret = false;
08588: HashMap map = ConsoleLauncher.getInstructionMap();
08589: if (getStatic == null || getStatic.size() == 0)
08590: return ret;
08591: else {
08592: for (int z = 0; z < getStatic.size(); z++) {
08593: Integer in = (Integer) getStatic.get(z);
08594: int Iin = in.intValue();
08595: if (s > Iin) // REQD getStatic
08596: {
08597: int temp1 = Iin;
08598: int temp2 = s;
08599: if (map != null) {
08600: Integer skip = (Integer) map.get(new Integer(temp1));
08601: if (skip != null) {
08602:
08603: int iskip = skip.intValue();
08604: int next = temp1 + iskip + 1;
08605: if (next < code.length)
08606: temp1 = next;
08607: }
08608:
08609: }
08610:
08611: for (int x = temp1; x < temp2; x++) {
08612: if (isThisInstrStart(behaviour
08613: .getInstructionStartPositions(), x)) {
08614: int inst = code[x];
08615: switch (inst) {
08616: case JvmOpCodes.INVOKEVIRTUAL:
08617: case JvmOpCodes.INVOKESTATIC:
08618: case JvmOpCodes.INVOKESPECIAL:
08619: case JvmOpCodes.INVOKEINTERFACE:
08620: return false;
08621:
08622: default:
08623: ret = true;
08624: }
08625: }
08626: }
08627:
08628: if (ret) {
08629: str.append(Iin);
08630: return ret;
08631: }
08632: }
08633:
08634: }
08635:
08636: }
08637: return ret;
08638:
08639: }
08640:
08641: private boolean checkForAssociatedInvokeSpecial(Hashtable invokespecialpos,
08642: int s, StringBuffer str, byte[] code) {
08643:
08644: boolean ret = false;
08645: HashMap map = ConsoleLauncher.getInstructionMap();
08646: if (invokespecialpos != null && invokespecialpos.size() > 0) {
08647: Set set = invokespecialpos.keySet();
08648: Integer[] karr = (Integer[]) set.toArray(new Integer[set.size()]);
08649: Arrays.sort(karr);
08650: for (int z = 0; z < karr.length; z++) {
08651: Integer in = (Integer) karr[z];
08652: int Iin = in.intValue();
08653: if (s > Iin) // REQD invokespec
08654: {
08655: int temp1 = Iin;
08656: int temp2 = s;
08657: if (map != null) {
08658: Integer skip = (Integer) map.get(new Integer(temp1));
08659: if (skip != null) {
08660:
08661: int iskip = skip.intValue();
08662: int next = temp1 + iskip + 1;
08663: if (next < code.length)
08664: temp1 = next;
08665: }
08666:
08667: }
08668:
08669: for (int x = temp1; x < temp2; x++) {
08670: if (isThisInstrStart(behaviour
08671: .getInstructionStartPositions(), x)) {
08672: int inst = code[x];
08673: switch (inst) {
08674: case JvmOpCodes.INVOKEVIRTUAL:
08675: case JvmOpCodes.INVOKESTATIC:
08676: case JvmOpCodes.INVOKESPECIAL:
08677: case JvmOpCodes.INVOKEINTERFACE:
08678: return false;
08679:
08680: default:
08681: ret = true;
08682: }
08683: }
08684: }
08685:
08686: if (ret) {
08687: str.append(invokespecialpos.get(new Integer(Iin)));
08688: return ret;
08689: }
08690: }
08691:
08692: }
08693:
08694: }
08695: return false;
08696:
08697: }
08698:
08699: private int getObjectRefForGetField(int iS, byte[] code) {
08700: StringBuffer sb = new StringBuffer("");
08701: boolean ok = isPrevInstructionAload(iS, code, sb);
08702: if (ok) {
08703: int ref = Integer.parseInt(sb.toString());
08704: return ref;
08705: }
08706: // System.out.println("ERROR in getObjectRefForGetField "+iS);
08707: return iS;
08708:
08709: }
08710:
08711: private boolean isThisInstrStart(ArrayList list, int pos) {
08712: boolean ok = false;
08713: if (list == null)
08714: throw new NullPointerException("Starts pos is null in disassembler");
08715: if (list != null) {
08716: for (int k = 0; k < list.size(); k++) {
08717: Integer in = (Integer) list.get(k);
08718: if (in != null) {
08719: int i = in.intValue();
08720: if (i == pos)
08721: return !ok;
08722: }
08723: }
08724: }
08725: return ok;
08726:
08727: }
08728:
08729: // s --> Some if start
08730: // e--> goto start
08731:
08732: private IFBlock[] getInRangeIFS(int s, int e) {
08733: Collection ifs = getCurrentIFStructues();
08734: if (ifs == null || ifs.size() == 0)
08735: return null;
08736: ArrayList list = new ArrayList();
08737: int start = s + 2 + 1; // ifstart+skipbytes+1 --> start of next inst
08738: Iterator it = ifs.iterator();
08739: while (it.hasNext()) {
08740: IFBlock cur = (IFBlock) it.next();
08741: int ifstart = cur.getIfStart();
08742: if (ifstart >= start && ifstart < e) {
08743: list.add(cur);
08744: }
08745: }
08746:
08747: if (list.size() > 0)
08748: return (IFBlock[]) list.toArray(new IFBlock[list.size()]);
08749: else
08750: return null;
08751: }
08752:
08753: private java.lang.String anyWhileBodyHere(int e, Loop iloop,
08754: OperandStack opStack) {
08755: java.lang.String str = "";
08756: boolean sp = checkToEvaluateAnyLoopBody(e, behaviour.getCode());
08757: if (!sp)
08758: return str;
08759: byte[] code = behaviour.getCode();
08760: Operand ops[] = new Operand[2];
08761: java.lang.String val = "";
08762: if (isThisInstrStart(behaviour.getInstructionStartPositions(), e)) {
08763: switch (code[e]) {
08764:
08765: case JvmOpCodes.IF_ACMPEQ:
08766: ops = getIFArgs(opStack, 2);
08767: if (ops != null) {
08768: str = "\nif(" + ops[1].getOperandValue() + "=="
08769: + ops[0].getOperandValue()
08770: + "))\n{\n}\nelse\n{\nbreak\n}\n;";
08771: } else {
08772: str = "";
08773: }
08774: break;
08775: case JvmOpCodes.IF_ACMPNE:
08776: ops = getIFArgs(opStack, 2);
08777: if (ops != null) {
08778: str = "\nif(!" + ops[1].getOperandValue() + "=="
08779: + ops[0].getOperandValue()
08780: + "))\n{\n}\nelse\n{\nbreak\n}\n;";
08781: } else {
08782: str = "";
08783: }
08784: break;
08785: case JvmOpCodes.IF_ICMPEQ:
08786:
08787: ops = getIFArgs(opStack, 2);
08788: if (ops != null) {
08789: str = "\nif(" + ops[1].getOperandValue() + " == "
08790: + ops[0].getOperandValue()
08791: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08792: } else {
08793: str = "";
08794: }
08795: break;
08796: case JvmOpCodes.IF_ICMPGE:
08797: ops = getIFArgs(opStack, 2);
08798: if (ops != null) {
08799: str = "\nif(" + ops[1].getOperandValue() + " >= "
08800: + ops[0].getOperandValue()
08801: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08802: } else {
08803: str = "";
08804: }
08805: break;
08806:
08807: case JvmOpCodes.IF_ICMPGT:
08808: ops = getIFArgs(opStack, 2);
08809: if (ops != null) {
08810: str = "\nif(" + ops[1].getOperandValue() + " > "
08811: + ops[0].getOperandValue()
08812: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08813: } else {
08814: str = "";
08815: }
08816: break;
08817:
08818: case JvmOpCodes.IF_ICMPLE:
08819: ops = getIFArgs(opStack, 2);
08820: if (ops != null) {
08821: str = "\nif(" + ops[1].getOperandValue() + " <= "
08822: + ops[0].getOperandValue()
08823: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08824: } else {
08825: str = "";
08826: }
08827: break;
08828:
08829: case JvmOpCodes.IF_ICMPLT:
08830: ops = getIFArgs(opStack, 2);
08831: if (ops != null) {
08832: str = "\nif(" + ops[1].getOperandValue() + "<"
08833: + ops[0].getOperandValue()
08834: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08835: } else {
08836: str = "";
08837: }
08838: break;
08839:
08840: case JvmOpCodes.IF_ICMPNE:
08841: ops = getIFArgs(opStack, 2);
08842: if (ops != null) {
08843: str = "\nif(" + ops[1].getOperandValue() + "!= "
08844: + ops[0].getOperandValue()
08845: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08846: } else {
08847: str = "";
08848: }
08849: break;
08850:
08851: case JvmOpCodes.IFEQ:
08852: ops = getIFArgs(opStack, 1);
08853: val = getReturnTypeIfPreviousInvoke(currentForIndex, code);
08854: java.lang.String t3 = ops[0].getClassType();
08855: java.lang.String t4 = ops[0].getLocalVarType();
08856: if ((t3 != null && t3.trim().equals("boolean"))
08857: || (t4 != null && t4.trim().equals("boolean"))) {
08858: if (val != null && val.trim().equals("1")) {
08859: val = "true";
08860: }
08861: if (val != null && val.trim().equals("0")) {
08862: val = "false";
08863: }
08864: }
08865: if (ops != null) {
08866: if ((code[currentForIndex - 1] != JvmOpCodes.DCMPG)
08867: && (code[currentForIndex - 1] != JvmOpCodes.DCMPL)
08868: && code[currentForIndex - 1] != JvmOpCodes.FCMPG
08869: && code[currentForIndex - 1] != JvmOpCodes.FCMPL
08870: && code[currentForIndex - 1] != JvmOpCodes.LCMP)
08871: str = "\nif(" + ops[0].getOperandValue() + "==" + val
08872: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08873: else
08874: str = "\nif(" + ops[0].getOperandValue()
08875: + ")\n{\nbreak;\n}\n" + "else\n" + "{\n"
08876: + "}\n";
08877: } else {
08878: str = "";
08879: }
08880: break;
08881: case JvmOpCodes.IFGE:
08882: ops = getIFArgs(opStack, 1);
08883: if (ops != null) {
08884: if ((code[currentForIndex - 1] != JvmOpCodes.DCMPG)
08885: && (code[currentForIndex - 1] != JvmOpCodes.DCMPL)
08886: && code[currentForIndex - 1] != JvmOpCodes.FCMPG
08887: && code[currentForIndex - 1] != JvmOpCodes.FCMPL
08888: && code[currentForIndex - 1] != JvmOpCodes.LCMP)
08889: str = "\nif(" + ops[0].getOperandValue()
08890: + ">=0)\n{\n}\nelse\n{\nbreak;\n}\n";
08891: else
08892: str = "\nif(" + ops[0].getOperandValue()
08893: + ")\n{\nbreak;\n}\n" + "else\n" + "{\n"
08894: + "}\n";
08895: } else {
08896: str = "";
08897: }
08898: break;
08899:
08900: case JvmOpCodes.IFGT:
08901: ops = getIFArgs(opStack, 1);
08902: if (ops != null) {
08903: if ((code[currentForIndex - 1] != JvmOpCodes.DCMPG)
08904: && (code[currentForIndex - 1] != JvmOpCodes.DCMPL)
08905: && code[currentForIndex - 1] != JvmOpCodes.FCMPG
08906: && code[currentForIndex - 1] != JvmOpCodes.FCMPL
08907: && code[currentForIndex - 1] != JvmOpCodes.LCMP)
08908: str = "\nif(" + ops[0].getOperandValue()
08909: + ">0)\n{\n}\nelse\n{\nbreak;\n}\n";
08910: else
08911: str = "\nif(" + ops[0].getOperandValue()
08912: + ")\n{\nbreak;\n}\n" + "else\n" + "{\n"
08913: + "}\n";
08914: } else {
08915: str = "";
08916: }
08917: break;
08918: case JvmOpCodes.IFLE:
08919: ops = getIFArgs(opStack, 1);
08920: if (ops != null) {
08921: if ((code[currentForIndex - 1] != JvmOpCodes.DCMPG)
08922: && (code[currentForIndex - 1] != JvmOpCodes.DCMPL)
08923: && code[currentForIndex - 1] != JvmOpCodes.FCMPG
08924: && code[currentForIndex - 1] != JvmOpCodes.FCMPL
08925: && code[currentForIndex - 1] != JvmOpCodes.LCMP)
08926: str = "\nif(" + ops[0].getOperandValue()
08927: + "<=0)\n{\n}\nelse\n{\nbreak;\n}\n";
08928: else
08929: str = "\nif(" + ops[0].getOperandValue()
08930: + ")\n{\nbreak;\n}\n" + "else\n" + "{\n"
08931: + "}\n";
08932: } else {
08933: str = "";
08934: }
08935: break;
08936: case JvmOpCodes.IFLT:
08937: ops = getIFArgs(opStack, 1);
08938: if (ops != null) {
08939: if ((code[currentForIndex - 1] != JvmOpCodes.DCMPG)
08940: && (code[currentForIndex - 1] != JvmOpCodes.DCMPL)
08941: && code[currentForIndex - 1] != JvmOpCodes.FCMPG
08942: && code[currentForIndex - 1] != JvmOpCodes.FCMPL
08943: && code[currentForIndex - 1] != JvmOpCodes.LCMP)
08944: str = "\nif(" + ops[0].getOperandValue()
08945: + "<0)\n{\n}\nelse\n{\nbreak;\n}\n";
08946: else
08947: str = "\nif(" + ops[0].getOperandValue()
08948: + ")\n{\nbreak;\n}\n" + "else\n" + "{\n"
08949: + "}\n";
08950: } else {
08951: str = "";
08952: }
08953: break;
08954: case JvmOpCodes.IFNE:
08955: ops = getIFArgs(opStack, 1);
08956: val = getReturnTypeIfPreviousInvoke(currentForIndex, code);
08957: t3 = ops[0].getClassType();
08958: t4 = ops[0].getLocalVarType();
08959: if ((t3 != null && t3.trim().equals("boolean"))
08960: || (t4 != null && t4.trim().equals("boolean"))) {
08961: if (val != null && val.trim().equals("1")) {
08962: val = "true";
08963: }
08964: if (val != null && val.trim().equals("0")) {
08965: val = "false";
08966: }
08967: }
08968: if (ops != null) {
08969: if ((code[currentForIndex - 1] != JvmOpCodes.DCMPG)
08970: && (code[currentForIndex - 1] != JvmOpCodes.DCMPL)
08971: && code[currentForIndex - 1] != JvmOpCodes.FCMPG
08972: && code[currentForIndex - 1] != JvmOpCodes.FCMPL
08973: && code[currentForIndex - 1] != JvmOpCodes.LCMP)
08974: str = "\nif(" + ops[0].getOperandValue() + "!=" + val
08975: + ")\n{\n}\nelse\n{\nbreak;\n}\n";
08976: else
08977: str = "\nif(" + ops[0].getOperandValue()
08978: + ")\n{\nbreak;\n}\n" + "else\n" + "{\n"
08979: + "}\n";
08980: } else {
08981: str = "";
08982: }
08983: break;
08984: case JvmOpCodes.IFNONNULL:
08985:
08986: ops = getIFArgs(opStack, 1);
08987: if (ops != null) {
08988: str = "\nif(" + ops[0].getOperandValue()
08989: + "!= null)\n{\n}\nelse\n{break;\n}\n";
08990: } else {
08991: str = "";
08992: }
08993: break;
08994: case JvmOpCodes.IFNULL:
08995: ops = getIFArgs(opStack, 1);
08996: if (ops != null) {
08997: str = "\nif(" + ops[0].getOperandValue()
08998: + "== null)\n{\n}\nelse\n{break;\n}\n";
08999: } else {
09000: str = "";
09001: }
09002: break;
09003: default:
09004: str = "";
09005: break;
09006:
09007: }
09008: }
09009: return str;
09010:
09011: }
09012:
09013: private Operand[] getIFArgs(OperandStack opStack, int number) {
09014: Operand ops[] = new Operand[number];
09015: if (opStack.size() >= number) {
09016:
09017: for (int z = 0; z < number; z++) // ops[0] --> Original TOS
09018: {
09019: ops[z] = opStack.getTopOfStack();
09020:
09021: }
09022:
09023: return ops;
09024: }
09025:
09026: return null;
09027: }
09028:
09029: private java.lang.String getIfElseReturnAtI(int i) {
09030: if (GlobalVariableStore.getRetAtIfElseEnd() == null
09031: || GlobalVariableStore.getRetAtIfElseEnd().size() == 0) {
09032: return null;
09033: } else {
09034: boolean ret = addReturnAtIFElseEnd(i);
09035: if (ret) {
09036: returnsaddedAtIfElse.add(new Integer(i));
09037: return (java.lang.String) ((GlobalVariableStore
09038: .getRetAtIfElseEnd()).get(new Integer(i)));
09039: } else
09040: return null;
09041: }
09042: }
09043:
09044: public static java.lang.String getClassName(java.lang.String path) {
09045: java.lang.String slash = "";
09046: if (path.indexOf("\\") != -1) {
09047: slash = "\\";
09048: } else {
09049: slash = "/";
09050: }
09051: int lastSlash = path.lastIndexOf(slash);
09052: return path.substring(lastSlash + 1);
09053:
09054: }
09055:
09056: private boolean isInstAnyBasicPrimitiveOperation(byte code[], int pos,
09057: StringBuffer sb) {
09058: boolean b = false;
09059: switch (code[pos]) {
09060:
09061: case JvmOpCodes.DADD:
09062: sb.append(2);
09063: b = true;
09064: break;
09065: case JvmOpCodes.DDIV:
09066: b = true;
09067: sb.append(2);
09068: break;
09069: case JvmOpCodes.DMUL:
09070: b = true;
09071: sb.append(2);
09072: break;
09073: case JvmOpCodes.DNEG:
09074: b = true;
09075: sb.append(1);
09076: break;
09077: case JvmOpCodes.DREM:
09078: b = true;
09079: sb.append(2);
09080: break;
09081: case JvmOpCodes.DSUB:
09082: b = true;
09083: sb.append(2);
09084: break;
09085:
09086: case JvmOpCodes.FADD:
09087: b = true;
09088: sb.append(2);
09089: break;
09090: case JvmOpCodes.FDIV:
09091: b = true;
09092: sb.append(2);
09093: break;
09094: case JvmOpCodes.FMUL:
09095: b = true;
09096: sb.append(2);
09097: break;
09098: case JvmOpCodes.FNEG:
09099: b = true;
09100: sb.append(1);
09101: break;
09102: case JvmOpCodes.FREM:
09103: b = true;
09104: sb.append(2);
09105: break;
09106: case JvmOpCodes.IADD:
09107: b = true;
09108: sb.append(2);
09109: break;
09110: case JvmOpCodes.IAND:
09111: b = true;
09112: break;
09113: case JvmOpCodes.IDIV:
09114: b = true;
09115: sb.append(2);
09116: break;
09117: case JvmOpCodes.IMUL:
09118: b = true;
09119: sb.append(2);
09120: break;
09121: case JvmOpCodes.INEG:
09122: b = true;
09123: sb.append(1);
09124: break;
09125: case JvmOpCodes.IOR:
09126: b = true;
09127: sb.append(2);
09128: break;
09129: case JvmOpCodes.IREM:
09130: b = true;
09131: sb.append(2);
09132: break;
09133: case JvmOpCodes.ISHL:
09134: b = true;
09135: sb.append(2);
09136: break;
09137: case JvmOpCodes.ISHR:
09138: b = true;
09139: sb.append(2);
09140: break;
09141: case JvmOpCodes.ISUB:
09142: b = true;
09143: sb.append(2);
09144: break;
09145: case JvmOpCodes.IUSHR:
09146: b = true;
09147: sb.append(2);
09148: break;
09149: case JvmOpCodes.IXOR:
09150: b = true;
09151: sb.append(2);
09152: break;
09153: case JvmOpCodes.LADD:
09154: b = true;
09155: sb.append(2);
09156: break;
09157:
09158: case JvmOpCodes.LAND:
09159: b = true;
09160: sb.append(2);
09161: break;
09162: case JvmOpCodes.LDIV:
09163: b = true;
09164: sb.append(2);
09165: break;
09166: case JvmOpCodes.LMUL:
09167: b = true;
09168: sb.append(2);
09169: break;
09170: case JvmOpCodes.LNEG:
09171: b = true;
09172: sb.append(1);
09173: break;
09174: case JvmOpCodes.LOR:
09175: b = true;
09176: sb.append(2);
09177: break;
09178: case JvmOpCodes.LREM:
09179: b = true;
09180: sb.append(2);
09181: break;
09182: case JvmOpCodes.LSHL:
09183: b = true;
09184: sb.append(2);
09185: break;
09186: case JvmOpCodes.LSHR:
09187: b = true;
09188: sb.append(2);
09189: break;
09190: case JvmOpCodes.LSUB:
09191: b = true;
09192: sb.append(2);
09193: break;
09194: case JvmOpCodes.LUSHR:
09195: b = true;
09196: sb.append(2);
09197: break;
09198: case JvmOpCodes.LXOR:
09199: b = true;
09200: sb.append(2);
09201: break;
09202:
09203: }
09204:
09205: return b;
09206: }
09207:
09208: private void handleBasicPrimitiveLoadOp(byte[] code, int k)
09209: throws Exception {
09210: if (k < 0)
09211: throw new Exception(
09212: "Invalid argument sent to handleBasicPrimitiveLoadOp");
09213: ArrayList list = behaviour.getInstructionStartPositions();
09214: boolean b = isThisInstrStart(list, k);
09215: while (!b) {
09216: k = k - 1;
09217: b = isThisInstrStart(list, k);
09218: }
09219: switch (code[k]) {
09220: /***********************************************************************
09221: * First List all recursive calls
09222: */
09223: case JvmOpCodes.DADD:
09224: InstParam newentry = new InstParam();
09225: newentry.setNumberOfParamsLeft(2);
09226: newentry.setCurrentParamOffsetInCode(-1);
09227: stackHandler.push(newentry);
09228: handleBasicPrimitiveLoadOp(code, (k - 1));
09229: InstParam tos = (InstParam) stackHandler.pop();
09230: int mybegin = tos.getCurrentParamOffsetInCode();
09231: tos = (InstParam) stackHandler.pop();
09232: int rem = tos.getNumberOfParamsLeft();
09233: rem = rem - 1;
09234: tos.setNumberOfParamsLeft(rem);
09235: tos.setCurrentParamOffsetInCode(mybegin);
09236: stackHandler.push(tos);
09237: if (rem == 0) {
09238: return;
09239: } else {
09240: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09241: return;
09242: }
09243:
09244: case JvmOpCodes.DDIV:
09245: newentry = new InstParam();
09246: newentry.setNumberOfParamsLeft(2);
09247: newentry.setCurrentParamOffsetInCode(-1);
09248: stackHandler.push(newentry);
09249: handleBasicPrimitiveLoadOp(code, (k - 1));
09250: tos = (InstParam) stackHandler.pop();
09251: mybegin = tos.getCurrentParamOffsetInCode();
09252: tos = (InstParam) stackHandler.pop();
09253: rem = tos.getNumberOfParamsLeft();
09254: rem = rem - 1;
09255: tos.setNumberOfParamsLeft(rem);
09256: tos.setCurrentParamOffsetInCode(mybegin);
09257: stackHandler.push(tos);
09258: if (rem == 0) {
09259: return;
09260: } else {
09261: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09262: return;
09263: }
09264:
09265: case JvmOpCodes.DMUL:
09266: newentry = new InstParam();
09267: newentry.setNumberOfParamsLeft(2);
09268: newentry.setCurrentParamOffsetInCode(-1);
09269: stackHandler.push(newentry);
09270: handleBasicPrimitiveLoadOp(code, (k - 1));
09271: tos = (InstParam) stackHandler.pop();
09272: mybegin = tos.getCurrentParamOffsetInCode();
09273: tos = (InstParam) stackHandler.pop();
09274: rem = tos.getNumberOfParamsLeft();
09275: rem = rem - 1;
09276: tos.setNumberOfParamsLeft(rem);
09277: tos.setCurrentParamOffsetInCode(mybegin);
09278: stackHandler.push(tos);
09279: if (rem == 0) {
09280: return;
09281: } else {
09282: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09283: return;
09284: }
09285:
09286: case JvmOpCodes.DNEG:
09287: newentry = new InstParam();
09288: newentry.setNumberOfParamsLeft(1);
09289: newentry.setCurrentParamOffsetInCode(-1);
09290: stackHandler.push(newentry);
09291: handleBasicPrimitiveLoadOp(code, (k - 1));
09292: tos = (InstParam) stackHandler.pop();
09293: mybegin = tos.getCurrentParamOffsetInCode();
09294: tos = (InstParam) stackHandler.pop();
09295: rem = tos.getNumberOfParamsLeft();
09296: rem = rem - 1;
09297: tos.setNumberOfParamsLeft(rem);
09298: tos.setCurrentParamOffsetInCode(mybegin);
09299: stackHandler.push(tos);
09300: if (rem == 0) {
09301: return;
09302: } else {
09303: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09304: return;
09305: }
09306:
09307: case JvmOpCodes.DREM:
09308: newentry = new InstParam();
09309: newentry.setNumberOfParamsLeft(2);
09310: newentry.setCurrentParamOffsetInCode(-1);
09311: stackHandler.push(newentry);
09312: handleBasicPrimitiveLoadOp(code, (k - 1));
09313: tos = (InstParam) stackHandler.pop();
09314: mybegin = tos.getCurrentParamOffsetInCode();
09315: tos = (InstParam) stackHandler.pop();
09316: rem = tos.getNumberOfParamsLeft();
09317: rem = rem - 1;
09318: tos.setNumberOfParamsLeft(rem);
09319: tos.setCurrentParamOffsetInCode(mybegin);
09320: stackHandler.push(tos);
09321: if (rem == 0) {
09322: return;
09323: } else {
09324: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09325: return;
09326: }
09327:
09328: case JvmOpCodes.DSUB:
09329: newentry = new InstParam();
09330: newentry.setNumberOfParamsLeft(2);
09331: newentry.setCurrentParamOffsetInCode(-1);
09332: stackHandler.push(newentry);
09333: handleBasicPrimitiveLoadOp(code, (k - 1));
09334: tos = (InstParam) stackHandler.pop();
09335: mybegin = tos.getCurrentParamOffsetInCode();
09336: tos = (InstParam) stackHandler.pop();
09337: rem = tos.getNumberOfParamsLeft();
09338: rem = rem - 1;
09339: tos.setNumberOfParamsLeft(rem);
09340: tos.setCurrentParamOffsetInCode(mybegin);
09341: stackHandler.push(tos);
09342: if (rem == 0) {
09343: return;
09344: } else {
09345: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09346: return;
09347: }
09348:
09349: case JvmOpCodes.FADD:
09350: newentry = new InstParam();
09351: newentry.setNumberOfParamsLeft(2);
09352: newentry.setCurrentParamOffsetInCode(-1);
09353: stackHandler.push(newentry);
09354: handleBasicPrimitiveLoadOp(code, (k - 1));
09355: tos = (InstParam) stackHandler.pop();
09356: mybegin = tos.getCurrentParamOffsetInCode();
09357: tos = (InstParam) stackHandler.pop();
09358: rem = tos.getNumberOfParamsLeft();
09359: rem = rem - 1;
09360: tos.setNumberOfParamsLeft(rem);
09361: tos.setCurrentParamOffsetInCode(mybegin);
09362: stackHandler.push(tos);
09363: if (rem == 0) {
09364: return;
09365: } else {
09366: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09367: return;
09368: }
09369:
09370: case JvmOpCodes.FDIV:
09371: newentry = new InstParam();
09372: newentry.setNumberOfParamsLeft(2);
09373: newentry.setCurrentParamOffsetInCode(-1);
09374: stackHandler.push(newentry);
09375: handleBasicPrimitiveLoadOp(code, (k - 1));
09376: tos = (InstParam) stackHandler.pop();
09377: mybegin = tos.getCurrentParamOffsetInCode();
09378: tos = (InstParam) stackHandler.pop();
09379: rem = tos.getNumberOfParamsLeft();
09380: rem = rem - 1;
09381: tos.setNumberOfParamsLeft(rem);
09382: tos.setCurrentParamOffsetInCode(mybegin);
09383: stackHandler.push(tos);
09384: if (rem == 0) {
09385: return;
09386: } else {
09387: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09388: return;
09389: }
09390:
09391: case JvmOpCodes.FMUL:
09392: newentry = new InstParam();
09393: newentry.setNumberOfParamsLeft(2);
09394: newentry.setCurrentParamOffsetInCode(-1);
09395: stackHandler.push(newentry);
09396: handleBasicPrimitiveLoadOp(code, (k - 1));
09397: tos = (InstParam) stackHandler.pop();
09398: mybegin = tos.getCurrentParamOffsetInCode();
09399: tos = (InstParam) stackHandler.pop();
09400: rem = tos.getNumberOfParamsLeft();
09401: rem = rem - 1;
09402: tos.setNumberOfParamsLeft(rem);
09403: tos.setCurrentParamOffsetInCode(mybegin);
09404: stackHandler.push(tos);
09405: if (rem == 0) {
09406: return;
09407: } else {
09408: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09409: return;
09410: }
09411:
09412: case JvmOpCodes.FNEG:
09413: newentry = new InstParam();
09414: newentry.setNumberOfParamsLeft(1);
09415: newentry.setCurrentParamOffsetInCode(-1);
09416: stackHandler.push(newentry);
09417: handleBasicPrimitiveLoadOp(code, (k - 1));
09418: tos = (InstParam) stackHandler.pop();
09419: mybegin = tos.getCurrentParamOffsetInCode();
09420: tos = (InstParam) stackHandler.pop();
09421: rem = tos.getNumberOfParamsLeft();
09422: rem = rem - 1;
09423: tos.setNumberOfParamsLeft(rem);
09424: tos.setCurrentParamOffsetInCode(mybegin);
09425: stackHandler.push(tos);
09426: if (rem == 0) {
09427: return;
09428: } else {
09429: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09430: return;
09431: }
09432:
09433: case JvmOpCodes.FREM:
09434: newentry = new InstParam();
09435: newentry.setNumberOfParamsLeft(2);
09436: newentry.setCurrentParamOffsetInCode(-1);
09437: stackHandler.push(newentry);
09438: handleBasicPrimitiveLoadOp(code, (k - 1));
09439: tos = (InstParam) stackHandler.pop();
09440: mybegin = tos.getCurrentParamOffsetInCode();
09441: tos = (InstParam) stackHandler.pop();
09442: rem = tos.getNumberOfParamsLeft();
09443: rem = rem - 1;
09444: tos.setNumberOfParamsLeft(rem);
09445: tos.setCurrentParamOffsetInCode(mybegin);
09446: stackHandler.push(tos);
09447: if (rem == 0) {
09448: return;
09449: } else {
09450: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09451: return;
09452: }
09453:
09454: case JvmOpCodes.IADD:
09455: newentry = new InstParam();
09456: newentry.setNumberOfParamsLeft(2);
09457: newentry.setCurrentParamOffsetInCode(-1);
09458: stackHandler.push(newentry);
09459: handleBasicPrimitiveLoadOp(code, (k - 1));
09460: tos = (InstParam) stackHandler.pop();
09461: mybegin = tos.getCurrentParamOffsetInCode();
09462: tos = (InstParam) stackHandler.pop();
09463: rem = tos.getNumberOfParamsLeft();
09464: rem = rem - 1;
09465: tos.setNumberOfParamsLeft(rem);
09466: tos.setCurrentParamOffsetInCode(mybegin);
09467: stackHandler.push(tos);
09468: if (rem == 0) {
09469: return;
09470: } else {
09471: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09472: return;
09473: }
09474:
09475: case JvmOpCodes.IAND:
09476: newentry = new InstParam();
09477: newentry.setNumberOfParamsLeft(2);
09478: newentry.setCurrentParamOffsetInCode(-1);
09479: stackHandler.push(newentry);
09480: handleBasicPrimitiveLoadOp(code, (k - 1));
09481: tos = (InstParam) stackHandler.pop();
09482: mybegin = tos.getCurrentParamOffsetInCode();
09483: tos = (InstParam) stackHandler.pop();
09484: rem = tos.getNumberOfParamsLeft();
09485: rem = rem - 1;
09486: tos.setNumberOfParamsLeft(rem);
09487: tos.setCurrentParamOffsetInCode(mybegin);
09488: stackHandler.push(tos);
09489: if (rem == 0) {
09490: return;
09491: } else {
09492: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09493: return;
09494: }
09495:
09496: case JvmOpCodes.IDIV:
09497: newentry = new InstParam();
09498: newentry.setNumberOfParamsLeft(2);
09499: newentry.setCurrentParamOffsetInCode(-1);
09500: stackHandler.push(newentry);
09501: handleBasicPrimitiveLoadOp(code, (k - 1));
09502: tos = (InstParam) stackHandler.pop();
09503: mybegin = tos.getCurrentParamOffsetInCode();
09504: tos = (InstParam) stackHandler.pop();
09505: rem = tos.getNumberOfParamsLeft();
09506: rem = rem - 1;
09507: tos.setNumberOfParamsLeft(rem);
09508: tos.setCurrentParamOffsetInCode(mybegin);
09509: stackHandler.push(tos);
09510: if (rem == 0) {
09511: return;
09512: } else {
09513: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09514: return;
09515: }
09516:
09517: case JvmOpCodes.IMUL:
09518: newentry = new InstParam();
09519: newentry.setNumberOfParamsLeft(2);
09520: newentry.setCurrentParamOffsetInCode(-1);
09521: stackHandler.push(newentry);
09522: handleBasicPrimitiveLoadOp(code, (k - 1));
09523: tos = (InstParam) stackHandler.pop();
09524: mybegin = tos.getCurrentParamOffsetInCode();
09525: tos = (InstParam) stackHandler.pop();
09526: rem = tos.getNumberOfParamsLeft();
09527: rem = rem - 1;
09528: tos.setNumberOfParamsLeft(rem);
09529: tos.setCurrentParamOffsetInCode(mybegin);
09530: stackHandler.push(tos);
09531: if (rem == 0) {
09532: return;
09533: } else {
09534: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09535: return;
09536:
09537: }
09538:
09539: case JvmOpCodes.INEG:
09540: newentry = new InstParam();
09541: newentry.setNumberOfParamsLeft(1);
09542: newentry.setCurrentParamOffsetInCode(-1);
09543: stackHandler.push(newentry);
09544: handleBasicPrimitiveLoadOp(code, (k - 1));
09545: tos = (InstParam) stackHandler.pop();
09546: mybegin = tos.getCurrentParamOffsetInCode();
09547: tos = (InstParam) stackHandler.pop();
09548: rem = tos.getNumberOfParamsLeft();
09549: rem = rem - 1;
09550: tos.setNumberOfParamsLeft(rem);
09551: tos.setCurrentParamOffsetInCode(mybegin);
09552: stackHandler.push(tos);
09553: if (rem == 0) {
09554: return;
09555: } else {
09556: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09557: return;
09558: }
09559:
09560: case JvmOpCodes.IOR:
09561: newentry = new InstParam();
09562: newentry.setNumberOfParamsLeft(2);
09563: newentry.setCurrentParamOffsetInCode(-1);
09564: stackHandler.push(newentry);
09565: handleBasicPrimitiveLoadOp(code, (k - 1));
09566: tos = (InstParam) stackHandler.pop();
09567: mybegin = tos.getCurrentParamOffsetInCode();
09568: tos = (InstParam) stackHandler.pop();
09569: rem = tos.getNumberOfParamsLeft();
09570: rem = rem - 1;
09571: tos.setNumberOfParamsLeft(rem);
09572: tos.setCurrentParamOffsetInCode(mybegin);
09573: stackHandler.push(tos);
09574: if (rem == 0) {
09575: return;
09576: } else {
09577: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09578: return;
09579: }
09580:
09581: case JvmOpCodes.IREM:
09582: newentry = new InstParam();
09583: newentry.setNumberOfParamsLeft(2);
09584: newentry.setCurrentParamOffsetInCode(-1);
09585: stackHandler.push(newentry);
09586: handleBasicPrimitiveLoadOp(code, (k - 1));
09587: tos = (InstParam) stackHandler.pop();
09588: mybegin = tos.getCurrentParamOffsetInCode();
09589: tos = (InstParam) stackHandler.pop();
09590: rem = tos.getNumberOfParamsLeft();
09591: rem = rem - 1;
09592: tos.setNumberOfParamsLeft(rem);
09593: tos.setCurrentParamOffsetInCode(mybegin);
09594: stackHandler.push(tos);
09595: if (rem == 0) {
09596: return;
09597: } else {
09598: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09599: return;
09600: }
09601:
09602: case JvmOpCodes.ISHL:
09603: newentry = new InstParam();
09604: newentry.setNumberOfParamsLeft(2);
09605: newentry.setCurrentParamOffsetInCode(-1);
09606: stackHandler.push(newentry);
09607: handleBasicPrimitiveLoadOp(code, (k - 1));
09608: tos = (InstParam) stackHandler.pop();
09609: mybegin = tos.getCurrentParamOffsetInCode();
09610: tos = (InstParam) stackHandler.pop();
09611: rem = tos.getNumberOfParamsLeft();
09612: rem = rem - 1;
09613: tos.setNumberOfParamsLeft(rem);
09614: tos.setCurrentParamOffsetInCode(mybegin);
09615: stackHandler.push(tos);
09616: if (rem == 0) {
09617: return;
09618: } else {
09619: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09620: return;
09621: }
09622:
09623: case JvmOpCodes.ISHR:
09624: newentry = new InstParam();
09625: newentry.setNumberOfParamsLeft(2);
09626: newentry.setCurrentParamOffsetInCode(-1);
09627: stackHandler.push(newentry);
09628: handleBasicPrimitiveLoadOp(code, (k - 1));
09629: tos = (InstParam) stackHandler.pop();
09630: mybegin = tos.getCurrentParamOffsetInCode();
09631: tos = (InstParam) stackHandler.pop();
09632: rem = tos.getNumberOfParamsLeft();
09633: rem = rem - 1;
09634: tos.setNumberOfParamsLeft(rem);
09635: tos.setCurrentParamOffsetInCode(mybegin);
09636: stackHandler.push(tos);
09637: if (rem == 0) {
09638: return;
09639: } else {
09640: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09641: return;
09642: }
09643:
09644: case JvmOpCodes.ISUB:
09645: newentry = new InstParam();
09646: newentry.setNumberOfParamsLeft(2);
09647: newentry.setCurrentParamOffsetInCode(-1);
09648: stackHandler.push(newentry);
09649: handleBasicPrimitiveLoadOp(code, (k - 1));
09650: tos = (InstParam) stackHandler.pop();
09651: mybegin = tos.getCurrentParamOffsetInCode();
09652: tos = (InstParam) stackHandler.pop();
09653: rem = tos.getNumberOfParamsLeft();
09654: rem = rem - 1;
09655: tos.setNumberOfParamsLeft(rem);
09656: tos.setCurrentParamOffsetInCode(mybegin);
09657: stackHandler.push(tos);
09658: if (rem == 0) {
09659: return;
09660: } else {
09661: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09662: return;
09663: }
09664:
09665: case JvmOpCodes.IUSHR:
09666: newentry = new InstParam();
09667: newentry.setNumberOfParamsLeft(2);
09668: newentry.setCurrentParamOffsetInCode(-1);
09669: stackHandler.push(newentry);
09670: handleBasicPrimitiveLoadOp(code, (k - 1));
09671: tos = (InstParam) stackHandler.pop();
09672: mybegin = tos.getCurrentParamOffsetInCode();
09673: tos = (InstParam) stackHandler.pop();
09674: rem = tos.getNumberOfParamsLeft();
09675: rem = rem - 1;
09676: tos.setNumberOfParamsLeft(rem);
09677: tos.setCurrentParamOffsetInCode(mybegin);
09678: stackHandler.push(tos);
09679: if (rem == 0) {
09680: return;
09681: } else {
09682: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09683: return;
09684: }
09685:
09686: case JvmOpCodes.IXOR:
09687: newentry = new InstParam();
09688: newentry.setNumberOfParamsLeft(2);
09689: newentry.setCurrentParamOffsetInCode(-1);
09690: stackHandler.push(newentry);
09691: handleBasicPrimitiveLoadOp(code, (k - 1));
09692: tos = (InstParam) stackHandler.pop();
09693: mybegin = tos.getCurrentParamOffsetInCode();
09694: tos = (InstParam) stackHandler.pop();
09695: rem = tos.getNumberOfParamsLeft();
09696: rem = rem - 1;
09697: tos.setNumberOfParamsLeft(rem);
09698: tos.setCurrentParamOffsetInCode(mybegin);
09699: stackHandler.push(tos);
09700: if (rem == 0) {
09701: return;
09702: } else {
09703: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09704: return;
09705: }
09706:
09707: case JvmOpCodes.LADD:
09708: newentry = new InstParam();
09709: newentry.setNumberOfParamsLeft(2);
09710: newentry.setCurrentParamOffsetInCode(-1);
09711: stackHandler.push(newentry);
09712: handleBasicPrimitiveLoadOp(code, (k - 1));
09713: tos = (InstParam) stackHandler.pop();
09714: mybegin = tos.getCurrentParamOffsetInCode();
09715: tos = (InstParam) stackHandler.pop();
09716: rem = tos.getNumberOfParamsLeft();
09717: rem = rem - 1;
09718: tos.setNumberOfParamsLeft(rem);
09719: tos.setCurrentParamOffsetInCode(mybegin);
09720: stackHandler.push(tos);
09721: if (rem == 0) {
09722: return;
09723: } else {
09724: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09725: return;
09726: }
09727:
09728: case JvmOpCodes.LAND:
09729: newentry = new InstParam();
09730: newentry.setNumberOfParamsLeft(2);
09731: newentry.setCurrentParamOffsetInCode(-1);
09732: stackHandler.push(newentry);
09733: handleBasicPrimitiveLoadOp(code, (k - 1));
09734: tos = (InstParam) stackHandler.pop();
09735: mybegin = tos.getCurrentParamOffsetInCode();
09736: tos = (InstParam) stackHandler.pop();
09737: rem = tos.getNumberOfParamsLeft();
09738: rem = rem - 1;
09739: tos.setNumberOfParamsLeft(rem);
09740: tos.setCurrentParamOffsetInCode(mybegin);
09741: stackHandler.push(tos);
09742: if (rem == 0) {
09743: return;
09744: } else {
09745: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09746: return;
09747: }
09748:
09749: case JvmOpCodes.LDIV:
09750: newentry = new InstParam();
09751: newentry.setNumberOfParamsLeft(2);
09752: newentry.setCurrentParamOffsetInCode(-1);
09753: stackHandler.push(newentry);
09754: handleBasicPrimitiveLoadOp(code, (k - 1));
09755: tos = (InstParam) stackHandler.pop();
09756: mybegin = tos.getCurrentParamOffsetInCode();
09757: tos = (InstParam) stackHandler.pop();
09758: rem = tos.getNumberOfParamsLeft();
09759: rem = rem - 1;
09760: tos.setNumberOfParamsLeft(rem);
09761: tos.setCurrentParamOffsetInCode(mybegin);
09762: stackHandler.push(tos);
09763: if (rem == 0) {
09764: return;
09765: } else {
09766: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09767: return;
09768: }
09769:
09770: case JvmOpCodes.LMUL:
09771: newentry = new InstParam();
09772: newentry.setNumberOfParamsLeft(2);
09773: newentry.setCurrentParamOffsetInCode(-1);
09774: stackHandler.push(newentry);
09775: handleBasicPrimitiveLoadOp(code, (k - 1));
09776: tos = (InstParam) stackHandler.pop();
09777: mybegin = tos.getCurrentParamOffsetInCode();
09778: tos = (InstParam) stackHandler.pop();
09779: rem = tos.getNumberOfParamsLeft();
09780: rem = rem - 1;
09781: tos.setNumberOfParamsLeft(rem);
09782: tos.setCurrentParamOffsetInCode(mybegin);
09783: stackHandler.push(tos);
09784: if (rem == 0) {
09785: return;
09786: } else {
09787: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09788: return;
09789: }
09790:
09791: case JvmOpCodes.LNEG:
09792: newentry = new InstParam();
09793: newentry.setNumberOfParamsLeft(1);
09794: newentry.setCurrentParamOffsetInCode(-1);
09795: stackHandler.push(newentry);
09796: handleBasicPrimitiveLoadOp(code, (k - 1));
09797: tos = (InstParam) stackHandler.pop();
09798: mybegin = tos.getCurrentParamOffsetInCode();
09799: tos = (InstParam) stackHandler.pop();
09800: rem = tos.getNumberOfParamsLeft();
09801: rem = rem - 1;
09802: tos.setNumberOfParamsLeft(rem);
09803: tos.setCurrentParamOffsetInCode(mybegin);
09804: stackHandler.push(tos);
09805: if (rem == 0) {
09806: return;
09807: } else {
09808: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09809: return;
09810: }
09811:
09812: case JvmOpCodes.LOR:
09813: newentry = new InstParam();
09814: newentry.setNumberOfParamsLeft(2);
09815: newentry.setCurrentParamOffsetInCode(-1);
09816: stackHandler.push(newentry);
09817: handleBasicPrimitiveLoadOp(code, (k - 1));
09818: tos = (InstParam) stackHandler.pop();
09819: mybegin = tos.getCurrentParamOffsetInCode();
09820: tos = (InstParam) stackHandler.pop();
09821: rem = tos.getNumberOfParamsLeft();
09822: rem = rem - 1;
09823: tos.setNumberOfParamsLeft(rem);
09824: tos.setCurrentParamOffsetInCode(mybegin);
09825: stackHandler.push(tos);
09826: if (rem == 0) {
09827: return;
09828: } else {
09829: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09830: return;
09831: }
09832:
09833: case JvmOpCodes.LREM:
09834: newentry = new InstParam();
09835: newentry.setNumberOfParamsLeft(2);
09836: newentry.setCurrentParamOffsetInCode(-1);
09837: stackHandler.push(newentry);
09838: handleBasicPrimitiveLoadOp(code, (k - 1));
09839: tos = (InstParam) stackHandler.pop();
09840: mybegin = tos.getCurrentParamOffsetInCode();
09841: tos = (InstParam) stackHandler.pop();
09842: rem = tos.getNumberOfParamsLeft();
09843: rem = rem - 1;
09844: tos.setNumberOfParamsLeft(rem);
09845: tos.setCurrentParamOffsetInCode(mybegin);
09846: stackHandler.push(tos);
09847: if (rem == 0) {
09848: return;
09849: } else {
09850: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09851: return;
09852: }
09853:
09854: case JvmOpCodes.LSHL:
09855: newentry = new InstParam();
09856: newentry.setNumberOfParamsLeft(2);
09857: newentry.setCurrentParamOffsetInCode(-1);
09858: stackHandler.push(newentry);
09859: handleBasicPrimitiveLoadOp(code, (k - 1));
09860: tos = (InstParam) stackHandler.pop();
09861: mybegin = tos.getCurrentParamOffsetInCode();
09862: tos = (InstParam) stackHandler.pop();
09863: rem = tos.getNumberOfParamsLeft();
09864: rem = rem - 1;
09865: tos.setNumberOfParamsLeft(rem);
09866: tos.setCurrentParamOffsetInCode(mybegin);
09867: stackHandler.push(tos);
09868: if (rem == 0) {
09869: return;
09870: } else {
09871: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09872: return;
09873: }
09874:
09875: case JvmOpCodes.LSHR:
09876: newentry = new InstParam();
09877: newentry.setNumberOfParamsLeft(2);
09878: newentry.setCurrentParamOffsetInCode(-1);
09879: stackHandler.push(newentry);
09880: handleBasicPrimitiveLoadOp(code, (k - 1));
09881: tos = (InstParam) stackHandler.pop();
09882: mybegin = tos.getCurrentParamOffsetInCode();
09883: tos = (InstParam) stackHandler.pop();
09884: rem = tos.getNumberOfParamsLeft();
09885: rem = rem - 1;
09886: tos.setNumberOfParamsLeft(rem);
09887: tos.setCurrentParamOffsetInCode(mybegin);
09888: stackHandler.push(tos);
09889: if (rem == 0) {
09890: return;
09891: } else {
09892: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09893: return;
09894: }
09895:
09896: case JvmOpCodes.LSUB:
09897: newentry = new InstParam();
09898: newentry.setNumberOfParamsLeft(2);
09899: newentry.setCurrentParamOffsetInCode(-1);
09900: stackHandler.push(newentry);
09901: handleBasicPrimitiveLoadOp(code, (k - 1));
09902: tos = (InstParam) stackHandler.pop();
09903: mybegin = tos.getCurrentParamOffsetInCode();
09904: tos = (InstParam) stackHandler.pop();
09905: rem = tos.getNumberOfParamsLeft();
09906: rem = rem - 1;
09907: tos.setNumberOfParamsLeft(rem);
09908: tos.setCurrentParamOffsetInCode(mybegin);
09909: stackHandler.push(tos);
09910: if (rem == 0) {
09911: return;
09912: } else {
09913: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09914: return;
09915: }
09916:
09917: case JvmOpCodes.LUSHR:
09918: newentry = new InstParam();
09919: newentry.setNumberOfParamsLeft(2);
09920: newentry.setCurrentParamOffsetInCode(-1);
09921: stackHandler.push(newentry);
09922: handleBasicPrimitiveLoadOp(code, (k - 1));
09923: tos = (InstParam) stackHandler.pop();
09924: mybegin = tos.getCurrentParamOffsetInCode();
09925: tos = (InstParam) stackHandler.pop();
09926: rem = tos.getNumberOfParamsLeft();
09927: rem = rem - 1;
09928: tos.setNumberOfParamsLeft(rem);
09929: tos.setCurrentParamOffsetInCode(mybegin);
09930: stackHandler.push(tos);
09931: if (rem == 0) {
09932: return;
09933: } else {
09934: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09935: return;
09936: }
09937:
09938: case JvmOpCodes.LXOR:
09939: newentry = new InstParam();
09940: newentry.setNumberOfParamsLeft(2);
09941: newentry.setCurrentParamOffsetInCode(-1);
09942: stackHandler.push(newentry);
09943: handleBasicPrimitiveLoadOp(code, (k - 1));
09944: tos = (InstParam) stackHandler.pop();
09945: mybegin = tos.getCurrentParamOffsetInCode();
09946: tos = (InstParam) stackHandler.pop();
09947: rem = tos.getNumberOfParamsLeft();
09948: rem = rem - 1;
09949: tos.setNumberOfParamsLeft(rem);
09950: tos.setCurrentParamOffsetInCode(mybegin);
09951: stackHandler.push(tos);
09952: if (rem == 0) {
09953: return;
09954: } else {
09955: handleBasicPrimitiveLoadOp(code, (mybegin - 1));
09956: return;
09957: }
09958:
09959: }
09960:
09961: if (code[k] == JvmOpCodes.BALOAD || code[k] == JvmOpCodes.CALOAD
09962: || code[k] == JvmOpCodes.DALOAD || code[k] == JvmOpCodes.FALOAD
09963: || code[k] == JvmOpCodes.LALOAD || code[k] == JvmOpCodes.IALOAD
09964: || code[k] == JvmOpCodes.SALOAD) {
09965: StringBuffer sb = new StringBuffer("");
09966: int posFound = isInstAload(k, code, sb);
09967: while (posFound == -1) {
09968:
09969: k = k - 1;
09970: sb = new StringBuffer("");
09971: posFound = isInstAload(k, code, sb);
09972:
09973: }
09974: InstParam tos = (InstParam) stackHandler.pop();
09975: int rem = tos.getNumberOfParamsLeft();
09976: rem = rem - 1;
09977: tos.setNumberOfParamsLeft(rem);
09978: tos.setCurrentParamOffsetInCode(posFound);
09979: stackHandler.push(tos);
09980: if (rem == 0)
09981: return;
09982: else {
09983: handleBasicPrimitiveLoadOp(code, posFound - 1);
09984: return;
09985: }
09986:
09987: }
09988:
09989: if (code[k] == JvmOpCodes.BIPUSH || code[k] == JvmOpCodes.SIPUSH) {
09990: InstParam tos = (InstParam) stackHandler.pop();
09991: int rem = tos.getNumberOfParamsLeft();
09992: rem = rem - 1;
09993: tos.setNumberOfParamsLeft(rem);
09994: tos.setCurrentParamOffsetInCode(k);
09995: stackHandler.push(tos);
09996: if (rem == 0)
09997: return;
09998: else {
09999: handleBasicPrimitiveLoadOp(code, k - 1);
10000: return;
10001: }
10002:
10003: }
10004: int y = isInstIloadInst(code, k, new StringBuffer(""));
10005: if (y != -1) {
10006: InstParam tos = (InstParam) stackHandler.pop();
10007: int rem = tos.getNumberOfParamsLeft();
10008: rem = rem - 1;
10009: tos.setNumberOfParamsLeft(rem);
10010: tos.setCurrentParamOffsetInCode(y);
10011: stackHandler.push(tos);
10012: if (rem == 0) {
10013: return;
10014: } else {
10015: handleBasicPrimitiveLoadOp(code, y - 1);
10016: tos = (InstParam) stackHandler.pop();
10017: rem = tos.getNumberOfParamsLeft();
10018: if (rem == 0) {
10019: stackHandler.push(tos);
10020: return;
10021: }
10022:
10023: }
10024:
10025: }
10026: y = isInstFloadInst(code, k, new StringBuffer(""));
10027: if (y != -1) {
10028: InstParam tos = (InstParam) stackHandler.pop();
10029: int rem = tos.getNumberOfParamsLeft();
10030: rem = rem - 1;
10031: tos.setNumberOfParamsLeft(rem);
10032: tos.setCurrentParamOffsetInCode(y);
10033: stackHandler.push(tos);
10034: if (rem == 0)
10035: return;
10036: else {
10037: handleBasicPrimitiveLoadOp(code, y - 1);
10038: return;
10039: }
10040:
10041: }
10042: y = isInstDloadInst(code, k, new StringBuffer(""));
10043: if (y != -1) {
10044: InstParam tos = (InstParam) stackHandler.pop();
10045: int rem = tos.getNumberOfParamsLeft();
10046: rem = rem - 1;
10047: tos.setNumberOfParamsLeft(rem);
10048: tos.setCurrentParamOffsetInCode(y);
10049: stackHandler.push(tos);
10050: if (rem == 0)
10051: return;
10052: else {
10053: handleBasicPrimitiveLoadOp(code, y - 1);
10054: return;
10055: }
10056:
10057: }
10058: if (code[k] == JvmOpCodes.LDC || code[k] == JvmOpCodes.LDC2_W
10059: || code[k] == JvmOpCodes.LDC_W) {
10060: InstParam tos = (InstParam) stackHandler.pop();
10061: int rem = tos.getNumberOfParamsLeft();
10062: rem = rem - 1;
10063: tos.setNumberOfParamsLeft(rem);
10064: tos.setCurrentParamOffsetInCode(k);
10065: stackHandler.push(tos);
10066: if (rem == 0)
10067: return;
10068: else {
10069: handleBasicPrimitiveLoadOp(code, k - 1);
10070: return;
10071: }
10072:
10073: }
10074: y = isInstIConstInst(code, k);
10075: if (y != -1) {
10076: InstParam tos = (InstParam) stackHandler.pop();
10077: int rem = tos.getNumberOfParamsLeft();
10078: rem = rem - 1;
10079: tos.setNumberOfParamsLeft(rem);
10080: tos.setCurrentParamOffsetInCode(y);
10081: stackHandler.push(tos);
10082: if (rem == 0)
10083: return;
10084: else {
10085: handleBasicPrimitiveLoadOp(code, y - 1);
10086: return;
10087: }
10088:
10089: }
10090: y = isInstFConstInst(code, k);
10091: if (y != -1) {
10092: InstParam tos = (InstParam) stackHandler.pop();
10093: int rem = tos.getNumberOfParamsLeft();
10094: rem = rem - 1;
10095: tos.setNumberOfParamsLeft(rem);
10096: tos.setCurrentParamOffsetInCode(y);
10097: stackHandler.push(tos);
10098: if (rem == 0)
10099: return;
10100: else {
10101: handleBasicPrimitiveLoadOp(code, y - 1);
10102: return;
10103: }
10104:
10105: }
10106: y = isInstdConstInst(code, k);
10107: if (y != -1) {
10108: InstParam tos = (InstParam) stackHandler.pop();
10109: int rem = tos.getNumberOfParamsLeft();
10110: rem = rem - 1;
10111: tos.setNumberOfParamsLeft(rem);
10112: tos.setCurrentParamOffsetInCode(y);
10113: stackHandler.push(tos);
10114: if (rem == 0)
10115: return;
10116: else {
10117: handleBasicPrimitiveLoadOp(code, y - 1);
10118: return;
10119: }
10120:
10121: }
10122: y = isInstLConstInst(code, k);
10123: if (y != -1) {
10124: InstParam tos = (InstParam) stackHandler.pop();
10125: int rem = tos.getNumberOfParamsLeft();
10126: rem = rem - 1;
10127: tos.setNumberOfParamsLeft(rem);
10128: tos.setCurrentParamOffsetInCode(y);
10129: stackHandler.push(tos);
10130: if (rem == 0)
10131: return;
10132: else {
10133: handleBasicPrimitiveLoadOp(code, y - 1);
10134: return;
10135: }
10136:
10137: }
10138: if (code[k] == JvmOpCodes.GETFIELD) {
10139: StringBuffer sb1 = new StringBuffer("");
10140: int pos2 = isInstAload(k - 1, code, sb1);
10141: if (pos2 != -1) {
10142: InstParam tos = (InstParam) stackHandler.pop();
10143: int rem = tos.getNumberOfParamsLeft();
10144: rem = rem - 1;
10145: tos.setNumberOfParamsLeft(rem);
10146: tos.setCurrentParamOffsetInCode(pos2);
10147: stackHandler.push(tos);
10148: if (rem == 0)
10149: return;
10150: else {
10151: handleBasicPrimitiveLoadOp(code, pos2 - 1);
10152: return;
10153: }
10154: }
10155: }
10156: if (code[k] == JvmOpCodes.GETSTATIC) {
10157:
10158: InstParam tos = (InstParam) stackHandler.pop();
10159: int rem = tos.getNumberOfParamsLeft();
10160: rem = rem - 1;
10161: tos.setNumberOfParamsLeft(rem);
10162: tos.setCurrentParamOffsetInCode(k); // todo: TAKE POP INTO ACCOUNT
10163: stackHandler.push(tos);
10164: if (rem == 0)
10165: return;
10166: else {
10167: handleBasicPrimitiveLoadOp(code, k - 1);
10168: return;
10169: }
10170:
10171: }
10172:
10173: StringBuffer isinvoke = new StringBuffer("");
10174: if (isNextInstructionAnyInvoke(code[k], isinvoke)) {
10175:
10176: InstParam tos = (InstParam) stackHandler.pop();
10177: int rem = tos.getNumberOfParamsLeft();
10178: rem = rem - 1;
10179: tos.setNumberOfParamsLeft(rem);
10180: Integer ref = (Integer) invokeinstrefpos.get(new Integer(k));
10181: if (ref != null) {
10182:
10183: tos.setCurrentParamOffsetInCode(ref.intValue());
10184: stackHandler.push(tos);
10185: if (rem == 0) {
10186: return;
10187: } else {
10188: handleBasicPrimitiveLoadOp(code, ref.intValue() - 1);
10189: return;
10190:
10191: }
10192: }
10193:
10194: }
10195:
10196: if (code[k] == JvmOpCodes.D2F || code[k] == JvmOpCodes.D2I
10197: || code[k] == JvmOpCodes.D2L) {
10198:
10199: int t = k - 1;
10200: boolean done = false;
10201: StringBuffer strb = new StringBuffer("");
10202: int dload = isInstDloadInst(code, t, strb);
10203: int foundpos = -1;
10204: if (dload != -1) {
10205: foundpos = dload;
10206: done = true;
10207: } else {
10208: strb = new StringBuffer("");
10209: int loadin = traceLoadInst(t, code, strb);
10210: if (loadin != -1) {
10211: foundpos = loadin;
10212: done = true;
10213: }
10214:
10215: }
10216:
10217: if (done) {
10218:
10219: InstParam tos = (InstParam) stackHandler.pop();
10220: int rem = tos.getNumberOfParamsLeft();
10221: rem = rem - 1;
10222: tos.setNumberOfParamsLeft(rem);
10223: tos.setCurrentParamOffsetInCode(foundpos);
10224: stackHandler.push(tos);
10225: if (rem == 0)
10226: return;
10227: else {
10228: handleBasicPrimitiveLoadOp(code, foundpos - 1);
10229: return;
10230: }
10231: }
10232:
10233: else {
10234: InstParam newentry = new InstParam();
10235: newentry.setNumberOfParamsLeft(1);
10236: newentry.setCurrentParamOffsetInCode(-1);
10237: stackHandler.push(newentry);
10238: handleBasicPrimitiveLoadOp(code, (k - 1));
10239: InstParam tos = (InstParam) stackHandler.pop();
10240: int entry = tos.getCurrentParamOffsetInCode();
10241: tos = (InstParam) stackHandler.pop();
10242: int r = tos.getNumberOfParamsLeft();
10243: r = r - 1;
10244: tos.setNumberOfParamsLeft(r);
10245: tos.setCurrentParamOffsetInCode(entry);
10246: stackHandler.push(tos);
10247: if (r == 0) {
10248: return;
10249: } else {
10250: handleBasicPrimitiveLoadOp(code, entry - 1);
10251: return;
10252: }
10253: }
10254: }
10255: if (code[k] == JvmOpCodes.I2B || code[k] == JvmOpCodes.I2C
10256: || code[k] == JvmOpCodes.I2S || code[k] == JvmOpCodes.I2D
10257: || code[k] == JvmOpCodes.I2F || code[k] == JvmOpCodes.I2L) {
10258:
10259: int t = k - 1;
10260: boolean done = false;
10261: StringBuffer strb = new StringBuffer("");
10262: int dload = isInstIloadInst(code, t, strb);
10263: int foundpos = -1;
10264: if (dload != -1) {
10265: foundpos = dload;
10266: done = true;
10267: } else {
10268: strb = new StringBuffer("");
10269: int loadin = traceLoadInst(t, code, strb);
10270: if (loadin != -1) {
10271: foundpos = loadin;
10272: done = true;
10273: }
10274:
10275: }
10276:
10277: if (done) {
10278:
10279: InstParam tos = (InstParam) stackHandler.pop();
10280: int rem = tos.getNumberOfParamsLeft();
10281: rem = rem - 1;
10282: tos.setNumberOfParamsLeft(rem);
10283: tos.setCurrentParamOffsetInCode(foundpos);
10284: stackHandler.push(tos);
10285: if (rem == 0)
10286: return;
10287: else {
10288: handleBasicPrimitiveLoadOp(code, foundpos - 1);
10289: return;
10290: }
10291: }
10292:
10293: else {
10294: InstParam newentry = new InstParam();
10295: newentry.setNumberOfParamsLeft(1);
10296: newentry.setCurrentParamOffsetInCode(-1);
10297: stackHandler.push(newentry);
10298: handleBasicPrimitiveLoadOp(code, (k - 1));
10299: InstParam tos = (InstParam) stackHandler.pop();
10300: int entry = tos.getCurrentParamOffsetInCode();
10301: tos = (InstParam) stackHandler.pop();
10302: int r = tos.getNumberOfParamsLeft();
10303: r = r - 1;
10304: tos.setNumberOfParamsLeft(r);
10305: tos.setCurrentParamOffsetInCode(entry);
10306: stackHandler.push(tos);
10307: if (r == 0) {
10308: return;
10309: } else {
10310: handleBasicPrimitiveLoadOp(code, entry - 1);
10311: return;
10312: }
10313: }
10314: }
10315: if (code[k] == JvmOpCodes.F2D || code[k] == JvmOpCodes.F2L
10316: || code[k] == JvmOpCodes.F2I) {
10317: int t = k - 1;
10318: boolean done = false;
10319: StringBuffer strb = new StringBuffer("");
10320: int dload = isInstFloadInst(code, t, strb);
10321: int foundpos = -1;
10322: if (dload != -1) {
10323: foundpos = dload;
10324: done = true;
10325: } else {
10326: strb = new StringBuffer("");
10327: int loadin = traceLoadInst(t, code, strb);
10328: if (loadin != -1) {
10329: foundpos = loadin;
10330: done = true;
10331: }
10332:
10333: }
10334:
10335: if (done) {
10336:
10337: InstParam tos = (InstParam) stackHandler.pop();
10338: int rem = tos.getNumberOfParamsLeft();
10339: rem = rem - 1;
10340: tos.setNumberOfParamsLeft(rem);
10341: tos.setCurrentParamOffsetInCode(foundpos);
10342: stackHandler.push(tos);
10343: if (rem == 0)
10344: return;
10345: else {
10346: handleBasicPrimitiveLoadOp(code, foundpos - 1);
10347: return;
10348: }
10349: }
10350:
10351: else {
10352: InstParam newentry = new InstParam();
10353: newentry.setNumberOfParamsLeft(1);
10354: newentry.setCurrentParamOffsetInCode(-1);
10355: stackHandler.push(newentry);
10356: handleBasicPrimitiveLoadOp(code, (k - 1));
10357: InstParam tos = (InstParam) stackHandler.pop();
10358: int entry = tos.getCurrentParamOffsetInCode();
10359: tos = (InstParam) stackHandler.pop();
10360: int r = tos.getNumberOfParamsLeft();
10361: r = r - 1;
10362: tos.setNumberOfParamsLeft(r);
10363: tos.setCurrentParamOffsetInCode(entry);
10364: stackHandler.push(tos);
10365: if (r == 0) {
10366: return;
10367: } else {
10368: handleBasicPrimitiveLoadOp(code, entry - 1);
10369: return;
10370: }
10371: }
10372: }
10373: if (code[k] == JvmOpCodes.L2D || code[k] == JvmOpCodes.L2F
10374: || code[k] == JvmOpCodes.L2I) {
10375: int t = k - 1;
10376: boolean done = false;
10377: StringBuffer strb = new StringBuffer("");
10378: int dload = isInstLloadInst(code, t, strb);
10379: int foundpos = -1;
10380: if (dload != -1) {
10381: foundpos = dload;
10382: done = true;
10383: } else {
10384: strb = new StringBuffer("");
10385: int loadin = traceLoadInst(t, code, strb);
10386: if (loadin != -1) {
10387: foundpos = loadin;
10388: done = true;
10389: }
10390:
10391: }
10392:
10393: if (done) {
10394:
10395: InstParam tos = (InstParam) stackHandler.pop();
10396: int rem = tos.getNumberOfParamsLeft();
10397: rem = rem - 1;
10398: tos.setNumberOfParamsLeft(rem);
10399: tos.setCurrentParamOffsetInCode(foundpos);
10400: stackHandler.push(tos);
10401: if (rem == 0)
10402: return;
10403: else {
10404: handleBasicPrimitiveLoadOp(code, foundpos - 1);
10405: return;
10406: }
10407: }
10408:
10409: else {
10410: InstParam newentry = new InstParam();
10411: newentry.setNumberOfParamsLeft(1);
10412: newentry.setCurrentParamOffsetInCode(-1);
10413: stackHandler.push(newentry);
10414: handleBasicPrimitiveLoadOp(code, (k - 1));
10415: InstParam tos = (InstParam) stackHandler.pop();
10416: int entry = tos.getCurrentParamOffsetInCode();
10417: tos = (InstParam) stackHandler.pop();
10418: int r = tos.getNumberOfParamsLeft();
10419: r = r - 1;
10420: tos.setNumberOfParamsLeft(r);
10421: tos.setCurrentParamOffsetInCode(entry);
10422: stackHandler.push(tos);
10423: if (r == 0) {
10424: return;
10425: } else {
10426: handleBasicPrimitiveLoadOp(code, entry - 1);
10427: return;
10428: }
10429: }
10430: }
10431:
10432: }
10433:
10434: /***************************************************************************
10435: * belurs: The below 2 are used in handleBasicPrimitiveLoadOp Could Think of
10436: * an appropriate names here. Refactor later if better names can be thpught
10437: * of
10438: */
10439:
10440: private Stack stackHandler = null; // will contain InstParam Objects
10441:
10442: class InstParam {
10443:
10444: private int numberOfParamsLeft; // Example imul takes 2 so initially 2
10445:
10446: // is populated
10447:
10448: private int currentParamOffsetInCode; // Example for imul the first
10449:
10450: // one cane be iload_1..So once
10451:
10452: // This is encountered, currentParamOffsetInCode will be
10453: // set to iload_1 position in code.
10454:
10455: public int getNumberOfParamsLeft() {
10456: return numberOfParamsLeft;
10457: }
10458:
10459: public void setNumberOfParamsLeft(int numberOfParamsLeft) {
10460: this .numberOfParamsLeft = numberOfParamsLeft;
10461: }
10462:
10463: public int getCurrentParamOffsetInCode() {
10464: return currentParamOffsetInCode;
10465: }
10466:
10467: public void setCurrentParamOffsetInCode(int currentParamOffsetInCode) {
10468: this .currentParamOffsetInCode = currentParamOffsetInCode;
10469: }
10470:
10471: }
10472:
10473: private Operand createOperand(Object val, int type, int categ) {
10474: Operand opr = new Operand();
10475: opr.setOperandValue(val);
10476: opr.setOperandType(type);
10477: opr.setCategory(categ);
10478: return opr;
10479:
10480: }
10481:
10482: private Operand createOperand(Object val) {
10483: Operand opr = new Operand();
10484: opr.setOperandValue(val);
10485: return opr;
10486:
10487: }
10488:
10489: private int getSwitchOffset(byte[] info, int counter, java.lang.String lbl) {
10490: int b1 = info[++counter];
10491: int b2 = info[++counter];
10492: int b3 = info[++counter];
10493: int b4 = info[++counter];
10494:
10495: if (b1 < 0)
10496: b1 = (256 + b1);
10497: if (b2 < 0)
10498: b2 = (256 + b2);
10499: if (b3 < 0)
10500: b3 = (256 + b3);
10501: if (b4 < 0)
10502: b4 = (256 + b4);
10503:
10504: int jmp = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
10505: if (jmp > 65535)
10506: jmp = jmp - 65536;
10507: if (lbl.equals("label"))
10508: return jmp;
10509: if (jmp < 0)
10510: jmp = 512 + jmp;
10511: return jmp;
10512:
10513: }
10514:
10515: private java.lang.String getReturnTypeIfPreviousInvoke(int j, byte[] info) {
10516:
10517: // Terminator t;
10518: java.lang.String s = "0";
10519: if (GlobalVariableStore.getInvokeStartEnd() != null) {
10520: Integer in = (Integer) GlobalVariableStore.getInvokeStartEnd().get(
10521: new Integer(j - 1));
10522: if (in != null) {
10523: int iin = in.intValue();
10524: switch (info[iin]) {
10525:
10526: case JvmOpCodes.INVOKEINTERFACE:
10527: int classIndex = getOffset(info, iin);
10528: InterfaceMethodRef iref = cd
10529: .getInterfaceMethodAtCPoolPosition(classIndex);
10530: java.lang.String classname = iref.getClassname();
10531: java.lang.String typeofmet = iref.getTypeofmethod();
10532: int br = typeofmet.indexOf(")");
10533: if (br != -1) {
10534: java.lang.String ret = typeofmet.substring(br + 1);
10535: if (ret.trim().equals("Z")) {
10536: return "false";
10537: }
10538:
10539: }
10540:
10541: break;
10542:
10543: case JvmOpCodes.INVOKESPECIAL:
10544:
10545: classIndex = getOffset(info, iin);
10546: MethodRef mref = cd.getMethodRefAtCPoolPosition(classIndex);
10547: java.lang.String classtype = mref.getClassname();
10548: typeofmet = mref.getTypeofmethod();
10549: br = typeofmet.indexOf(")");
10550: if (br != -1) {
10551: java.lang.String ret = typeofmet.substring(br + 1);
10552: if (ret.trim().equals("Z")) {
10553: return "false";
10554: }
10555:
10556: }
10557:
10558: break;
10559:
10560: case JvmOpCodes.INVOKESTATIC:
10561: classIndex = getOffset(info, iin);
10562: mref = cd.getMethodRefAtCPoolPosition(classIndex);
10563: classname = mref.getClassname();
10564: typeofmet = mref.getTypeofmethod();
10565: br = typeofmet.indexOf(")");
10566: if (br != -1) {
10567: java.lang.String ret = typeofmet.substring(br + 1);
10568: if (ret.trim().equals("Z")) {
10569: return "false";
10570: }
10571:
10572: }
10573:
10574: break;
10575:
10576: case JvmOpCodes.INVOKEVIRTUAL:
10577: classIndex = getOffset(info, iin);
10578: mref = cd.getMethodRefAtCPoolPosition(classIndex);
10579: classname = mref.getClassname();
10580: typeofmet = mref.getTypeofmethod();
10581: br = typeofmet.indexOf(")");
10582: if (br != -1) {
10583: java.lang.String ret = typeofmet.substring(br + 1);
10584: if (ret.trim().equals("Z")) {
10585: return "false";
10586: }
10587:
10588: }
10589:
10590: break;
10591:
10592: default:
10593: return s;
10594:
10595: }
10596: }
10597:
10598: return s;
10599:
10600: } else {
10601: int iin = j - 3;
10602: int classIndex = -1;
10603: boolean isS = isThisInstrStart(behaviour
10604: .getInstructionStartPositions(), iin);
10605: if (isS) {
10606: switch (info[iin]) {
10607:
10608: /*
10609: * case JvmOpCodes.INVOKEINTERFACE: int
10610: * classIndex=getOffset(info,iin); InterfaceMethodRef
10611: * iref=cd.getInterfaceMethodAtCPoolPosition(classIndex);
10612: * java.lang.String classname=iref.getClassname();
10613: * java.lang.String typeofmet=iref.getTypeofmethod(); int
10614: * br=typeofmet.indexOf(")"); if(br!=-1) { java.lang.String
10615: * ret=typeofmet.substring(br+1); if(ret.trim().equals("Z")) {
10616: * return "false"; } }
10617: *
10618: * break;
10619: */
10620:
10621: case JvmOpCodes.INVOKESPECIAL:
10622:
10623: classIndex = getOffset(info, iin);
10624: MethodRef mref = cd.getMethodRefAtCPoolPosition(classIndex);
10625: java.lang.String classtype = mref.getClassname();
10626: java.lang.String typeofmet = mref.getTypeofmethod();
10627: int br = typeofmet.indexOf(")");
10628: if (br != -1) {
10629: java.lang.String ret = typeofmet.substring(br + 1);
10630: if (ret.trim().equals("Z")) {
10631: return "false";
10632: }
10633:
10634: }
10635:
10636: break;
10637:
10638: case JvmOpCodes.INVOKESTATIC:
10639: classIndex = getOffset(info, iin);
10640: mref = cd.getMethodRefAtCPoolPosition(classIndex);
10641: java.lang.String classname = mref.getClassname();
10642: typeofmet = mref.getTypeofmethod();
10643: br = typeofmet.indexOf(")");
10644: if (br != -1) {
10645: java.lang.String ret = typeofmet.substring(br + 1);
10646: if (ret.trim().equals("Z")) {
10647: return "false";
10648: }
10649:
10650: }
10651:
10652: break;
10653:
10654: case JvmOpCodes.INVOKEVIRTUAL:
10655: classIndex = getOffset(info, iin);
10656: mref = cd.getMethodRefAtCPoolPosition(classIndex);
10657: classname = mref.getClassname();
10658: typeofmet = mref.getTypeofmethod();
10659: br = typeofmet.indexOf(")");
10660: if (br != -1) {
10661: java.lang.String ret = typeofmet.substring(br + 1);
10662: if (ret.trim().equals("Z")) {
10663: return "false";
10664: }
10665:
10666: }
10667:
10668: }
10669: }
10670: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
10671: j - 5)
10672: && info[j - 5] == JvmOpCodes.INVOKEINTERFACE) {
10673: iin = j - 5;
10674: classIndex = getOffset(info, iin);
10675: InterfaceMethodRef iref = cd
10676: .getInterfaceMethodAtCPoolPosition(classIndex);
10677: java.lang.String classname = iref.getClassname();
10678: java.lang.String typeofmet = iref.getTypeofmethod();
10679: int br = typeofmet.indexOf(")");
10680: if (br != -1) {
10681: java.lang.String ret = typeofmet.substring(br + 1);
10682: if (ret.trim().equals("Z")) {
10683: return "false";
10684: }
10685:
10686: }
10687: }
10688: }
10689: return s;
10690: }
10691:
10692: ArrayList startlist = null;
10693:
10694: private void findSkipRangesWRTSynchronizedBlocks() {
10695:
10696: startlist = behaviour.getInstructionStartPositions();
10697: synchSkips = new Hashtable();
10698: byte code[] = behaviour.getCode();
10699: if (code == null)
10700: return;
10701: for (int j = 0; j < code.length; j++) {
10702:
10703: if (isThisInstrStart(behaviour.getInstructionStartPositions(), j)
10704: && code[j] == JvmOpCodes.MONITOREXIT) {
10705: int loadpos = -1;
10706: boolean simple = true;
10707: int index = -1;
10708: switch (code[j + 1]) {
10709:
10710: case JvmOpCodes.ALOAD:
10711: simple = false;
10712: loadpos = j + 1;
10713:
10714: break;
10715: case JvmOpCodes.ALOAD_0:
10716: simple = true;
10717: loadpos = j + 1;
10718: index = 0;
10719: break;
10720: case JvmOpCodes.ALOAD_1:
10721: simple = true;
10722: loadpos = j + 1;
10723: index = 1;
10724: break;
10725: case JvmOpCodes.ALOAD_2:
10726: simple = true;
10727: loadpos = j + 1;
10728: index = 2;
10729: break;
10730: case JvmOpCodes.ALOAD_3:
10731: simple = true;
10732: loadpos = j + 1;
10733: index = 3;
10734: break;
10735: default:
10736: loadpos = -1;
10737:
10738: }
10739:
10740: if (loadpos != -1) {
10741:
10742: if (simple) {
10743:
10744: if (code[j + 1 + 1] == JvmOpCodes.ATHROW) {
10745: int start = j;
10746: while (start >= 0) {
10747:
10748: int st = code[start];
10749: if (isThisInstrStart(startlist, start)) {
10750: int storeindex = -1;
10751:
10752: switch (st) {
10753: case JvmOpCodes.ASTORE_0:
10754: storeindex = 0;
10755: break;
10756:
10757: case JvmOpCodes.ASTORE_1:
10758: storeindex = 1;
10759: break;
10760:
10761: case JvmOpCodes.ASTORE_2:
10762: storeindex = 2;
10763: break;
10764:
10765: case JvmOpCodes.ASTORE_3:
10766: storeindex = 3;
10767: break;
10768:
10769: default:
10770: storeindex = -1;
10771: break;
10772:
10773: }
10774:
10775: if (storeindex == index) {
10776:
10777: boolean toskip = confirmSynchronizedSkip(
10778: behaviour.getCode(), j);
10779: if (!toskip) {
10780: int skipstart = start;
10781: int prevstart = getPrevStartOfInst(
10782: start, behaviour.getCode());
10783: synchSkips.put(new Integer(start),
10784: new Integer(j + 2));
10785: ArrayList synchlist = behaviour
10786: .getSynchronizedEntries();
10787: ExceptionTable table = getSynchTableGivenEnd(
10788: synchlist, j + 1);
10789: if (table != null) {
10790: table.setSynchEnd(prevstart);
10791: }
10792: break;
10793:
10794: } else {
10795: synchSkips.put(new Integer(start),
10796: new Integer(j + 2));
10797: break;
10798: }
10799: }
10800:
10801: }
10802: start--;
10803:
10804: }
10805:
10806: }
10807: } else {
10808: if (code[j + 1 + 2] == JvmOpCodes.ATHROW) {
10809: index = code[j + 1 + 1];
10810: if (index < 0)
10811: index += 256; // TODO: apply this to elsewhere
10812: int start = j;
10813: while (start >= 0) {
10814:
10815: int st = code[start];
10816: if (isThisInstrStart(startlist, start)) {
10817: int storeindex = -1;
10818:
10819: switch (st) {
10820: case JvmOpCodes.ASTORE_0:
10821: storeindex = 0;
10822: break;
10823:
10824: case JvmOpCodes.ASTORE_1:
10825: storeindex = 1;
10826: break;
10827:
10828: case JvmOpCodes.ASTORE_2:
10829: storeindex = 2;
10830: break;
10831:
10832: case JvmOpCodes.ASTORE_3:
10833: storeindex = 3;
10834: break;
10835:
10836: case JvmOpCodes.ASTORE:
10837: storeindex = code[start + 1];
10838: if (storeindex < 0)
10839: storeindex += 256;
10840: break;
10841:
10842: default:
10843: storeindex = -1;
10844: break;
10845:
10846: }
10847:
10848: if (storeindex == index) {
10849: boolean toskip = confirmSynchronizedSkip(
10850: behaviour.getCode(), j);
10851: if (!toskip) {
10852: int skipstart = start;
10853: int prevstart = getPrevStartOfInst(
10854: start, behaviour.getCode());
10855: synchSkips.put(new Integer(start),
10856: new Integer(j + 3));
10857: ArrayList synchlist = behaviour
10858: .getSynchronizedEntries();
10859: ExceptionTable table = getSynchTableGivenEnd(
10860: synchlist, j + 1);
10861: if (table != null) {
10862: table.setSynchEnd(prevstart);
10863: }
10864: break;
10865:
10866: } else {
10867: synchSkips.put(new Integer(start),
10868: new Integer(j + 3));
10869: break;
10870:
10871: }
10872: }
10873: }
10874: start--;
10875:
10876: }
10877:
10878: }
10879:
10880: }
10881:
10882: }
10883: }
10884:
10885: }
10886:
10887: sortSynchBlocksByStart();
10888:
10889: }
10890:
10891: private void sortSynchBlocksByStart() {
10892:
10893: if (synchSkips != null) {
10894: sortedsynchSkips = new ArrayList();
10895: Set set = synchSkips.keySet();
10896: List aslist = new ArrayList(set);
10897: Collections.sort(aslist);
10898: for (int i = 0; i < aslist.size(); i++) {
10899: SynchSkipHelper helper = new SynchSkipHelper();
10900: helper.start = ((Integer) aslist.get(i)).intValue();
10901: helper.end = ((Integer) synchSkips.get(aslist.get(i)))
10902: .intValue();
10903: sortedsynchSkips.add(helper);
10904: }
10905: }
10906:
10907: }
10908:
10909: private class SynchSkipHelper {
10910:
10911: private int start;
10912:
10913: private int end;
10914:
10915: public int hashCode() {
10916: final int PRIME = 31;
10917: int result = 1;
10918: result = PRIME * result + end;
10919: result = PRIME * result + start;
10920: return result;
10921: }
10922:
10923: public boolean equals(Object obj) {
10924: if (this == obj)
10925: return true;
10926: if (obj == null)
10927: return false;
10928: if (getClass() != obj.getClass())
10929: return false;
10930: final SynchSkipHelper other = (SynchSkipHelper) obj;
10931: if (end != other.end)
10932: return false;
10933: if (start != other.start)
10934: return false;
10935: return true;
10936: }
10937:
10938: }
10939:
10940: private int handleAloadCase(byte[] info, int i, OperandStack OpStack) {
10941:
10942: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
10943: JvmOpCodes.ALOAD);
10944:
10945: }
10946:
10947: // belurs:
10948: // only polls for end of synch tables . Not start(MonitorEnter)
10949:
10950: private java.lang.String pollsynchblocks(int cur) {
10951:
10952: ArrayList synchlist = behaviour.getSynchronizedEntries();
10953: if (synchlist != null && synchlist.size() > 0) {
10954:
10955: for (int s = 0; s < synchlist.size(); s++) {
10956: ExceptionTable table = (ExceptionTable) synchlist.get(s);
10957: int end = table.getSynchEnd();
10958: if (end == cur
10959: && !TryHelper.synchBlockEndedForStartAt(table
10960: .getStartPC(), synchlist, table)) {
10961: checkForAthrowAtSynchEnd(end);
10962: table.setWasSynchClosed(true);
10963: return "}";
10964: }
10965:
10966: }
10967:
10968: }
10969: return "";
10970:
10971: }
10972:
10973: private void resetEndOfSynchBlockIfNecessary(int current) {
10974:
10975: // Step 1 : Determine the applicable IF block
10976: // fOR EACH MONITORENTER FIND out the closest if and end of that... ~ to
10977: // try handling
10978: ArrayList synchtables = behaviour.getSynchronizedEntries();
10979: byte code[] = behaviour.getCode();
10980:
10981: if (synchtables != null && synchtables.size() > 0) {
10982: ArrayList starts = behaviour.getInstructionStartPositions();
10983: for (int s = 0; s < synchtables.size(); s++) {
10984:
10985: ExceptionTable tab = (ExceptionTable) synchtables.get(s);
10986:
10987: int monitorStart = tab.getMonitorEnterPosInCode();
10988: if (frozenMonitorStarts.contains(new Integer(monitorStart))) {
10989: continue;
10990: }
10991: int start = tab.getStartPC();
10992: if (tab.getMonitorEnterPosInCode() == GlobalVariableStore
10993: .getCurrentMonitorEnterPos()) {
10994:
10995: int synchend = tab.getEndPC(); // belurs:
10996: if (current - 3 >= 0
10997: && isNextInstructionIf(code[current - 3])) // Actually
10998: // The
10999: // previous
11000: // Instruction
11001: {
11002: boolean switchfound = false;
11003: int switchstartpos = -1;
11004: java.lang.String switchtype = null;
11005: for (int x = current - 3 - 1; x > start; x--) {
11006: if (isThisInstrStart(starts, x)
11007: && code[x] == JvmOpCodes.MONITOREXIT) {
11008: GlobalVariableStore
11009: .setCurrentMonitorEnterPos(-1);
11010: return;
11011:
11012: }
11013: if (isThisInstrStart(starts, x)
11014: && isNextInstructionIf(code[x])) {
11015: GlobalVariableStore
11016: .setCurrentMonitorEnterPos(-1);
11017: return;
11018: }
11019: if (isThisInstrStart(starts, x)
11020: && (code[x] == JvmOpCodes.TABLESWITCH || code[x] == JvmOpCodes.LOOKUPSWITCH)) {
11021: switchfound = true;
11022: switchstartpos = x;
11023: if (code[x] == JvmOpCodes.TABLESWITCH)
11024: switchtype = "table";
11025: else
11026: switchtype = "lookup";
11027:
11028: }
11029: }
11030:
11031: if (switchfound) {
11032: if (switchstartpos != -1) {
11033: Switch swblk = getSwitchBlockGivenStart(switchstartpos);
11034: if (swblk != null) {
11035:
11036: ArrayList cases = swblk
11037: .sortCasesByEnd(swblk.getAllCases());
11038: Case endcase = null;
11039: if (cases != null) {
11040: endcase = (Case) cases.get(0);
11041: }
11042: int defend = swblk.getDefaultEnd();
11043: if (defend != -1) {
11044: if (defend > endcase.getCaseEnd()) {
11045: if (swblk.getStartOfSwitch() > start
11046: && defend > synchend) {
11047: tab.setSynchEnd(defend);
11048: GlobalVariableStore
11049: .setCurrentMonitorEnterPos(-1);
11050: return;
11051: }
11052: } else {
11053: if (swblk.getStartOfSwitch() > start
11054: && endcase.getCaseEnd() > synchend) {
11055: tab.setSynchEnd(endcase
11056: .getCaseEnd());
11057: GlobalVariableStore
11058: .setCurrentMonitorEnterPos(-1);
11059: return;
11060: }
11061: }
11062: } else {
11063: if (swblk.getStartOfSwitch() > start
11064: && endcase.getCaseEnd() > synchend) {
11065: tab.setSynchEnd(endcase
11066: .getCaseEnd());
11067: GlobalVariableStore
11068: .setCurrentMonitorEnterPos(-1);
11069: return;
11070: }
11071: }
11072:
11073: }
11074: }
11075:
11076: } else // reset w.r.t if
11077: {
11078:
11079: IFBlock reqdif = null;
11080: Collection ifs = getCurrentIFStructues();
11081: Iterator it = ifs.iterator();
11082: while (it.hasNext()) {
11083: IFBlock IF = (IFBlock) it.next();
11084: if (IF.getIfStart() == current - 3) {
11085: reqdif = IF;
11086: break;
11087: }
11088: }
11089: if (reqdif != null) {
11090: int ifend = reqdif.getIfCloseFromByteCode();
11091: int elseend = reqdif.getElseCloseLineNumber();
11092: if (elseend == -1) {
11093: if (ifend > reqdif.getIfStart()) {
11094: if (reqdif.getIfStart() > start) {
11095: if (ifend > synchend) {
11096: GlobalVariableStore
11097: .setCurrentMonitorEnterPos(-1);
11098: tab.setSynchEnd(ifend);
11099: return;
11100:
11101: }
11102:
11103: }
11104: }
11105:
11106: } else {
11107: if (elseend > reqdif.getIfStart()) {
11108: if (reqdif.getIfStart() > start) {
11109: if (elseend > synchend) {
11110: GlobalVariableStore
11111: .setCurrentMonitorEnterPos(-1);
11112: tab.setSynchEnd(elseend);
11113: return;
11114:
11115: }
11116:
11117: }
11118: }
11119:
11120: }
11121: }
11122:
11123: }
11124:
11125: }
11126:
11127: return;
11128: }
11129:
11130: }
11131:
11132: }
11133:
11134: }
11135:
11136: private Switch getSwitchBlockGivenStart(int start) {
11137: Switch sw = null;
11138: ArrayList allswitches = behaviour.getAllSwitchBlks();
11139: for (int s = 0; s < allswitches.size(); s++) {
11140:
11141: Switch switchblk = (Switch) allswitches.get(s);
11142: if (switchblk.getStartOfSwitch() == start) {
11143: return switchblk;
11144: }
11145: }
11146: return sw;
11147:
11148: }
11149:
11150: private boolean instanceof found = false;
11151:
11152: private void handleSwapInst(OperandStack stack) {
11153: execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null, JvmOpCodes.SWAP);
11154: }
11155:
11156: private int handleAALOAD(OperandStack stack) {
11157: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
11158: JvmOpCodes.AALOAD);
11159:
11160: }
11161:
11162: private boolean isInstReturnInst(byte[] code, int pos, StringBuffer sb) {
11163:
11164: boolean ret = false;
11165: if (isThisInstrStart(behaviour.getInstructionStartPositions(), pos)) {
11166: switch (code[pos]) {
11167: case JvmOpCodes.IRETURN:
11168: sb.append("ireturn");
11169: ret = true;
11170: break;
11171:
11172: case JvmOpCodes.LRETURN:
11173: sb.append("lreturn");
11174: ret = true;
11175: break;
11176: case JvmOpCodes.FRETURN:
11177: sb.append("freturn");
11178: ret = true;
11179: break;
11180: case JvmOpCodes.DRETURN:
11181: sb.append("dreturn");
11182: ret = true;
11183: break;
11184: case JvmOpCodes.ARETURN:
11185: sb.append("areturn");
11186: ret = true;
11187: break;
11188: case JvmOpCodes.RETURN:
11189: sb.append("return");
11190: ret = true;
11191: break;
11192: }
11193: }
11194:
11195: return ret;
11196:
11197: }
11198:
11199: private void addAnyReturnBeforeIfClose(byte[] info, IFBlock IF,
11200: java.lang.StringBuffer S, int j, OperandStack stack) {
11201: int ifend = IF.getIfCloseLineNumber();
11202: boolean addret = addReturnAtIFElseEnd(j);
11203: if (addret) {
11204: if (info[ifend] == JvmOpCodes.GOTO) {
11205: int gotojump = getJumpAddress(info, ifend);
11206: StringBuffer sg = new StringBuffer("");
11207: boolean r = isInstReturnInst(info, gotojump, sg);
11208:
11209: if (r) {
11210: if (sg.toString().equals("return") == false
11211: && stack.size() > 0) {
11212: java.lang.String t = stack.getTopOfStack()
11213: .getOperandValue();
11214: boolean b = isMethodRetBoolean(behaviour);
11215: if (t != null) {
11216: if (t.equals("1") && b)
11217: t = "true";
11218: if (t.equals("0") && b)
11219: t = "false";
11220: java.lang.String retst = "return " + t + ";";
11221: boolean a = addRETURNatI(ifend, IF);
11222: if (a) {
11223: a = BranchHelper.addReturnInIfBlock(
11224: currentForIndex, IF);
11225: if (a) {
11226: S.append(Util
11227: .formatDecompiledStatement(retst));// if
11228:
11229: GlobalVariableStore.getReturnsAtI().put(
11230: new Integer(ifend), "true");
11231: }
11232: }
11233: }
11234:
11235: } else if (sg.toString().equals("return") == true) {
11236: boolean a = addRETURNatI(ifend, IF);
11237: if (a) {
11238: java.lang.String retst = "return ;";
11239: boolean continueadding = okToEndIfElseWithContinueOrReturn(
11240: currentForIndex, IF);
11241: if (continueadding) {
11242: continueadding = BranchHelper
11243: .addReturnInIfBlock(currentForIndex, IF);
11244: if (continueadding) {
11245: S.append(Util
11246: .formatDecompiledStatement(retst));// if
11247:
11248: GlobalVariableStore.getReturnsAtI().put(
11249: new Integer(ifend), "true");
11250: }
11251: }
11252: }
11253: }
11254: }
11255:
11256: } else {
11257:
11258: StringBuffer sg = new StringBuffer("");
11259: boolean r = isInstReturnInst(info, ifend, sg);
11260: if (r) {
11261: if (sg.toString().equals("return") == false
11262: && stack.size() > 0) {
11263: java.lang.String t = stack.getTopOfStack()
11264: .getOperandValue();
11265: boolean b = isMethodRetBoolean(behaviour);
11266: if (t != null) {
11267: if (t.equals("1") && b)
11268: t = "true";
11269: if (t.equals("0") && b)
11270: t = "false";
11271: java.lang.String retst = "return " + t + ";";
11272: boolean a = addRETURNatI(ifend, IF);
11273: if (a) {
11274: a = BranchHelper.addReturnInIfBlock(
11275: currentForIndex, IF);
11276: if (a) {
11277: S.append(Util
11278: .formatDecompiledStatement(retst));// if
11279: // end\n");
11280: GlobalVariableStore.getReturnsAtI().put(
11281: new Integer(ifend), "true");
11282: }
11283: }
11284: }
11285:
11286: } else if (sg.toString().equals("return") == true) {
11287: boolean a = addRETURNatI(ifend, IF);
11288: if (a) {
11289: java.lang.String retst = "return ;";
11290: boolean ok = OKToAddReturn(ifend);
11291: if (ok) {
11292: boolean continueadding = okToEndIfElseWithContinueOrReturn(
11293: currentForIndex, IF);
11294: if (continueadding) {
11295: continueadding = BranchHelper
11296: .addReturnInIfBlock(
11297: currentForIndex, IF);
11298: if (continueadding) {
11299: S
11300: .append(Util
11301: .formatDecompiledStatement(retst));// if
11302: // end\n");
11303: GlobalVariableStore
11304: .getReturnsAtI()
11305: .put(new Integer(ifend), "true");
11306: }
11307: }
11308: }
11309: }
11310: } else {
11311:
11312: }
11313: }
11314:
11315: }
11316:
11317: }
11318: }
11319:
11320: private void addAnyReturnBeforeElseClose(byte[] info, IFBlock IF,
11321: java.lang.StringBuffer S, int j, OperandStack stack) {
11322:
11323: int end = IF.getElseCloseLineNumber();
11324:
11325: StringBuffer sg = new StringBuffer("");
11326: boolean r = isInstReturnInst(info, end, sg);
11327: if (!r) {
11328: if (info[end] == JvmOpCodes.GOTO) {
11329: int gotoj = getJumpAddress(info, end);
11330: sg = new StringBuffer("");
11331: r = isInstReturnInst(info, gotoj, sg);
11332: }
11333: }
11334: if (r) {
11335: if (sg.toString().equals("return") == false) {
11336: if (stack.size() > 0) {
11337: java.lang.String t = stack.getTopOfStack()
11338: .getOperandValue();
11339: boolean b = isMethodRetBoolean(behaviour);
11340: if (t != null) {
11341: if (t.equals("1") && b)
11342: t = "true";
11343: if (t.equals("0") && b)
11344: t = "false";
11345: java.lang.String retst = "return " + t + ";";
11346: boolean ok = OKToAddReturn(end);
11347: boolean ok2 = okToEndIfElseWithContinueOrReturn(
11348: currentForIndex, IF);
11349:
11350: int previousPos = currentForIndex - 1;
11351: boolean athrowfound = false;
11352: if (isThisInstrStart(behaviour
11353: .getInstructionStartPositions(), previousPos)) {
11354: if (behaviour.getCode()[previousPos] == JvmOpCodes.ATHROW) {
11355: athrowfound = true;
11356:
11357: }
11358: }
11359: if (!athrowfound) {
11360: if (ok) {
11361: S.append(Util.formatDecompiledStatement(retst));
11362: GlobalVariableStore.getReturnsAtI().put(
11363: new Integer(end), "true");
11364: }
11365: }
11366: }
11367: }
11368: }
11369: if (sg.toString().equals("return") == true) {
11370: java.lang.String retst = "return ;";
11371: boolean ok = OKToAddReturn(end);
11372: boolean ok2 = okToEndIfElseWithContinueOrReturn(
11373: currentForIndex, IF);
11374: int previousPos = currentForIndex - 1;
11375: boolean athrowfound = false;
11376: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
11377: previousPos)) {
11378: if (behaviour.getCode()[previousPos] == JvmOpCodes.ATHROW) {
11379: athrowfound = true;
11380:
11381: }
11382: }
11383: if (!athrowfound) {
11384: if (ok) {
11385: if (ok2)
11386: S.append(Util.formatDecompiledStatement(retst));
11387: GlobalVariableStore.getReturnsAtI().put(
11388: new Integer(end), "true");
11389: }
11390: }
11391: }
11392: }
11393:
11394: }
11395:
11396: private void checkForIFElseEndStatement(byte[] info, Set methodifs, int i,
11397: StringBuffer reset, OperandStack stack, StringBuffer ifelsecode,
11398: java.lang.String w)
11399:
11400: {
11401: int position_i = i;
11402: List methodifsaslist = IFHelper.sortByToCloseOrder(methodifs);
11403: // Iterator iter = methodifs.iterator();
11404: List generatedifsprinted = new ArrayList();
11405: int y = 0;
11406: for (; y < methodifsaslist.size(); y++) {
11407:
11408: IFBlock current_ifst = (IFBlock) methodifsaslist.get(y);
11409: int current_ifCloseLineNo = current_ifst.getIfCloseLineNumber();
11410: int current_elseCloseLineNo = current_ifst.getElseCloseLineNumber();
11411: if (current_elseCloseLineNo != -1)// && w.equals("else"))
11412: {
11413: if (i == current_elseCloseLineNo) {
11414: // boolean
11415: // print=isThisLoopEndAlso(behaviour.getBehaviourLoops(),i);
11416: boolean addelseend = true;// addElseEnd(i);
11417: if (addelseend) {
11418: StringBuffer sb = new StringBuffer();
11419: java.lang.String lbl = getBranchTypeAtI(i,
11420: current_ifst, sb);
11421: java.lang.String lbl2 = getIfElseReturnAtI(i);
11422: if (lbl2 != null) {
11423: ifelsecode.append(Util
11424: .formatDecompiledStatement(lbl2 + ";\n"));
11425: }
11426:
11427: // BigInteger b
11428: if (lbl != null && !lbl.equals("")
11429: && !lbl.equals("continue") && lbl2 == null) {
11430:
11431: ifelsecode.append(Util
11432: .formatDecompiledStatement(lbl + " "
11433: + sb.toString() + ";\n"));
11434:
11435: }
11436: if (lbl != null && !lbl.equals("")
11437: && lbl.equals("continue") && lbl2 == null) {
11438: boolean continueadding = okToEndIfElseWithContinueOrReturn(
11439: currentForIndex, current_ifst);
11440: if (continueadding)
11441: ifelsecode.append(Util
11442: .formatDecompiledStatement(lbl + " "
11443: + sb.toString() + ";\n"));
11444:
11445: }
11446: if (lbl2 == null) {
11447: StringBuffer sr = new StringBuffer("");
11448: addAnyReturnBeforeElseClose(info, current_ifst, sr,
11449: currentForIndex, stack);
11450: ifelsecode.append(sr.toString());
11451: }
11452:
11453: StringBuffer in = new StringBuffer("");
11454: StringBuffer t = new StringBuffer("");
11455:
11456: boolean isstore = isStoreInst(i, info, in, t);
11457: if (isstore) {
11458:
11459: int ind = Integer.parseInt(in.toString());
11460: if (ind != -1 && opStack.size() > 0) {
11461: boolean simple = false;
11462: if ((ind == 0) || (ind == 1) || (ind == 2)
11463: || (ind == 3))
11464: simple = true;
11465: LocalVariable loc = getLocalVariable(ind,
11466: "store", t.toString(), simple, i);
11467: Operand objref = (Operand) opStack.pop(); // Pop
11468: // The
11469: // Object
11470: // Ref
11471: GlobalVariableStore.setDoNotPop(true);
11472: if (loc != null
11473: && loc.wasCreated()
11474: && objref != null
11475: && objref.getClassType().trim()
11476: .length() > 0)
11477: loc.setDataType(objref.getClassType());
11478: java.lang.String temp = (java.lang.String) objref
11479: .getOperandValue();
11480:
11481: if (loc != null
11482: && !loc.isDeclarationGenerated()) {
11483: /**
11484: * Push Variable Declaration to Front Fix
11485: * For Ternary If Issue
11486: */
11487:
11488: boolean prm = loc.isPrimitive();
11489: boolean bol = loc.isBoolean();
11490: if (prm) {
11491: bol = loc.isBoolean();
11492: }
11493: java.lang.String inival = "null";
11494: if (prm && bol) {
11495: inival = "false";
11496: }
11497: if (prm && !bol) {
11498: inival = "0";
11499: }
11500: if (!loc.isMethodParameterVariable()) {
11501: DecompilerHelper.VariableAtFront vaf = new DecompilerHelper.VariableAtFront(
11502: loc.getVarName(), loc
11503: .getDataType().replace(
11504: '/', '.'),
11505: inival);
11506:
11507: GlobalVariableStore
11508: .getVariablesatfront().add(vaf);
11509: }
11510:
11511: temp = " " + loc.getVarName() + "=" + temp
11512: + ";\n";
11513: behaviour.appendToBuffer(Util
11514: .formatDecompiledStatement(temp));
11515:
11516: } else {
11517:
11518: if (loc != null) {
11519: if (loc.getDataType() != null
11520: && loc.getDataType().indexOf(
11521: "boolean") != -1) {
11522: if ("1".equals(temp)) {
11523: temp = "true";
11524: } else {
11525: temp = "false";
11526: }
11527: }
11528: temp = " " + loc.getVarName() + " ="
11529: + temp + ";\n";
11530: } else {
11531: temp = " " + "<UNKNOWN VARIABLE>"
11532: + " =" + temp + ";\n";
11533: }
11534:
11535: behaviour.appendToBuffer(Util
11536: .formatDecompiledStatement(temp));
11537:
11538: }
11539: } else {
11540: if (opStack.size() >= 3) {
11541: GlobalVariableStore.setDoNotPop(true);
11542: Operand value = opStack.getTopOfStack(); // Value
11543: Operand index = opStack.getTopOfStack(); // Index
11544: // into
11545: // target
11546: Operand arRef = opStack.getTopOfStack(); // Target
11547: // Arref
11548: java.lang.String temp = arRef
11549: .getOperandValue()
11550: + "["
11551: + index.getOperandValue()
11552: + "] ="
11553: + value.getOperandValue()
11554: + ";";
11555: behaviour
11556: .appendToBuffer("\n"
11557: + Util
11558: .formatDecompiledStatement(temp)
11559: + "\n");
11560: }
11561: }
11562:
11563: } else {
11564: if (info[current_ifCloseLineNo] == JvmOpCodes.GOTO) {
11565: int gotojumpa = getJumpAddress(info,
11566: current_ifCloseLineNo);
11567: if (isThisInstrStart(behaviour
11568: .getInstructionStartPositions(),
11569: gotojumpa)) {
11570: in = new StringBuffer("");
11571: t = new StringBuffer("");
11572:
11573: isstore = isStoreInst(gotojumpa, info, in,
11574: t);
11575: if (isstore) {
11576: int ind = Integer.parseInt(in
11577: .toString());
11578: if (ind != -1 && opStack.size() > 0) {
11579: boolean simple = false;
11580: if ((ind == 0) || (ind == 1)
11581: || (ind == 2) || (ind == 3))
11582: simple = true;
11583: LocalVariable loc = getLocalVariable(
11584: ind, "store", t.toString(),
11585: simple, gotojumpa);
11586: Operand objref = (Operand) opStack
11587: .pop(); // Pop The Object
11588: // Ref
11589: GlobalVariableStore
11590: .setDoNotPop(true);
11591: if (loc != null
11592: && loc.wasCreated()
11593: && objref != null
11594: && objref.getClassType()
11595: .trim().length() > 0)
11596: loc.setDataType(objref
11597: .getClassType());
11598: java.lang.String temp = (java.lang.String) objref
11599: .getOperandValue();
11600: if (loc != null
11601: && !loc
11602: .isDeclarationGenerated()) {
11603: /**
11604: * Push Variable Declaration to
11605: * Front Fix For Ternary If
11606: * Issue
11607: */
11608:
11609: boolean prm = loc.isPrimitive();
11610: boolean bol = loc.isBoolean();
11611: if (prm) {
11612: bol = loc.isBoolean();
11613: }
11614: java.lang.String inival = "null";
11615: if (prm && bol) {
11616: inival = "false";
11617: }
11618: if (prm && !bol) {
11619: inival = "0";
11620: }
11621: if (!loc
11622: .isMethodParameterVariable()) {
11623: DecompilerHelper.VariableAtFront vaf = new DecompilerHelper.VariableAtFront(
11624: loc.getVarName(),
11625: loc
11626: .getDataType()
11627: .replace(
11628: '/',
11629: '.'),
11630: inival);
11631:
11632: GlobalVariableStore
11633: .getVariablesatfront()
11634: .add(vaf);
11635: }
11636:
11637: temp = " " + loc.getVarName()
11638: + "=" + temp + ";\n";
11639: behaviour
11640: .appendToBuffer(Util
11641: .formatDecompiledStatement(temp));
11642:
11643: } else {
11644:
11645: if (loc != null)
11646: temp = " "
11647: + loc.getVarName()
11648: + " =" + temp
11649: + ";\n";
11650: else
11651: temp = " "
11652: + "<UNKNOWN VARIABLE>"
11653: + " =" + temp
11654: + ";\n";
11655: behaviour
11656: .appendToBuffer(Util
11657: .formatDecompiledStatement(temp));
11658:
11659: }
11660: } else {
11661: if (opStack.size() >= 3) {
11662: GlobalVariableStore
11663: .setDoNotPop(true);
11664: Operand value = opStack
11665: .getTopOfStack(); // Value
11666: Operand index = opStack
11667: .getTopOfStack(); // Index
11668: // into
11669: // target
11670: Operand arRef = opStack
11671: .getTopOfStack(); // Target
11672: // Arref
11673: java.lang.String temp = arRef
11674: .getOperandValue()
11675: + "["
11676: + index
11677: .getOperandValue()
11678: + "] ="
11679: + value
11680: .getOperandValue()
11681: + ";";
11682: behaviour
11683: .appendToBuffer("\n"
11684: + Util
11685: .formatDecompiledStatement(temp)
11686: + "\n");
11687: }
11688: }
11689:
11690: } else {
11691: if (info[gotojumpa] == JvmOpCodes.PUTFIELD) {
11692: // Add here
11693: GlobalVariableStore
11694: .setDoNotPop(true);
11695: int pos = getOffset(info, gotojumpa);
11696:
11697: FieldRef fref = cd
11698: .getFieldRefAtCPoolPosition(pos);
11699: Operand value = opStack
11700: .getTopOfStack();
11701: Operand objRef = null;
11702: objRef = checkAnyStoredPUTFIELDObjRef(gotojumpa);
11703: if (objRef == null
11704: && opStack.size() > 0) {
11705: objRef = opStack
11706: .getTopOfStack();
11707: }
11708:
11709: java.lang.String temp = "";
11710: java.lang.String freftype = fref
11711: .getTypeoffield();
11712: if (objRef != null) {
11713: StringBuffer stb = new StringBuffer(
11714: "");
11715: checkForImport(objRef
11716: .getOperandValue(), stb);
11717: temp = stb.toString()
11718: + "."
11719: + fref.getFieldName()
11720: + " = "
11721: + value
11722: .getOperandValue()
11723: + ";";
11724: } else {
11725: temp = fref.getFieldName()
11726: + " = "
11727: + value
11728: .getOperandValue()
11729: + ";";
11730: }
11731: behaviour
11732: .appendToBuffer("\n"
11733: + Util
11734: .formatDecompiledStatement(temp)
11735: + "\n");
11736: }
11737: if (info[gotojumpa] == JvmOpCodes.PUTSTATIC) {
11738: GlobalVariableStore
11739: .setDoNotPop(true);
11740: int pos = getOffset(info, gotojumpa);
11741: /*
11742: * parsedString+="PUTSTATIC\t";
11743: * parsedString+="#"+pos;
11744: * parsedString+="\n";
11745: * parsedString+="\t";parsedString+="\t";
11746: */
11747: FieldRef fref = cd
11748: .getFieldRefAtCPoolPosition(pos);
11749: Operand value = opStack
11750: .getTopOfStack();
11751: java.lang.String freftype = fref
11752: .getTypeoffield();
11753:
11754: // For the code statement
11755: int classpointer = fref
11756: .getClassPointer();
11757: ClassInfo cinfo = cd
11758: .getClassInfoAtCPoolPosition(classpointer);
11759: java.lang.String classname = cd
11760: .getUTF8String(cinfo
11761: .getUtf8pointer());
11762: java.lang.String v = value
11763: .getOperandValue()
11764: .toString();
11765: if (v.indexOf("(") == -1
11766: && v.indexOf(")") != -1) {
11767: v = v.replaceAll("\\)", "");
11768:
11769: }
11770: v = v.trim();
11771: StringBuffer stb = new StringBuffer(
11772: "");
11773: checkForImport(classname, stb);
11774: java.lang.String temp = stb
11775: .toString()
11776: + "."
11777: + fref.getFieldName()
11778: + " = " + v + ";";
11779: behaviour
11780: .appendToBuffer("\n"
11781: + Util
11782: .formatDecompiledStatement(temp)
11783: + "\n");
11784: }
11785:
11786: }
11787:
11788: }
11789: }
11790: }
11791:
11792: checkForATHROWAtIFelseEnd(current_ifst, ifelsecode, i);
11793: if (!current_ifst.getDonotclose()
11794: && current_ifst.hasMatchingElseBeenGenerated()
11795: && !current_ifst.elseHasBeenClosed()) {
11796: ifelsecode.append(Util
11797: .formatDecompiledStatement("}\n")); // Else
11798: // End\n");
11799: current_ifst.setElseHasBeenClosed(true);
11800: reset.append("true");
11801: }
11802:
11803: // elseendsadded.add(new Integer(i));
11804: }
11805: // ABove commmented by belurs
11806: // ifHashTable.remove(key);
11807: // ifLevel--;
11808: }
11809:
11810: }
11811: // else
11812: // {
11813: if (i == current_ifCloseLineNo)// && w.equals("if"))// &&
11814: // !current_ifst.hasIfBeenClosed())
11815: {
11816: boolean labelOrReturnAdded = false;
11817:
11818: // boolean
11819: // print=isThisLoopEndAlso(behaviour.getBehaviourLoops(),i);
11820: // System.out.println(print+"print"+i);
11821: // boolean print
11822: // =isThisIfALoopCondition(current_ifst,info,behaviour.getBehaviourLoops());
11823: // if(!print) // TODO:
11824: // {
11825: if (current_ifst.getIfStart() == current_ifst
11826: .getIfCloseLineNumber()) {
11827: // ifelsecode
11828: // return;
11829: }
11830:
11831: boolean skip = accountForAnyDoWhileIF(currentForIndex,
11832: current_ifst);
11833: StringBuffer sb = new StringBuffer();
11834: java.lang.String lbl = getBranchTypeAtI(i, current_ifst, sb);
11835: // System.out.println(lbl+"lbl"+i);
11836: java.lang.String lbl2 = getIfElseReturnAtI(i);
11837: if (lbl2 != null && lbl2.trim().length() > 0) {
11838: ifelsecode.append(Util.formatDecompiledStatement(lbl2
11839: + ";\n"));
11840: labelOrReturnAdded = true;
11841: }
11842:
11843: if (lbl != null && !lbl.trim().equals("")
11844: && !lbl.equals("continue") && lbl2 == null) {
11845: // codeStatements+=
11846: // Util.formatDecompiledStatement(lbl+";\n");
11847: int previousPos = currentForIndex - 1;
11848: boolean athrowfound = false;
11849: if (isThisInstrStart(behaviour
11850: .getInstructionStartPositions(), previousPos)) {
11851: if (behaviour.getCode()[previousPos] == JvmOpCodes.ATHROW) {
11852: athrowfound = true;
11853:
11854: }
11855: }
11856: if (!athrowfound)
11857: ifelsecode.append(Util.formatDecompiledStatement(lbl
11858: + " " + sb.toString() + ";\n"));
11859: labelOrReturnAdded = true;
11860:
11861: }
11862: if (lbl != null && !lbl.trim().equals("")
11863: && lbl.equals("continue") && lbl2 == null) {
11864: boolean continueadding = okToEndIfElseWithContinueOrReturn(
11865: currentForIndex, current_ifst);
11866: if (continueadding) {
11867: ifelsecode.append(Util.formatDecompiledStatement(lbl
11868: + " " + sb.toString() + ";\n"));
11869: labelOrReturnAdded = true;
11870: }
11871:
11872: }
11873: if (lbl2 == null) {
11874: StringBuffer sr = new StringBuffer("");
11875: addAnyReturnBeforeIfClose(info, current_ifst, sr,
11876: currentForIndex, stack);
11877: if (sr.toString().trim().length() > 0) {
11878: ifelsecode.append(sr.toString());
11879: labelOrReturnAdded = true;
11880: }
11881: }
11882: int nextinstrpos = -1;
11883: int gotojumpvalue = -1;
11884: if (info[i] == JvmOpCodes.GOTO) {
11885: nextinstrpos = i + 3;
11886: int gotojumpa = getJumpAddress(info, i);
11887: gotojumpvalue = gotojumpa;
11888: boolean k = storealreadyhandledatifend(i);
11889: if (isThisInstrStart(behaviour
11890: .getInstructionStartPositions(), gotojumpa)
11891: && !k) {
11892: StringBuffer in = new StringBuffer("");
11893: StringBuffer t = new StringBuffer("");
11894:
11895: boolean isstore = isStoreInst(gotojumpa, info, in, t);
11896: if (isstore) {
11897: int ind = Integer.parseInt(in.toString());
11898: if (ind != -1 && opStack.size() > 0) {
11899: boolean simple = false;
11900: if ((ind == 0) || (ind == 1) || (ind == 2)
11901: || (ind == 3))
11902: simple = true;
11903: LocalVariable loc = getLocalVariable(ind,
11904: "store", t.toString(), simple,
11905: gotojumpa);
11906: Operand objref = (Operand) opStack.pop(); // Pop
11907: // The
11908: // Object
11909: // Ref
11910: GlobalVariableStore.setDoNotPop(true);
11911: if (loc != null
11912: && loc.wasCreated()
11913: && objref != null
11914: && objref.getClassType().trim()
11915: .length() > 0)
11916: loc.setDataType(objref.getClassType());
11917: java.lang.String temp = (java.lang.String) objref
11918: .getOperandValue();
11919: if (loc != null
11920: && !loc.isDeclarationGenerated()) {
11921: /**
11922: * Push Variable Declaration to Front Fix
11923: * For Ternary If Issue
11924: */
11925:
11926: boolean prm = loc.isPrimitive();
11927: boolean bol = loc.isBoolean();
11928: if (prm) {
11929: bol = loc.isBoolean();
11930: }
11931: java.lang.String inival = "null";
11932: if (prm && bol) {
11933: inival = "false";
11934: }
11935: if (prm && !bol) {
11936: inival = "0";
11937: }
11938: if (!loc.isMethodParameterVariable()) {
11939: DecompilerHelper.VariableAtFront vaf = new DecompilerHelper.VariableAtFront(
11940: loc.getVarName(), loc
11941: .getDataType().replace(
11942: '/', '.'),
11943: inival);
11944:
11945: GlobalVariableStore
11946: .getVariablesatfront().add(vaf);
11947: }
11948:
11949: temp = " " + loc.getVarName() + "=" + temp
11950: + ";\n";
11951: behaviour.appendToBuffer(Util
11952: .formatDecompiledStatement(temp));
11953:
11954: } else {
11955:
11956: if (loc != null) {
11957: if (loc.getDataType() != null
11958: && loc.getDataType().indexOf(
11959: "boolean") != -1) {
11960: if ("1".equals(temp)) {
11961: temp = "true";
11962: } else {
11963: temp = "false";
11964: }
11965: }
11966: temp = " " + loc.getVarName() + " ="
11967: + temp + ";\n";
11968: }
11969:
11970: else
11971: temp = " " + "<UNKNOWN VARIABLE>"
11972: + " =" + temp + ";\n";
11973: behaviour.appendToBuffer(Util
11974: .formatDecompiledStatement(temp));
11975:
11976: }
11977: storesatifend.add(new Integer(i));
11978: } else {
11979: if (opStack.size() >= 3) {
11980: GlobalVariableStore.setDoNotPop(true);
11981: Operand value = opStack.getTopOfStack(); // Value
11982: Operand index = opStack.getTopOfStack(); // Index
11983: // into
11984: // target
11985: Operand arRef = opStack.getTopOfStack(); // Target
11986: // Arref
11987: java.lang.String temp = arRef
11988: .getOperandValue()
11989: + "["
11990: + index.getOperandValue()
11991: + "] ="
11992: + value.getOperandValue()
11993: + ";";
11994: behaviour
11995: .appendToBuffer("\n"
11996: + Util
11997: .formatDecompiledStatement(temp)
11998: + "\n");
11999: storesatifend.add(new Integer(i));
12000: }
12001: }
12002:
12003: } else {
12004: if (info[gotojumpa] == JvmOpCodes.PUTFIELD) {
12005: // Add here
12006: GlobalVariableStore.setDoNotPop(true);
12007: int pos = getOffset(info, gotojumpa);
12008:
12009: FieldRef fref = cd
12010: .getFieldRefAtCPoolPosition(pos);
12011: Operand value = opStack.getTopOfStack();
12012: Operand objRef = opStack.getTopOfStack();
12013: putfieldObjRefMap.put(new Integer(gotojumpa),
12014: objRef);
12015: java.lang.String freftype = fref
12016: .getTypeoffield();
12017: StringBuffer stb = new StringBuffer("");
12018: checkForImport(objRef.getOperandValue(), stb);
12019: java.lang.String temp = stb.toString() + "."
12020: + fref.getFieldName() + " = "
12021: + value.getOperandValue() + ";";
12022: behaviour.appendToBuffer("\n"
12023: + Util.formatDecompiledStatement(temp)
12024: + "\n");
12025: }
12026: if (info[gotojumpa] == JvmOpCodes.PUTSTATIC) {
12027: GlobalVariableStore.setDoNotPop(true);
12028: int pos = getOffset(info, gotojumpa);
12029: /*
12030: * parsedString+="PUTSTATIC\t";
12031: * parsedString+="#"+pos; parsedString+="\n";
12032: * parsedString+="\t";parsedString+="\t";
12033: */
12034: FieldRef fref = cd
12035: .getFieldRefAtCPoolPosition(pos);
12036: Operand value = opStack.getTopOfStack();
12037: java.lang.String freftype = fref
12038: .getTypeoffield();
12039:
12040: // For the code statement
12041: int classpointer = fref.getClassPointer();
12042: ClassInfo cinfo = cd
12043: .getClassInfoAtCPoolPosition(classpointer);
12044: java.lang.String classname = cd
12045: .getUTF8String(cinfo.getUtf8pointer());
12046: java.lang.String v = value.getOperandValue()
12047: .toString();
12048: if (v.indexOf("(") == -1
12049: && v.indexOf(")") != -1) {
12050: v = v.replaceAll("\\)", "");
12051:
12052: }
12053: v = v.trim();
12054: StringBuffer stb = new StringBuffer("");
12055: checkForImport(classname, stb);
12056: java.lang.String temp = stb.toString() + "."
12057: + fref.getFieldName() + " = " + v + ";";
12058: behaviour.appendToBuffer("\n"
12059: + Util.formatDecompiledStatement(temp)
12060: + "\n");
12061: }
12062:
12063: }
12064:
12065: }
12066: }
12067: if (!current_ifst.IfHasBeenClosed()
12068: && current_ifst.getDonotclose() == false) {
12069:
12070: // Note: sbelur
12071: // Take if end reset due to do-while kind of loops into
12072: // account here
12073: boolean ifendreset = false;
12074: java.lang.String e = (java.lang.String) ifsbeginends_dowhile
12075: .get("" + current_ifst.getIfStart());
12076: int ie = -1;
12077: if (e != null) {
12078: try {
12079: ie = Integer.parseInt(e);
12080: } catch (NumberFormatException ne) {
12081: e = null;
12082: }
12083: }
12084:
12085: if (e != null) {
12086: int currentclose = current_ifst.getIfCloseLineNumber();
12087: if (currentclose != ie && ie != -1 && ie > currentclose) {
12088: current_ifst.setIfCloseLineNumber(ie);
12089: ifendreset = true;
12090: }
12091: }
12092:
12093: // NOTE: sbelur
12094: // Changes below are to fix the bug caused by if @ end of
12095: // this if's loop
12096: // that if body had to be closed before this if loop could
12097: // be closed
12098:
12099: if (!skip && !ifendreset) {
12100: checkForATHROWAtIFelseEnd(current_ifst, ifelsecode, i);
12101: // //if end +current_ifst.getIfStart()
12102:
12103: // TODO: w.r.t goto at if end
12104: // Fix for infinite.java
12105: if (gotojumpvalue != -1 && nextinstrpos != -1
12106: && !labelOrReturnAdded) {
12107:
12108: if (gotojumpvalue > position_i + 3) {
12109: int nextpos = DecompilerHelper
12110: .getNextInstrPos(nextinstrpos);
12111: int p = i - 1;
12112: boolean invalid = false;
12113: if (isThisInstrStart(behaviour
12114: .getInstructionStartPositions(), p)) {
12115: if (info[p] == JvmOpCodes.ATHROW) {
12116: invalid = true;
12117: }
12118: }
12119: if (!invalid
12120: && !TryHelper
12121: .doesHandlerBlockStartAtIndex(nextinstrpos)) {
12122:
12123: if (gotojumpvalue > nextpos) {
12124: boolean correct_if = false;
12125: IFinder branchFinder = FinderFactory
12126: .getFinder(IFinder.BRANCH);
12127: for (int from = i - 1; from >= 0; from--) {
12128: if (isThisInstrStart(
12129: behaviour
12130: .getInstructionStartPositions(),
12131: from)) {
12132:
12133: if (branchFinder
12134: .isInstructionIF(from)) {
12135: if (from == current_ifst
12136: .getIfStart()) {
12137:
12138: correct_if = true;
12139: break;
12140: } else {
12141: correct_if = false;
12142: break;
12143: }
12144: }
12145: }
12146: }
12147:
12148: if (correct_if) {
12149: DecompilerHelper.VariableAtFront vaf = new DecompilerHelper.VariableAtFront(
12150: "JdecGenerated_" + i,
12151: "boolean".replace('/', '.'),
12152: "true");
12153:
12154: generatedIfTracker.add(
12155: current_ifst, nextinstrpos,
12156: gotojumpvalue,
12157: "JdecGenerated_" + i);
12158: if (!generatedifsprinted
12159: .contains(new Integer(i))) {
12160:
12161: GlobalVariableStore
12162: .getVariablesatfront()
12163: .add(vaf);
12164: behaviour
12165: .appendToBuffer((Util
12166: .formatDecompiledStatement("\nJdecGenerated_"
12167: + i
12168: + "=false;\n")));
12169:
12170: generatedifsprinted
12171: .add(new Integer(i));
12172: }
12173: }
12174: }
12175: }
12176: }
12177:
12178: }
12179: // ifend" + current_ifCloseLineNo + ":" +
12180: // current_ifst.getIfStart() +
12181: if (currentForIndex != current_ifst.getIfStart())
12182: ifelsecode.append(Util
12183: .formatDecompiledStatement("\n}"
12184: // +current_ifst.getIfStart()+"-"+current_ifst.getIfCloseLineNumber()+"-"+currentForIndex
12185: + "\n"));// if//ifend
12186: else {
12187: Loop clashedloop = IFHelper
12188: .getClashingLoopIfEndAtStartWRTALoop(current_ifst);
12189: if (clashedloop != null) {
12190: current_ifst.setIfCloseLineNumber(clashedloop
12191: .getEndIndex());
12192: } else {
12193: ifelsecode
12194: .append(Util
12195: .formatDecompiledStatement("\n}"
12196: + "\n"));// if//ifend
12197: }
12198: }
12199: current_ifst.setIfHasBeenClosed(true);
12200: // end\nIFEND"+current_ifst.getIfCloseLineNumber()+"");
12201: int loopBeginForIf = IFHelper
12202: .attachMarkerToIfInDoWhileKindOfLoop(current_ifst
12203: .getIfStart());
12204: boolean skipBreakCheck = false;
12205: if (loopBeginForIf != -1) {
12206: if (GlobalVariableStore.getDowhileloopmarkers() != null
12207: && GlobalVariableStore
12208: .getDowhileloopmarkers()
12209: .contains(
12210: new Integer(loopBeginForIf))) {
12211: ifelsecode.append("\n<IF_AT_LOOP_END_END_"
12212: + loopBeginForIf + "_>\n");
12213: skipBreakCheck = true;
12214: }
12215: }
12216:
12217: boolean add = true;
12218: if (GlobalVariableStore.getBranchLabels() != null
12219: && !skipBreakCheck) {
12220: Iterator iterator = GlobalVariableStore
12221: .getBranchLabels().entrySet().iterator();
12222: while (iterator.hasNext()) {
12223: Entry entry = (Entry) iterator.next();
12224: DecompilerHelper.BranchLabel bl = (DecompilerHelper.BranchLabel) entry
12225: .getKey();
12226: if (bl.getLBL() != null
12227: && bl.getLBL().trim().equals("break")) {
12228: IFBlock IF = bl.getIF();
12229: if (IF.getIfCloseLineNumber() == i) {
12230: add = false;
12231: }
12232: }
12233: }
12234: }
12235: java.lang.String s = "";
12236: boolean elseadded = false;
12237: // BUGGY Charinfo
12238: if (add && !skipBreakCheck) {
12239: s = addAnyElseBreakForIFChain(current_ifst
12240: .getIfStart());
12241: ifelsecode.append(s);
12242: if (s.trim().length() > 0) {
12243: elseadded = true;
12244: current_ifst.setElsebreakadded(true);
12245: }
12246: }
12247: if (s.trim().length() == 0 && !skipBreakCheck) {
12248: boolean alreadygenerated = false;
12249: boolean loopEndalso = LoopHelper.isThisLoopEndAlso(
12250: behaviour.getBehaviourLoops(),
12251: currentForIndex, current_ifst.getIfStart());
12252: if (loopEndalso) {
12253: IFBlock associatedIf = IFHelper
12254: .getAssociatedIfAt(currentForIndex);
12255: if (associatedIf != null
12256: && current_ifst.getIfStart() == associatedIf
12257: .getIfStart()
12258: && current_ifst
12259: .getIfCloseFromByteCode() > currentForIndex) {
12260: alreadygenerated = true;
12261: java.lang.String elsestmt = "\nelse\n{\nbreak;\n}\n";
12262: ifelsecode
12263: .append(Util
12264: .formatDecompiledStatement(elsestmt));
12265: elseadded = true;
12266: }
12267: }
12268: }
12269: if (!elseadded && s.length() == 0 && !skipBreakCheck) {
12270: boolean elligible = BranchHelper.checkForReturn(
12271: behaviour.getCode(), currentForIndex - 1);
12272: if (!elligible) {
12273: if (isThisInstrStart(behaviour
12274: .getInstructionStartPositions(),
12275: currentForIndex - 1)) {
12276: if (info[currentForIndex - 1] == JvmOpCodes.ATHROW) {
12277: elligible = true;
12278: }
12279: }
12280: }
12281:
12282: if (elligible && !skipBreakCheck) {
12283: int reqdpos = -1;
12284: int ifstart = current_ifst.getIfStart();
12285: for (int u = ifstart + 1; u < currentForIndex; u++) {
12286: if (isThisInstrStart(behaviour
12287: .getInstructionStartPositions(), u)) {
12288: boolean isif = isNextInstructionIf(info[u]);
12289: if (isif) {
12290: int newreqdpos = getJumpAddress(
12291: info, u);
12292: if (reqdpos == -1)
12293: reqdpos = newreqdpos;
12294: else {
12295: if (newreqdpos < reqdpos) {
12296: reqdpos = newreqdpos;
12297: }
12298: }
12299: }
12300: }
12301:
12302: }
12303: if (reqdpos != -1 && !skipBreakCheck
12304: && reqdpos > currentForIndex) {
12305: elseadded = true;
12306: current_ifst
12307: .setHasMatchingElseBeenGenerated(true);
12308: current_ifst
12309: .setElseCloseLineNumber(reqdpos);
12310: ifelsecode
12311: .append(Util
12312: .formatDecompiledStatement("\nelse"
12313: + currentForIndex
12314: + "\n{\n"));
12315: }
12316:
12317: }
12318: }
12319: if (!elseadded && s.length() == 0 && !skipBreakCheck) {
12320: int byc = current_ifst.getIfCloseFromByteCode();
12321: if (byc < current_ifst.getIfStart()) {
12322: Loop ploop = LoopHelper.getLoopGivenStart(byc);
12323: if (ploop != null) {
12324: if (info[currentForIndex] == JvmOpCodes.GOTO) {
12325: int gj = FinderFactory.getFinder(
12326: IFinder.BASE).getJumpAddress(
12327: currentForIndex);
12328: Loop ifloop = LoopHelper
12329: .getLoopGivenStart(gj);
12330: if (ifloop != null) {
12331: for (int f = ifloop.getStartIndex(); f <= current_ifst
12332: .getIfStart(); f++) {
12333: if (isThisInstrStart(
12334: behaviour
12335: .getInstructionStartPositions(),
12336: f)) {
12337: if (isInstructionIF(info[f])) {
12338: if (f == current_ifst
12339: .getIfStart()) {
12340: if (ploop
12341: .getStartIndex() < ifloop
12342: .getStartIndex()) {
12343: if (ploop
12344: .getEndIndex() >= ifloop
12345: .getEndIndex()) {
12346: elseadded = true;
12347: current_ifst
12348: .setHasMatchingElseBeenGenerated(true);
12349: java.lang.String elsestmt = "\nelse\n{\nbreak;\n}\n";
12350: ifelsecode
12351: .append(Util
12352: .formatDecompiledStatement(elsestmt));
12353: }
12354: }
12355: }
12356: }
12357: }
12358: }
12359: }
12360: }
12361: }
12362: }
12363: }
12364:
12365: }
12366:
12367: }
12368:
12369: // }
12370:
12371: }
12372:
12373: // }
12374: }
12375:
12376: }
12377:
12378: private boolean accountForAnyDoWhileIF(int current, IFBlock ifst) {
12379: boolean skip = false;
12380: ArrayList loops = behaviour.getBehaviourLoops();
12381: ArrayList starts = behaviour.getInstructionStartPositions();
12382: byte[] code = behaviour.getCode();
12383: Loop l = getLoopGivenEnd(current, loops);
12384: if (l != null) {
12385: boolean isif = isInstructionIF(code[current]);
12386: if (isif && isThisInstrStart(starts, current)) {
12387: int jump = getJumpAddress(code, current);
12388: if (jump < current && jump == l.getStartIndex()) {
12389: int start = jump;
12390: int till = current;
12391: for (int z = start; z < till; z++) {
12392: boolean st = isThisInstrStart(starts, z);
12393: if (st) {
12394: isif = isInstructionIF(code[z]);
12395: if (isif) {
12396: int passedIfStart = ifst.getIfStart();
12397: int passedIfbyend = ifst
12398: .getIfCloseFromByteCode();
12399: if (passedIfStart == z) {
12400: if (passedIfbyend > l.getEndIndex()) {
12401: start = current + 3;
12402: for (int m = start; m < passedIfbyend; m++) {
12403: boolean ret = checkForReturn(code,
12404: m);
12405: if (ret) {
12406: // need to reset end of ifst and
12407: // loop here
12408: // also for found if at current
12409: ifst
12410: .setIfCloseLineNumber(passedIfbyend);
12411: l
12412: .setLoopendDueToReset(passedIfbyend);
12413: l.setLoopendreset(true);
12414: skip = true;
12415:
12416: // Need to check for any changes
12417: // to be done in branchLabels
12418: checkForChangeInBranchLabels(ifst);
12419:
12420: return skip;
12421: } else // check for athrow
12422: {
12423: st = isThisInstrStart(starts, m);
12424: if (st) {
12425: if (code[m] == JvmOpCodes.ATHROW) {
12426: // need to reset end of
12427: // ifst and loop here
12428: // also for found if at
12429: // current
12430: ifst
12431: .setIfCloseLineNumber(passedIfbyend);
12432: l
12433: .setLoopendDueToReset(passedIfbyend);
12434: l.setLoopendreset(true);
12435: skip = true;
12436: // Need to check for any
12437: // changes to be done in
12438: // branchLabels
12439: checkForChangeInBranchLabels(ifst);
12440: return skip;
12441: }
12442: }
12443: }
12444:
12445: }
12446:
12447: }
12448: }
12449: }
12450:
12451: }
12452: }
12453:
12454: }
12455: }
12456:
12457: }
12458: return skip;
12459: }
12460:
12461: /*
12462: * private boolean pushOnStackForStoreInst(byte[] info,int cur,boolean type) {
12463: * if(type) { int next=cur+1; switch(info[next]) {
12464: *
12465: * case JvmOpCodes.IADD: case JvmOpCodes.IAND: case JvmOpCodes.I } } else { } }
12466: */
12467:
12468: // belurs:
12469: /***************************************************************************
12470: * NOTE: Currently This method takes into account only dup and dup2 NOT
12471: * dup2_x1 and dup_x2 So the jdec might not output correctly if the dup inst
12472: * if one oisStoreInstf dup2_x1 and dup_x2 TODO: Need to revisit This Item
12473: * and fix the problem This method is used by primitive store blocks to
12474: * check whether to print Or add to stack
12475: */
12476:
12477: private boolean isPrevInstDup(byte[] info, int cur) {
12478:
12479: if (isThisInstrStart(behaviour.getInstructionStartPositions(), cur - 1)
12480: && (info[cur - 1] == JvmOpCodes.DUP || info[cur - 1] == JvmOpCodes.DUP2))
12481: return true;
12482: else
12483: return false;
12484:
12485: }
12486:
12487: private boolean isInstDup(byte[] info, int cur) {
12488:
12489: if (isThisInstrStart(behaviour.getInstructionStartPositions(), cur)
12490: && (info[cur] == JvmOpCodes.DUP || info[cur] == JvmOpCodes.DUP2))
12491: return true;
12492: else
12493: return false;
12494: }
12495:
12496: private void popFromStackIFNec(byte[] info, int cur, OperandStack stack)
12497:
12498: {
12499: ArrayList list = behaviour.getInstructionStartPositions();
12500:
12501: if (info[cur - 5] == JvmOpCodes.INVOKEINTERFACE
12502: && isThisInstrStart(list, cur - 5)) {
12503: stack.getTopOfStack();
12504: }
12505: if (info[cur - 3] == JvmOpCodes.INVOKESPECIAL
12506: && isThisInstrStart(list, cur - 3)) {
12507: stack.getTopOfStack();
12508: }
12509: if (info[cur - 3] == JvmOpCodes.INVOKEVIRTUAL
12510: && isThisInstrStart(list, cur - 3)) {
12511: stack.getTopOfStack();
12512: }
12513: if (info[cur - 3] == JvmOpCodes.INVOKESTATIC
12514: && isThisInstrStart(list, cur - 3)) {
12515: stack.getTopOfStack();
12516: }
12517:
12518: }
12519:
12520: private void handleSimpleLStoreCase(OperandStack stack, byte[] info,
12521: int index) {
12522:
12523: int opcodeval;
12524: switch (index) {
12525:
12526: case 0:
12527: opcodeval = JvmOpCodes.LSTORE_0;
12528: break;
12529: case 1:
12530: opcodeval = JvmOpCodes.LSTORE_1;
12531: break;
12532: case 2:
12533: opcodeval = JvmOpCodes.LSTORE_2;
12534: break;
12535: default:
12536: opcodeval = JvmOpCodes.LSTORE_3;
12537: break;
12538: }
12539:
12540: execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.LONG, opcodeval);
12541: }
12542:
12543: private int handleSimpleFstoreCaseInst(OperandStack stack, byte[] info,
12544: int index) {
12545:
12546: int opcodeval;
12547:
12548: switch (index) {
12549: case 0:
12550: opcodeval = JvmOpCodes.FSTORE_0;
12551: break;
12552: case 1:
12553: opcodeval = JvmOpCodes.FSTORE_1;
12554: break;
12555: case 2:
12556: opcodeval = JvmOpCodes.FSTORE_2;
12557: break;
12558: default:
12559: opcodeval = JvmOpCodes.FSTORE_3;
12560: break;
12561: }
12562:
12563: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.FLOAT,
12564: opcodeval);
12565: }
12566:
12567: private int handleSimpleDstoreCaseInst(int opcodevalue) {
12568: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.DOUBLE,
12569: opcodevalue);
12570: }
12571:
12572: private Hashtable anewarrayrefpos;
12573:
12574: private boolean processANEWARRAYb4Invoke(byte[] code, int s,
12575: StringBuffer invokepos) {
12576:
12577: int startpos = s + 2 + 1;
12578: ArrayList starts = behaviour.getInstructionStartPositions();
12579: boolean donotprocess = false;
12580: boolean foundinvoke = false;
12581: int pos = -1;
12582: for (int k = startpos; k < code.length; k++) {
12583:
12584: boolean startinst = isThisInstrStart(starts, k);
12585: if (code[k] == JvmOpCodes.INVOKEINTERFACE
12586: || code[k] == JvmOpCodes.INVOKEVIRTUAL
12587: || code[k] == JvmOpCodes.INVOKESTATIC) {
12588: foundinvoke = true;
12589: pos = k;
12590: break;
12591: }
12592: }
12593:
12594: if (pos != -1) {
12595: for (int k = startpos; k < pos; k++) {
12596: boolean startinst = isThisInstrStart(starts, k);
12597: if (startinst) {
12598:
12599: switch (code[k]) {
12600:
12601: case JvmOpCodes.NEW:
12602: case JvmOpCodes.NEWARRAY:
12603: case JvmOpCodes.MULTIANEWARRAY:
12604: invokepos.append(pos);
12605: donotprocess = true;
12606: return donotprocess;
12607:
12608: }
12609:
12610: }
12611: }
12612: }
12613:
12614: return donotprocess;
12615:
12616: }
12617:
12618: private void resetMethodParameters(OperandStack stack,
12619: ArrayList methodParams, int j) {
12620: // Check if reset needs to be done in the first place
12621: if (GlobalVariableStore.getProblematicInvokes() == null
12622: || GlobalVariableStore.getProblematicInvokes().size() == 0)
12623: return;
12624: boolean ok = false;
12625: for (int n = 0; n < GlobalVariableStore.getProblematicInvokes().size(); n++) {
12626:
12627: Integer in = (Integer) GlobalVariableStore.getProblematicInvokes()
12628: .get(n);
12629: if (in.intValue() == j) {
12630: ok = true; // Yes jdec
12631: break;
12632: } else
12633: ok = false;
12634:
12635: }
12636: if (!ok)
12637: return;
12638:
12639: // some validations
12640: if (methodParams == null || stack == null)
12641: return;
12642: int count = methodParams.size();
12643: if (count == 0)
12644: return;
12645: if (stack.size() < count)
12646: return; // Should Not happen: A Bug in jdec
12647: Operand reqdops[] = new Operand[count];
12648: boolean needtoresetstack = false;
12649: for (int h = 0; h < count; h++) {
12650: reqdops[h] = stack.getTopOfStack();
12651: needtoresetstack = true;
12652: }
12653:
12654: // IMPORTANT : IF needtoresetstack IS TRUE method shud return only after
12655: // resetting stack .NOT before that
12656:
12657: // start Resetting
12658: int opstart = 0;
12659: for (int z = count - 1; z >= 0; z--) {
12660:
12661: Operand current = reqdops[opstart];
12662: opstart++;
12663: if (current != null) {
12664: java.lang.String type = current.getLocalVarType();
12665: boolean needtoreset = false;
12666: java.lang.String param = (java.lang.String) methodParams.get(z);
12667: if (type != null && type.trim().equals("int")) {
12668:
12669: if (param.trim().equals("byte")) {
12670: needtoreset = true;
12671: } else if (param.trim().equals("boolean")) {
12672: needtoreset = true;
12673: } else if (param.trim().equals("short")) {
12674: needtoreset = true;
12675: } else if (param.trim().equals("char")) {
12676: needtoreset = true;
12677: } else {
12678: needtoreset = false;
12679: }
12680: if (needtoreset) {
12681: int localIndex = current.getLocalVarIndex();
12682: java.lang.String searchFor = "#REPLACE_INT_"
12683: + localIndex + "#";
12684: int len = searchFor.length();
12685: int start = behaviour.getCodeStatements().indexOf(
12686: searchFor);
12687: java.lang.String name = "";
12688: if (start != -1) {
12689: java.lang.String tp = behaviour.getCodeStatements()
12690: .substring(start + len, start + len + 3);
12691: int equalTo = -1;
12692: StringBuffer newpos = new StringBuffer("");
12693: if (tp.equals("int")) {
12694: // java.lang.String=codeStatements.replaceFirst(searchFor+"int",param.trim());
12695: name = (java.lang.String) current
12696: .getOperandValue();
12697:
12698: behaviour
12699: .replaceBuffer(getStringAfterReplacement(
12700: start, searchFor + "int", param
12701: .trim(), newpos, name,
12702: false, param.trim()));
12703:
12704: }
12705: try {
12706: equalTo = Integer.parseInt(newpos.toString());
12707: } catch (NumberFormatException ne) {
12708: equalTo = -1;
12709: }
12710:
12711: if (equalTo != -1) {
12712: int valueIn = behaviour.getCodeStatements()
12713: .indexOf("#VALUE" + localIndex + "#",
12714: equalTo);
12715: if (valueIn != -1) {
12716: java.lang.String valuehash = "#VALUE"
12717: + localIndex + "#";
12718: java.lang.String val = behaviour
12719: .getCodeStatements().substring(
12720: valueIn
12721: + valuehash
12722: .length(),
12723: valueIn
12724: + valuehash
12725: .length()
12726: + 1);
12727:
12728: behaviour
12729: .replaceBuffer(getStringAfterReplacement(
12730: valueIn, "#VALUE"
12731: + localIndex + "#",
12732: val, newpos, name, true,
12733: param.trim()));
12734: }
12735: }
12736: }
12737:
12738: }
12739:
12740: } else if (type != null && type.trim().equals("")) {
12741:
12742: if (param.trim().equals("byte")
12743: || param.trim().equals("short")
12744: || param.trim().equals("char")) {
12745:
12746: current.setOperandValue("(" + param + ")"
12747: + current.getOperandValue());
12748:
12749: }
12750: }
12751: // Check for multidimensional.....
12752:
12753: if (param.trim().indexOf("[") != -1) {
12754: int first = param.trim().indexOf("[");
12755: int last = param.trim().lastIndexOf("[");
12756: int howmany = last - first + 1;
12757: boolean isMulti = current.isMultiDimension();
12758: if (isMulti) {
12759: java.lang.String value = (java.lang.String) current
12760: .getOperandValue();
12761: /*
12762: * if(value.indexOf("[")!=-1) { /*int cnt=1; int
12763: * start=value.indexOf("["); int next=start+1;
12764: * while(next < value.length()) {
12765: *
12766: * if(value.charAt(next)=='[') { cnt++; } next++; }
12767: *
12768: * int total=cnt+howmany;
12769: */
12770: java.lang.String bracks = "";
12771: for (int s = 0; s < howmany; s++) {
12772:
12773: bracks += "[]";
12774: }
12775: value += bracks;
12776: current.setOperandValue(value);
12777:
12778: }
12779:
12780: }
12781:
12782: } else // Again should not happen at all. Returning if this happens
12783: // , so that jdec will not reset a wrong operand's value
12784: {
12785: // Restore Stack
12786: for (int l = reqdops.length - 1; l >= 0; l--) {
12787: Operand op = reqdops[l];
12788: stack.push(op);
12789: }
12790: return;
12791: }
12792:
12793: }
12794:
12795: // This should be final step before returning
12796: if (needtoresetstack) {
12797: // Restore Stack
12798: for (int l = reqdops.length - 1; l >= 0; l--) {
12799: Operand op = reqdops[l];
12800: stack.push(op);
12801: }
12802: }
12803:
12804: }
12805:
12806: private java.lang.String getStringAfterReplacement(int fromwhere,
12807: java.lang.String lookfor, java.lang.String replaceString,
12808: StringBuffer sb, java.lang.String name, boolean skipone,
12809: java.lang.String methodparam) {
12810: int equal = -1;
12811: java.lang.String codeasstring = behaviour.getCodeAsBuffer().toString();
12812: java.lang.String orig = codeasstring;
12813: java.lang.String temp1 = codeasstring.substring(0, fromwhere);
12814: java.lang.String temp2 = replaceString;
12815: java.lang.String temp3 = "";
12816: if (skipone) {
12817: if (methodparam.equalsIgnoreCase("boolean")) {
12818:
12819: if (replaceString.trim().equalsIgnoreCase("0")) {
12820: temp2 = "false";
12821: } else if (replaceString.trim().equalsIgnoreCase("1")) {
12822: temp2 = "true";
12823: } else {
12824:
12825: }
12826:
12827: }
12828: temp3 = codeasstring.substring(fromwhere + lookfor.length() + 1);
12829: } else {
12830: temp3 = codeasstring.substring(fromwhere + lookfor.length());
12831: }
12832:
12833: orig = temp1 + temp2 + temp3;
12834: equal = orig.indexOf("=", orig.indexOf(replaceString + "\t" + name));
12835: sb.append(equal);
12836: return orig;
12837: }
12838:
12839: private boolean isNextInstAStore(byte[] info, int pos) {
12840:
12841: if (isThisInstrStart(behaviour.getInstructionStartPositions(), pos)) {
12842: if (info[pos] == JvmOpCodes.ASTORE) {
12843:
12844: return true;
12845: }
12846: if (info[pos] == JvmOpCodes.ASTORE_0) {
12847: return true;
12848:
12849: }
12850: if (info[pos] == JvmOpCodes.ASTORE_1) {
12851:
12852: return true;
12853: }
12854: if (info[pos] == JvmOpCodes.ASTORE_2) {
12855: return true;
12856:
12857: }
12858: if (info[pos] == JvmOpCodes.ASTORE_3) {
12859: return true;
12860:
12861: }
12862: }
12863: return false;
12864:
12865: }
12866:
12867: private int handleACONSTNULL() {
12868: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
12869: JvmOpCodes.ACONST_NULL);
12870: }
12871:
12872: private int handlesimpleaload(int index) {
12873:
12874: int opcodeval;
12875: switch (index) {
12876: case 0:
12877: opcodeval = JvmOpCodes.ALOAD_0;
12878: break;
12879: case 1:
12880: opcodeval = JvmOpCodes.ALOAD_1;
12881: break;
12882: case 2:
12883: opcodeval = JvmOpCodes.ALOAD_2;
12884: break;
12885: default:
12886: opcodeval = JvmOpCodes.ALOAD_3;
12887: break;
12888: }
12889: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
12890: opcodeval);
12891:
12892: }
12893:
12894: private int handleARRAYLENGTHCase() {
12895: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
12896: JvmOpCodes.ARRAYLENGTH);
12897: }
12898:
12899: private int handleARETURNCase(int i, HashMap returnsAtI) {
12900: return execute(InstrConstants.BRANCH_INSTR_TYPE, null,
12901: JvmOpCodes.ARETURN);
12902: }
12903:
12904: private int sipushvalue = -1;
12905:
12906: private void handleSIPUSH(byte[] info) {
12907: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
12908: JvmOpCodes.SIPUSH);
12909: }
12910:
12911: private int handleBIPush(byte[] info) {
12912: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
12913: JvmOpCodes.BIPUSH);
12914:
12915: }
12916:
12917: private void handleSASTORE() {
12918: execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.INT,
12919: JvmOpCodes.SASTORE);
12920: }
12921:
12922: private void handleSALOAD() {
12923: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
12924: JvmOpCodes.SALOAD);
12925: }
12926:
12927: private void handleSimpleReturn() {
12928: execute(InstrConstants.BRANCH_INSTR_TYPE, null, JvmOpCodes.RETURN);
12929:
12930: }
12931:
12932: private void handleNEWARRAYCase(byte[] info) {
12933: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
12934: JvmOpCodes.NEWARRAY);
12935:
12936: }
12937:
12938: private boolean skipAASTORE(int pos) {
12939: for (int z = 0; z < GlobalVariableStore.getSkipaastores().size(); z++) {
12940:
12941: if (((Integer) GlobalVariableStore.getSkipaastores().get(z))
12942: .intValue() == pos) {
12943: return true;
12944: }
12945: }
12946: return false;
12947: }
12948:
12949: private int handleAASTORECase() {
12950:
12951: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.OBJECT,
12952: JvmOpCodes.AASTORE);
12953: }
12954:
12955: // Change
12956: private int handleANEWARRAYCase(byte[] info) {
12957:
12958: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
12959: JvmOpCodes.ANEWARRAY);
12960: }
12961:
12962: private void checkForImport(java.lang.String input, StringBuffer sb) {
12963: DecompilerHelper.checkForImport(input, sb);
12964: }
12965:
12966: // Duplicate Method
12967: private int getPrevStartCodePos(byte[] info, int i) {
12968: int current = i;
12969: ArrayList allstarts = behaviour.getInstructionStartPositions();
12970: int z;
12971: for (z = current - 1; z >= 0; z--) {
12972:
12973: boolean ok = isThisInstrStart(allstarts, z);
12974: if (ok) {
12975: return z;
12976: }
12977: }
12978: return z;
12979:
12980: }
12981:
12982: private boolean isStoreInst(int index, byte[] info, StringBuffer varindex,
12983: StringBuffer t) {
12984:
12985: boolean b = isThisInstrStart(behaviour.getInstructionStartPositions(),
12986: index);
12987: if (b == false)
12988: return false;
12989: switch (info[index]) {
12990: case JvmOpCodes.AASTORE:
12991: case JvmOpCodes.BASTORE:
12992: case JvmOpCodes.CASTORE:
12993: case JvmOpCodes.DASTORE:
12994: case JvmOpCodes.FASTORE:
12995: case JvmOpCodes.IASTORE:
12996: case JvmOpCodes.LASTORE:
12997: case JvmOpCodes.SASTORE:
12998: varindex.append("-1");
12999: return true;
13000:
13001: case JvmOpCodes.ASTORE:
13002: varindex.append(info[(index + 1)]);
13003: t.append("java.lang.Object");
13004: return true;
13005: case JvmOpCodes.DSTORE:
13006: varindex.append(info[(index + 1)]);
13007: t.append("double");
13008: return true;
13009: case JvmOpCodes.FSTORE:
13010: varindex.append(info[(index + 1)]);
13011: t.append("float");
13012: return true;
13013: case JvmOpCodes.ISTORE:
13014: varindex.append(info[(index + 1)]);
13015: t.append("int");
13016: return true;
13017: case JvmOpCodes.LSTORE:
13018: varindex.append(info[(index + 1)]);
13019: t.append("long");
13020: return true;
13021:
13022: case JvmOpCodes.ASTORE_0:
13023: varindex.append("0");
13024: t.append("java.lang.Object");
13025: return true;
13026:
13027: case JvmOpCodes.DSTORE_0:
13028: varindex.append("0");
13029: t.append("double");
13030: return true;
13031: case JvmOpCodes.FSTORE_0:
13032: varindex.append("0");
13033: t.append("float");
13034: return true;
13035: case JvmOpCodes.ISTORE_0:
13036: varindex.append("0");
13037: t.append("int");
13038: return true;
13039: case JvmOpCodes.LSTORE_0:
13040: varindex.append("0");
13041: t.append("long");
13042: return true;
13043:
13044: case JvmOpCodes.ASTORE_1:
13045: varindex.append("1");
13046: t.append("java.lang.Object");
13047: return true;
13048: case JvmOpCodes.DSTORE_1:
13049: varindex.append("1");
13050: t.append("double");
13051: return true;
13052: case JvmOpCodes.FSTORE_1:
13053: varindex.append("1");
13054: t.append("float");
13055: return true;
13056: case JvmOpCodes.ISTORE_1:
13057: varindex.append("1");
13058: t.append("int");
13059: return true;
13060: case JvmOpCodes.LSTORE_1:
13061: varindex.append("1");
13062: t.append("long");
13063: return true;
13064:
13065: case JvmOpCodes.ASTORE_2:
13066: varindex.append("2");
13067: t.append("java.lang.Object");
13068: return true;
13069: case JvmOpCodes.DSTORE_2:
13070: varindex.append("2");
13071: t.append("double");
13072: return true;
13073: case JvmOpCodes.FSTORE_2:
13074: varindex.append("2");
13075: t.append("float");
13076: return true;
13077: case JvmOpCodes.ISTORE_2:
13078: varindex.append("2");
13079: t.append("int");
13080: return true;
13081: case JvmOpCodes.LSTORE_2:
13082: varindex.append("2");
13083: t.append("long");
13084: return true;
13085:
13086: case JvmOpCodes.ASTORE_3:
13087: varindex.append("3");
13088: t.append("java.lang.Object");
13089: return true;
13090: case JvmOpCodes.DSTORE_3:
13091: varindex.append("3");
13092: t.append("double");
13093: return true;
13094: case JvmOpCodes.FSTORE_3:
13095: varindex.append("3");
13096: t.append("float");
13097: return true;
13098: case JvmOpCodes.ISTORE_3:
13099: varindex.append("3");
13100: t.append("int");
13101: return true;
13102: case JvmOpCodes.LSTORE_3:
13103: varindex.append("3");
13104: t.append("long");
13105: return true;
13106:
13107: default:
13108: return false;
13109:
13110: }
13111:
13112: }
13113:
13114: private int handleComplexAStore(byte[] info, int i) {
13115: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.OBJECT,
13116: JvmOpCodes.ASTORE);
13117: }
13118:
13119: private boolean isMethodRetBoolean(Behaviour b) {
13120:
13121: java.lang.String type = b.getReturnType();
13122: if (type.equals("boolean"))
13123: return true;
13124: return false;
13125:
13126: }
13127:
13128: private int handleSimpleASTORECase(int i, int index) {
13129: int opcodeval;
13130: switch (index) {
13131: case 0:
13132: opcodeval = JvmOpCodes.ASTORE_0;
13133: break;
13134:
13135: case 1:
13136: opcodeval = JvmOpCodes.ASTORE_1;
13137: break;
13138:
13139: case 2:
13140: opcodeval = JvmOpCodes.ASTORE_2;
13141: break;
13142:
13143: default:
13144: opcodeval = JvmOpCodes.ASTORE_3;
13145: break;
13146: }
13147: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.OBJECT,
13148: opcodeval);
13149: }
13150:
13151: private boolean isThisInstASTOREInst(byte[] info, int pos, StringBuffer sb) {
13152:
13153: if (isThisInstrStart(behaviour.getInstructionStartPositions(), pos)) {
13154: if (info[pos] == JvmOpCodes.ASTORE) {
13155: sb.append(info[(pos + 1)]);
13156: return true;
13157: }
13158: if (info[pos] == JvmOpCodes.ASTORE_0) {
13159: sb.append(0);
13160: return true;
13161:
13162: }
13163: if (info[pos] == JvmOpCodes.ASTORE_1) {
13164: sb.append(1);
13165: return true;
13166: }
13167: if (info[pos] == JvmOpCodes.ASTORE_2) {
13168: sb.append(2);
13169: return true;
13170:
13171: }
13172: if (info[pos] == JvmOpCodes.ASTORE_3) {
13173: sb.append(3);
13174: return true;
13175:
13176: }
13177: }
13178: return false;
13179:
13180: }
13181:
13182: private boolean isPrevInstALOADInst(byte[] info, int pos, StringBuffer s) {
13183: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
13184: (pos - 1))) {
13185:
13186: switch (info[(pos - 1)]) {
13187:
13188: case JvmOpCodes.ALOAD_0:
13189: s.append(0);
13190: return true;
13191:
13192: case JvmOpCodes.ALOAD_1:
13193: s.append(1);
13194: return true;
13195:
13196: case JvmOpCodes.ALOAD_2:
13197: s.append(2);
13198: return true;
13199:
13200: case JvmOpCodes.ALOAD_3:
13201: s.append(3);
13202: return true;
13203:
13204: }
13205:
13206: }
13207: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
13208: (pos - 2))) {
13209:
13210: switch (info[(pos - 2)]) {
13211: case JvmOpCodes.ALOAD:
13212: s.append(info[(pos - 2 + 1)]);
13213: return true;
13214:
13215: }
13216: }
13217: return false;
13218: }
13219:
13220: private boolean checkForMatchingLoopAgain(ArrayList loops, int start,
13221: StringBuffer S) {
13222: boolean b = false;
13223: if (loops == null || loops.size() == 0)
13224: return b;
13225: else {
13226: for (int s = 0; s < loops.size(); s++) {
13227: Loop l = (Loop) loops.get(s);
13228: int loopstart = l.getStartIndex();
13229: if (loopstart == start) {
13230: b = true;
13231: S.append(l.getEndIndex());
13232: return b;
13233: }
13234:
13235: }
13236: }
13237: return b;
13238: }
13239:
13240: private int getClosestLoopEndForThisIf(int s, ArrayList loops, byte[] info) {
13241:
13242: int end = -1;
13243: if (loops == null || loops.size() == 0)
13244: return end;
13245: int gotos = s + 3;
13246: if (info[gotos] == JvmOpCodes.GOTO
13247: && isThisInstrStart(behaviour.getInstructionStartPositions(),
13248: gotos)) {
13249: int gotoj = getJumpAddress(info, gotos);
13250: int starts[] = new int[loops.size()];
13251: for (int z = 0; z < loops.size(); z++) {
13252: starts[z] = ((Loop) loops.get(z)).getEndIndex();
13253: }
13254: Arrays.sort(starts);
13255: int reqdloopend = -1;
13256: for (int x = 0; x < starts.length; x++) {
13257: int cur = starts[x];
13258: if (gotoj > cur) {
13259: reqdloopend = cur;
13260: break;
13261: }
13262: }
13263:
13264: if (reqdloopend != -1) {
13265: int lstart = getLoopStartForEnd(reqdloopend, loops);
13266: if (lstart < s) {
13267: return reqdloopend;
13268: }
13269: } else {
13270: return -1;
13271: }
13272:
13273: }
13274:
13275: return end;
13276: }
13277:
13278: private int checkElseCloseWRTAnyParentLoop(IFBlock ifs, int gotostart,
13279: byte[] info) {
13280:
13281: ArrayList allloops = behaviour.getBehaviourLoops();
13282: if (allloops == null || allloops.size() == 0)
13283: return -1;
13284: int gotojump = getJumpAddress(info, gotostart);
13285: Object[] sortedLoops = sortLoops(allloops);
13286:
13287: for (int k = 0; k < sortedLoops.length; k++) {
13288: Loop cur = (Loop) sortedLoops[k];
13289: if (cur.getStartIndex() == gotojump) {
13290: int parentLoopStart = getParentLoopStartForIf(sortedLoops, ifs
13291: .getIfStart());
13292: if (parentLoopStart == gotojump) {
13293: int loopend = getloopEndForStart(allloops, parentLoopStart);
13294: return loopend;
13295:
13296: }
13297: }
13298: }
13299: return -1;
13300: }
13301:
13302: private boolean checkForSkipWRTbooleanShortcutAssignFound(int i) {
13303:
13304: Set set = GlobalVariableStore.getSkipWRTbooleanShortcutAssignFound()
13305: .entrySet();
13306: boolean remove = false;
13307: Map.Entry toremove = null;
13308: for (Iterator it = set.iterator(); it.hasNext();) {
13309: Map.Entry elem = (Map.Entry) it.next();
13310: Integer in1 = (Integer) elem.getKey(); // inclusive
13311: Integer in2 = (Integer) elem.getValue(); // exclusive
13312: if (i >= in1.intValue() && i < in2.intValue()) {
13313: return true;
13314: }
13315: if (i == in2.intValue()) {
13316: remove = true;
13317: toremove = elem;
13318: }
13319: }
13320: if (remove) {
13321: Object rkey = null;
13322: for (Iterator it = set.iterator(); it.hasNext();) {
13323: Map.Entry elem = (Map.Entry) it.next();
13324: Integer in1 = (Integer) elem.getKey();
13325: Integer in2 = (Integer) elem.getValue();
13326: if (in2.intValue() == i) {
13327: rkey = in1;
13328: break;
13329: }
13330: }
13331: if (rkey != null) {
13332: GlobalVariableStore.getSkipWRTbooleanShortcutAssignFound()
13333: .remove(rkey);
13334: }
13335:
13336: }
13337: return false;
13338: }
13339:
13340: private boolean doesBooleanAssignFoundExist(int currentForIndex) {
13341: Set set = GlobalVariableStore.getBooleanAssignMap().entrySet();
13342: for (Iterator it = set.iterator(); it.hasNext();) {
13343: Map.Entry elem = (Map.Entry) it.next();
13344: Integer in1 = (Integer) elem.getKey();
13345: Integer in2 = (Integer) elem.getValue();
13346: if (currentForIndex >= in1.intValue()
13347: && currentForIndex < in2.intValue()) {
13348: return true;
13349: }
13350: }
13351: return false;
13352: }
13353:
13354: private boolean checkForShortCutIfBooleanAssignment(IFBlock ifst,
13355: byte[] info, StringBuffer end, StringBuffer msc) {
13356:
13357: int ifbyend = ifst.getIfCloseFromByteCode();
13358: ArrayList starts = behaviour.getInstructionStartPositions();
13359: boolean islastif = false;
13360: // int inital=ifbyend
13361: while (ifbyend < info.length) {
13362: if (isThisInstrStart(starts, ifbyend)
13363: && info[ifbyend] == JvmOpCodes.ICONST_1) {
13364: int next = ifbyend + 1;
13365: if (isThisInstrStart(starts, next)
13366: && info[next] == JvmOpCodes.GOTO) {
13367: next = next + 3;
13368: if (isThisInstrStart(starts, next)
13369: && info[next] == JvmOpCodes.ICONST_0) {
13370: next = next + 1;
13371: StringBuffer sb = new StringBuffer("");
13372:
13373: boolean anyif = checkForIfInRange(info,
13374: currentForIndex + 3, ifbyend,
13375: new StringBuffer(), starts);
13376: if (!anyif)
13377: return false;
13378: if (isThisInstrStart(starts, next)
13379: && (isThisInstructionIStoreInst(info, next, sb)
13380: || (info[next] == JvmOpCodes.PUTFIELD) || (info[next] == JvmOpCodes.PUTSTATIC))) {
13381:
13382: try {
13383: /*
13384: * int i=Integer.parseInt(sb.toString());
13385: * boolean complex=false; if(i!=0 && i!=1 &&
13386: * i!=2 && i!=3) complex=true; LocalVariable
13387: * local=getLocalVariable(i,"store","int",complex,next);
13388: */
13389: // if(local!=null &&
13390: // local.getDataType().equalsIgnoreCase("boolean")
13391: // ) {
13392: end.append("" + next);
13393: GlobalVariableStore
13394: .getSkipWRTbooleanShortcutAssignFound()
13395: .put(new Integer(ifbyend),
13396: new Integer(next));
13397: return true;
13398: // }
13399: } catch (Exception exp) {
13400: return false;
13401: }
13402:
13403: } else {
13404: if (isThisInstrStart(starts, next)
13405: && (!isThisInstructionIStoreInst(info,
13406: next, sb)
13407: && !(info[next] == JvmOpCodes.PUTFIELD) && !(info[next] == JvmOpCodes.PUTSTATIC))) {
13408: end.append("" + next);
13409: GlobalVariableStore
13410: .getSkipWRTbooleanShortcutAssignFound()
13411: .put(new Integer(ifbyend),
13412: new Integer(next));
13413: msc.append("true");
13414: return true;
13415: }
13416:
13417: return false;
13418: }
13419:
13420: } else {
13421: return false;
13422: }
13423:
13424: } else {
13425: return false;
13426: }
13427: } else if (info[ifbyend] == JvmOpCodes.ICONST_0) {
13428:
13429: int prev = ifbyend - 3;
13430: if (isThisInstrStart(starts, prev)
13431: && info[prev] == JvmOpCodes.GOTO) {
13432: prev = prev - 1;
13433: if (isThisInstrStart(starts, prev)
13434: && info[prev] == JvmOpCodes.ICONST_1) {
13435: int from = prev;
13436: int next = ifbyend + 1;
13437: StringBuffer sb = new StringBuffer("");
13438: boolean anyif = checkForIfInRange(info,
13439: currentForIndex + 3, prev, new StringBuffer(),
13440: starts);
13441: if (!anyif)
13442: return false;
13443: if (isThisInstrStart(starts, next)
13444: && (isThisInstructionIStoreInst(info, next, sb)
13445: || (info[next] == JvmOpCodes.PUTFIELD) || (info[next] == JvmOpCodes.PUTSTATIC))) {
13446: try {
13447: /*
13448: * int i=Integer.parseInt(sb.toString());
13449: * boolean complex=false; if(i!=0 && i!=1 &&
13450: * i!=2 && i!=3) complex=true; LocalVariable
13451: * local=getLocalVariable(i,"store","int",complex,next);
13452: * //if(local!=null &&
13453: * local.getDataType().equalsIgnoreCase("boolean") ) {
13454: */
13455: GlobalVariableStore
13456: .getSkipWRTbooleanShortcutAssignFound()
13457: .put(new Integer(from),
13458: new Integer(next));
13459: end.append("" + next);
13460: return true;
13461: // }
13462: } catch (Exception exp) {
13463: return false;
13464: }
13465: } else {
13466: if (isThisInstrStart(starts, next)
13467: && (!isThisInstructionIStoreInst(info,
13468: next, sb)
13469: && !(info[next] == JvmOpCodes.PUTFIELD) && !(info[next] == JvmOpCodes.PUTSTATIC))) {
13470: GlobalVariableStore
13471: .getSkipWRTbooleanShortcutAssignFound()
13472: .put(new Integer(from),
13473: new Integer(next));
13474: end.append("" + next);
13475: msc.append("true");
13476: return true;
13477: }
13478: return false;
13479: }
13480: } else {
13481: return false;
13482: }
13483: } else {
13484: return false;
13485: }
13486: } else {
13487: int cur = ifbyend;
13488: boolean found = false;
13489: int s1 = cur - 1;
13490: int s2 = ifst.getIfStart();
13491: for (; s1 > s2; s1--) {
13492: boolean isB = isThisInstrStart(starts, s1);
13493: if (isB) {
13494: boolean isIF = isInstructionIF(info[s1]);
13495: if (isIF) {
13496: islastif = sanalyser.isLastIfInChain(s1);
13497: break;
13498: }
13499: }
13500: }
13501: if (islastif) {
13502: return false;
13503: }
13504: while (cur < info.length) {
13505: boolean isst = isThisInstrStart(starts, cur);
13506: if (isst) {
13507: boolean isif = isInstructionIF(info[cur]);
13508: if (isif) {
13509: ifbyend = getJumpAddress(info, cur);
13510: if (ifbyend < cur)
13511: return false; // to avoid infinite loop
13512: found = true;
13513: break;
13514: }
13515: }
13516: cur++;
13517:
13518: }
13519: if (found) {
13520:
13521: } else {
13522: return false;
13523: }
13524: }
13525: }
13526: return false;
13527: }
13528:
13529: public boolean addCodeStatementWRTShortcutOR(IFBlock ifst,
13530: java.lang.String s, boolean print, java.lang.String ifw,
13531: boolean last, java.lang.String alt) {
13532:
13533: if (sanalyser == null)
13534: return true;
13535: byte[] info = behaviour.getCode();
13536: boolean reverse = false;
13537: ArrayList starts = behaviour.getInstructionStartPositions();
13538: // if(!print)return true;
13539: boolean add = true;
13540: int current = currentForIndex;
13541: byte[] code = behaviour.getCode();
13542: java.lang.String str = "\nif(";
13543: if (ifw.equals("while")) {
13544: str = "\nwhile(";
13545: }
13546: java.lang.String string = "";
13547: /*
13548: * if(last){ if(isInstAnyCMPInst(code,current-1)==false) { string=alt; }
13549: * else string=s; } else // belurs NOTE: Need to revert to alt if it is
13550: * shortcut and '&&' NOT shortcut or '||' { int
13551: * byjump=ifst.getIfCloseFromByteCode(); byjump=byjump-3; boolean
13552: * isstart=isThisInstrStart(starts,byjump);
13553: *
13554: * if(isstart) { boolean isif=isInstructionIF(info[byjump]); if(isif) {
13555: * int from=ifst.getIfStart()+3; int to=byjump; for(int
13556: * findex=from;findex < to;findex++) {
13557: * isstart=isThisInstrStart(starts,findex); if(isstart) {
13558: * isif=isInstructionIF(info[findex]); if(isif) { reverse=false; break; } } } } }
13559: * if(!reverse) string=s; else alt=alt; }
13560: */
13561:
13562: // Note: sbelur
13563: // Check for this type first
13564: // boolean b=(i > j) || (or &&) (k==2) type
13565: // Need to check this to as else was not coming in earlier
13566: // implementation
13567: // Shortcutchain
13568: // somechain=sanalyser.getShortcutChainGivenIf(currentForIndex);
13569: boolean booleanAssignFoundProcessed = doesBooleanAssignFoundExist(currentForIndex);
13570: if (booleanAssignFoundProcessed == false) {
13571: StringBuffer end = new StringBuffer();
13572: GlobalVariableStore.setMethodsc(new StringBuffer(""));
13573: GlobalVariableStore
13574: .setBooleanAssignFound(checkForShortCutIfBooleanAssignment(
13575: ifst, info, end, GlobalVariableStore.getMethodsc()));
13576: if (GlobalVariableStore.isBooleanAssignFound()) {
13577: GlobalVariableStore.getBooleanAssignMap().put(
13578: new Integer(currentForIndex),
13579: new Integer(end.toString()));
13580: }
13581: }
13582:
13583: boolean andpresent = false;
13584: boolean stringset = false;
13585: /*
13586: * if(booleanAssignFound){
13587: * IfPartOfShortCutChain=true;encounteredAndOrComp=true; }
13588: */
13589: boolean concatthis if = GlobalVariableStore.isIfPartOfShortCutChain();
13590: // if(last) {
13591: // if(IfPartOfShortCutChain) {
13592:
13593: int ifend = ifst.getIfCloseFromByteCode();
13594: int ifstart = ifst.getIfStart();
13595: int nextstart = ifstart + 3;
13596: int pr = ifend - 3;
13597: boolean isstart = isThisInstrStart(starts, pr);
13598: boolean isif;
13599: boolean lookforand = false;
13600: /*
13601: * if(isstart) { isif=isInstructionIF(info[pr]); if(isif==false) {
13602: * lookforand=true; } }
13603: */
13604: /*
13605: * if(lookforand) { int strt=nextstart; for(;nextstart < ifend
13606: * ;nextstart++) { isstart=isThisInstrStart(starts,nextstart);
13607: * if(isstart) { isif=isInstructionIF(info[nextstart]); if(isif) { int
13608: * jump=getJumpAddress(info,nextstart); if(jump==ifend) {
13609: * IfPartOfShortCutChain=true; andpresent=true; break; } else {
13610: * IfPartOfShortCutChain=true; andpresent=false; break; } } else {
13611: * if(info[nextstart]==JvmOpCodes.GOTO){ System.out.println("nextstart
13612: * found"+nextstart+" ifend"+ifend+"start"+strt); andpresent=false;
13613: * break; } } } } } else { StringBuffer pos=new StringBuffer();
13614: * //boolean
13615: * otherif=checkForAnyIFWithDifferentIndex(info,currentForIndex+3,pr+3,pos,starts);
13616: * boolean
13617: * otherif=checkForIfInRange(info,currentForIndex+3,pr,pos,starts);
13618: * if(!otherif) { int nextj=getJumpAddress(info,pr)-3; boolean
13619: * nextjisstart=isThisInstrStart(starts,nextj); boolean nextjisif=false;
13620: * if(nextjisstart) { nextjisif=isInstructionIF(info[nextj]); boolean
13621: * skip=false; if(nextj==currentForIndex) { skip=true; } if(!skip){
13622: * otherif=checkForIfInRange(info,pr+3,nextj,new StringBuffer(),starts);
13623: * if(nextjisif && !otherif) { IfPartOfShortCutChain=true;
13624: * andpresent=true; stringset=true; } else { IfPartOfShortCutChain=true;
13625: * andpresent=false; stringset=false; } } else {
13626: * IfPartOfShortCutChain=false; andpresent=false; stringset=false; } } }
13627: * else { boolean check=true; int nextifpos=-1; try {
13628: * nextifpos=Integer.parseInt(pos.toString()); }
13629: * catch(NumberFormatException ne){ check=false; }
13630: *
13631: * if(check==false){ IfPartOfShortCutChain=true; andpresent=true;
13632: * stringset=true; } else { int
13633: * currentjump=getJumpAddress(info,currentForIndex); int
13634: * nextifjump=getJumpAddress(info,nextifpos);
13635: * if(nextifjump!=currentjump){ IfPartOfShortCutChain=true;
13636: * andpresent=true; stringset=true; } else { IfPartOfShortCutChain=true;
13637: * andpresent=false; stringset=false; } } } }
13638: */
13639:
13640: // }
13641: // }
13642: /*
13643: * if(last) { if(andpresent) string = string; // TODO: Revisit this else
13644: * string = string; } else string = string;
13645: */
13646:
13647: java.lang.String connector = sanalyser.getConnector(ifst.getIfStart());
13648: if (!connector.equals(""))
13649: connector = " " + connector;
13650:
13651: if (connector != null && connector.trim().equals(ShortcutAnalyser.AND)) {
13652:
13653: boolean reset = false;
13654: /**
13655: * 1. Get the next if 2. Get all ifs before this if 3. Check if some
13656: * before if is closing in between this if start && next if start 4.
13657: * if 3 returns true then this if needs to be made a last if. 5. Get
13658: * the chain for this if 6. Nullify the next chain for this chain.
13659: * 7. Nullify the previous chain for next if.
13660: */
13661:
13662: // Get Next If
13663: int nextifstart = getNextIfStart(ifst.getIfStart(), info);
13664: if (nextifstart != -1) {
13665: // 2 and 3
13666: boolean bl = checkForIfCloseInRange(ifst.getIfStart(),
13667: nextifstart);
13668: if (bl) {
13669:
13670: Shortcutstore store = sanalyser
13671: .getShortCutStoreGivenIfStart(ifst.getIfStart());
13672: if (store != null) {
13673: // Point 4
13674: store.setConnectortype("");
13675: store.makeStoreInEffective(true);
13676: // point 5
13677: Shortcutchain chain1 = sanalyser
13678: .getShortcutChainGivenIf(ifst.getIfStart());
13679: Shortcutchain chain2 = sanalyser
13680: .getShortcutChainGivenIf(nextifstart);
13681:
13682: // Point 6 and 7
13683: chain1.setNextChain(null);
13684: chain2.setPrevChain(null);
13685:
13686: reset = true;
13687: }
13688:
13689: }
13690:
13691: }
13692:
13693: andpresent = true;
13694: if (reset)
13695: andpresent = false;
13696: } else if (connector != null
13697: && connector.trim().equals(ShortcutAnalyser.OR)) {
13698: andpresent = false;
13699: }
13700: if (andpresent)
13701: reverse = true;
13702: else
13703: reverse = false;
13704:
13705: if (!reverse) {
13706: reverse = sanalyser.checkToReverseCondition(ifst.getIfStart());
13707: }
13708: last = sanalyser.isLastIfInChain(ifst.getIfStart());
13709: if (last)
13710: reverse = true;
13711: if (!reverse)
13712: string = s;
13713: else
13714: string = alt;
13715:
13716: boolean begin = sanalyser.beginGroup(ifst.getIfStart());
13717: if (begin) {
13718: string = " (" + string;
13719: }
13720: boolean end = sanalyser.endGroup(ifst.getIfStart());
13721: if (end) {
13722: string = string + ") ";
13723: }
13724:
13725: Shortcutchain someChain = sanalyser
13726: .getShortcutChainGivenIf(currentForIndex);
13727: if (GlobalVariableStore.isIfPartOfShortCutChain() == false
13728: && connector != null
13729: && !connector.trim().equals(ShortcutAnalyser.NONE)) { // Prev
13730: // ->
13731: // encounteredOrComp
13732:
13733: int jump = getJumpAddress(code, current);
13734: int i = jump - 3;
13735: if ((jump > current
13736: && i > 0
13737: && i != current
13738: && isThisInstrStart(behaviour
13739: .getInstructionStartPositions(), i) && isInstructionIF(code[i]))
13740: || (GlobalVariableStore.isBooleanAssignFound())) {
13741:
13742: // boolean oktoopen=addOpenBracket(info,ifst);
13743: int jumpForNextIf = getJumpAddress(code, i);
13744: // if(jumpForNextIf > i) {
13745: // encounteredOrComp=true;
13746: if (!reverse) {
13747:
13748: GlobalVariableStore.setInitialBracketAdded(false);
13749: if (!GlobalVariableStore.isBooleanAssignFound())
13750: behaviour.appendToBuffer(Util
13751: .formatDecompiledStatement(str + string
13752: + " || "));
13753: else {
13754: Operand opt = createOperand("(" + string + " || ");
13755: opStack.push(opt);
13756: }
13757:
13758: } else {
13759:
13760: GlobalVariableStore.setInitialBracketAdded(false);
13761: if (!GlobalVariableStore.isBooleanAssignFound())
13762: behaviour.appendToBuffer(Util
13763: .formatDecompiledStatement(str + string
13764: + " && "));
13765: else {
13766: Operand opt = createOperand("(" + string + " && ");
13767: opStack.push(opt);
13768: }
13769:
13770: }
13771: ifst.setDonotclose(true);
13772: GlobalVariableStore.setIfPartOfShortCutChain(true);
13773: GlobalVariableStore.setEncounteredAndOrComp(true);
13774: return false;
13775: // }
13776: /*
13777: * else return true;
13778: */
13779: } else if (jump < current) {
13780: // boolean oktoopen=addOpenBracket(info,ifst);
13781: int close = ifst.getIfCloseLineNumber();
13782: int x = close - 3;
13783: if (x > 0
13784: && isThisInstrStart(behaviour
13785: .getInstructionStartPositions(), x)
13786: && isInstructionIF(code[x])) {
13787: // encounteredOrComp=true;
13788: if (!reverse) {
13789:
13790: GlobalVariableStore.setInitialBracketAdded(false);
13791: if (!GlobalVariableStore.isBooleanAssignFound())
13792: behaviour.appendToBuffer(Util
13793: .formatDecompiledStatement(str + string
13794: + " || "));
13795: else {
13796: Operand opt = createOperand("(" + string + " || ");
13797: opStack.push(opt);
13798: }
13799:
13800: } else {
13801:
13802: GlobalVariableStore.setInitialBracketAdded(false);
13803: if (!GlobalVariableStore.isBooleanAssignFound())
13804: behaviour.appendToBuffer(Util
13805: .formatDecompiledStatement(str + string
13806: + " && "));
13807: else {
13808: Operand opt = createOperand("(" + string + " && ");
13809: opStack.push(opt);
13810:
13811: }
13812:
13813: }
13814: ifst.setDonotclose(true);
13815: GlobalVariableStore.setIfPartOfShortCutChain(true);
13816: GlobalVariableStore.setEncounteredAndOrComp(true);
13817: return false;
13818: }
13819: /*
13820: * else { return true; }
13821: */
13822: }
13823: /*
13824: * else { return true; }
13825: */
13826: // Previous --> if(last && concatthisif && andpresent) {
13827: else if (andpresent) {
13828: // StringBuffer mif=new StringBuffer();
13829: // boolean
13830: // close=checkClosingBracketRuleForShortCutOp(currentForIndex,info,ifst.getIfCloseFromByteCode(),ifst.getIfStart(),mif);
13831:
13832: // Object
13833: // ob=openCloseBracketMap.get(""+ifst.getIfCloseFromByteCode());
13834: if (!GlobalVariableStore.isBooleanAssignFound()) {
13835: behaviour.appendToBuffer(Util.formatDecompiledStatement(str
13836: + string + " && "));
13837: } else {
13838:
13839: Operand opt = createOperand("(" + string + " && ");
13840: opStack.push(opt);
13841:
13842: // Operand opt=opStack.peekTopOfStack();
13843: // opt.setOperandValue(opt.getOperandValue()+string+" && ");
13844:
13845: }
13846:
13847: ifst.setDonotclose(true);
13848: GlobalVariableStore.setIfPartOfShortCutChain(true);
13849: GlobalVariableStore.setEncounteredAndOrComp(true);
13850: return false;
13851: }
13852: // Seems to be wrong to put { in If block
13853: /*
13854: * if(last && concatthisif && !andpresent) { // TODO: there might be
13855: * close bracket issue here. // May be need to check whether the
13856: * additional close was for the final close before start of {
13857: *
13858: * Util.forceStartSpace=false; StringBuffer mif=new StringBuffer();
13859: * //boolean
13860: * close=checkClosingBracketRuleForShortCutOp(currentForIndex,info,ifst.getIfCloseFromByteCode(),ifst.getIfStart(),mif);
13861: * if(!booleanAssignFound) codeStatements+=string+")"; // Adding
13862: * close anyway else { Operand opt=opStack.peekTopOfStack();
13863: * opt.setOperandValue(opt.getOperandValue()+string+")"); // Adding
13864: * close anyway ifst.setDonotclose(true); }
13865: *
13866: * Util.forceStartSpace=true; Util.forceTrimString=false;
13867: * Util.forceNewLine=false; if(!booleanAssignFound)
13868: * codeStatements+=Util.formatDecompiledStatement("\t\n{\n"); else {
13869: * Operand opt=opStack.peekTopOfStack();
13870: * opt.setOperandValue(opt.getOperandValue()+";\n");
13871: * ifst.setDonotclose(true); }
13872: *
13873: * Util.forceNewLine=true; Util.forceTrimString=true;
13874: * IfPartOfShortCutChain=false; andpresent=false;
13875: * concatthisif=false; return false; }
13876: */
13877:
13878: return true;
13879:
13880: } else if (GlobalVariableStore.isIfPartOfShortCutChain() == true
13881: && (connector != null
13882: && !connector.trim().equals(ShortcutAnalyser.NONE) || (sanalyser
13883: .isLastIfInChain(currentForIndex)
13884: && connector != null && connector.trim().equals(
13885: ShortcutAnalyser.NONE)))) {// Continue
13886:
13887: // codes
13888: StringBuffer mif = new StringBuffer();
13889: /*
13890: * boolean
13891: * closeb=checkClosingBracketRuleForShortCutOp(currentForIndex,info,ifst.getIfCloseFromByteCode(),ifst.getIfStart(),mif);
13892: * if(closeb==false) { boolean
13893: * oktoopen=addOpenBracket(info,ifst,closeb,mif); if(oktoopen) {
13894: * if(!booleanAssignFound) codeStatements+="("; else { Operand
13895: * opt=opStack.peekTopOfStack();
13896: * opt.setOperandValue(opt.getOperandValue()+"("); } } } else {
13897: * Object
13898: * ob=openCloseBracketMap.get(""+ifst.getIfCloseFromByteCode());
13899: * if(ob!=null) string=string+") "; else string=string; }
13900: */
13901:
13902: if (!GlobalVariableStore.isBooleanAssignFound())
13903: behaviour.appendToBuffer(string);
13904: else {
13905: Operand opt = opStack.peekTopOfStack();
13906: if (opt != null) // Added check while testing
13907: // BigInteger.class [makePositive]
13908: opt.setOperandValue(opt.getOperandValue() + string);
13909: else
13910: behaviour.appendToBuffer(string);
13911: }
13912: int jump = getJumpAddress(code, current);
13913: int i = jump - 3;
13914:
13915: if (i != current
13916: && jump > current
13917: && i > 0
13918: && isThisInstrStart(behaviour
13919: .getInstructionStartPositions(), i)
13920: && isInstructionIF(code[i])) {
13921: // IfPartOfShortCutChain=true;
13922: // codes
13923: if (!GlobalVariableStore.isBooleanAssignFound()) {
13924: if (!reverse)
13925: behaviour.appendToBuffer(" || ");
13926: else
13927: behaviour.appendToBuffer(" && ");
13928: } else {
13929: if (!reverse) {
13930: Operand opt = opStack.peekTopOfStack();
13931: opt.setOperandValue(opt.getOperandValue() + " || ");
13932: } else {
13933: Operand opt = opStack.peekTopOfStack();
13934: opt.setOperandValue(opt.getOperandValue() + " && ");
13935: }
13936: }
13937: ifst.setDonotclose(true);
13938:
13939: GlobalVariableStore.setIfPartOfShortCutChain(true);
13940: GlobalVariableStore.setEncounteredAndOrComp(true);
13941: return false;
13942: } else if (jump < current) { // BigInteger
13943: int close = ifst.getIfCloseLineNumber();
13944: int x = close - 3;
13945: if (connector != null
13946: && !connector.trim().equals(ShortcutAnalyser.NONE)
13947: && x > 0
13948: && isThisInstrStart(behaviour
13949: .getInstructionStartPositions(), x)
13950: && isInstructionIF(code[x])) {
13951: // encounteredOrComp=true;
13952: // codes
13953: if (!GlobalVariableStore.isBooleanAssignFound()) {
13954: if (!reverse)
13955: behaviour.appendToBuffer(" || ");
13956: else
13957: behaviour.appendToBuffer(" && ");
13958:
13959: } else {
13960: if (!reverse) {
13961: Operand opt = opStack.peekTopOfStack();
13962: opt.setOperandValue(opt.getOperandValue() + " || ");
13963: } else {
13964: Operand opt = opStack.peekTopOfStack();
13965: opt.setOperandValue(opt.getOperandValue() + " && ");
13966: }
13967: }
13968: ifst.setDonotclose(true);
13969:
13970: GlobalVariableStore.setIfPartOfShortCutChain(true);
13971: GlobalVariableStore.setEncounteredAndOrComp(true);
13972: return false;
13973: } else {
13974: if (!last) {
13975: Util.forceTrimString = false;
13976: if (!GlobalVariableStore.isBooleanAssignFound())
13977: behaviour.appendToBuffer(" " + connector + " ");
13978: else {
13979: Operand opt = opStack.peekTopOfStack();
13980: opt.setOperandValue(opt.getOperandValue() + " "
13981: + connector + " ");
13982: }
13983: ifst.setDonotclose(true);
13984: Util.forceTrimString = true;
13985: GlobalVariableStore.setIfPartOfShortCutChain(true);
13986: GlobalVariableStore.setEncounteredAndOrComp(true);
13987:
13988: } else {
13989: if (!GlobalVariableStore.isBooleanAssignFound())
13990: behaviour.appendToBuffer(Util
13991: .formatDecompiledStatement(")\n{\n"));
13992: else {
13993: Operand opt = opStack.peekTopOfStack();
13994: if (GlobalVariableStore.getMethodsc().toString()
13995: .equals("true")) {
13996: opt
13997: .setOperandValue(opt.getOperandValue()
13998: + ")");
13999: } else {
14000: opt.setOperandValue(opt.getOperandValue()
14001: + ");\n");
14002: }
14003: ifst.setDonotclose(true);
14004: }
14005: GlobalVariableStore.setIfPartOfShortCutChain(false);
14006: GlobalVariableStore.setEncounteredAndOrComp(false);
14007: }
14008: return false;
14009: }
14010: } else {
14011: if (!last) {
14012: Util.forceTrimString = false;
14013: if (!GlobalVariableStore.isBooleanAssignFound())
14014: behaviour.appendToBuffer(" " + connector + " ");
14015: else {
14016: Operand opt = opStack.peekTopOfStack();
14017: opt.setOperandValue(opt.getOperandValue() + " "
14018: + connector + " ");
14019: }
14020: ifst.setDonotclose(true);
14021: Util.forceTrimString = true;
14022: GlobalVariableStore.setIfPartOfShortCutChain(true);
14023: GlobalVariableStore.setEncounteredAndOrComp(true);
14024:
14025: } else {
14026: Operand opt = opStack.peekTopOfStack();
14027: if (!GlobalVariableStore.isBooleanAssignFound()
14028: || opt == null) {
14029: Util.forceTrimLines = false;
14030: behaviour.appendToBuffer(")\n");
14031: behaviour.appendToBuffer(Util
14032: .formatDecompiledStatement("\n{\n"));
14033: Util.forceTrimLines = true;
14034:
14035: } else {
14036:
14037: if (GlobalVariableStore.getMethodsc().toString()
14038: .equals("true")) {
14039: opt.setOperandValue(opt.getOperandValue() + ")");
14040: } else {
14041: opt.setOperandValue(opt.getOperandValue() + ");\n");
14042: }
14043: ifst.setDonotclose(true);
14044: }// 123
14045: GlobalVariableStore.setIfPartOfShortCutChain(false);
14046: GlobalVariableStore.setEncounteredAndOrComp(false);
14047: }
14048:
14049: return false;
14050: }
14051:
14052: } else {
14053: return true;
14054: }
14055:
14056: }
14057:
14058: private boolean isInstructionIF(int instruction) {
14059:
14060: switch (instruction) {
14061:
14062: case JvmOpCodes.IF_ACMPEQ:
14063: return true;
14064: case JvmOpCodes.IF_ACMPNE:
14065: return true;
14066: case JvmOpCodes.IF_ICMPEQ:
14067: return true;
14068: case JvmOpCodes.IF_ICMPGE:
14069: return true;
14070: case JvmOpCodes.IF_ICMPGT:
14071: return true;
14072: case JvmOpCodes.IF_ICMPLE:
14073: return true;
14074: case JvmOpCodes.IF_ICMPLT:
14075: return true;
14076: case JvmOpCodes.IF_ICMPNE:
14077: return true;
14078:
14079: case JvmOpCodes.IFEQ:
14080: return true;
14081: case JvmOpCodes.IFGE:
14082: return true;
14083: case JvmOpCodes.IFGT:
14084: return true;
14085: case JvmOpCodes.IFLE:
14086: return true;
14087: case JvmOpCodes.IFNE:
14088: return true;
14089: case JvmOpCodes.IFLT:
14090: return true;
14091: case JvmOpCodes.IFNULL:
14092: return true;
14093: case JvmOpCodes.IFNONNULL:
14094: return true;
14095: default:
14096: return false;
14097:
14098: }
14099:
14100: }
14101:
14102: private void checkForATHROWAtIFelseEnd(IFBlock ifst,
14103: StringBuffer ifelsecode, int i) {
14104: boolean start = isThisInstrStart(behaviour
14105: .getInstructionStartPositions(), i);
14106: byte[] info = behaviour.getCode();
14107: if (start && info[i] == JvmOpCodes.ATHROW) {
14108: boolean x = addATHROWOutput(i);
14109: if (opStack.size() > 0 && x) {
14110: Operand op = (Operand) opStack.pop();
14111: opStack.push(op);
14112: java.lang.String tempString = "throw " + op.getOperandValue()
14113: + ";\n";
14114: ifelsecode.append(Util.formatDecompiledStatement("\n"
14115: + tempString + "\n"));
14116: GlobalVariableStore.getAthrowmap().put(new Integer(i), "true");
14117: }
14118:
14119: }
14120:
14121: }
14122:
14123: private boolean addATHROWOutput(int i) {
14124: if (GlobalVariableStore.getAthrowmap().size() == 0)
14125: return true;
14126: Set entries = GlobalVariableStore.getAthrowmap().entrySet();
14127: Iterator it = entries.iterator();
14128: while (it.hasNext()) {
14129: Map.Entry entry = (Map.Entry) it.next();
14130: Integer pos = (Integer) entry.getKey();
14131: if (pos.intValue() == i) {
14132: java.lang.String str = (java.lang.String) entry.getValue();
14133: if (str.equals("true")) {
14134: return false;
14135: }
14136: }
14137: }
14138:
14139: return true;
14140:
14141: }
14142:
14143: private int handleBALOAD(OperandStack stack) {
14144: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
14145: JvmOpCodes.BALOAD);
14146: }
14147:
14148: private int handleBASTORE(OperandStack stack) {
14149:
14150: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.INT,
14151: JvmOpCodes.BASTORE);
14152: }
14153:
14154: private int handleCALOAD(OperandStack stack) {
14155: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
14156: JvmOpCodes.CALOAD);
14157: }
14158:
14159: private int handleCASTORE(OperandStack stack) {
14160: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.INT,
14161: JvmOpCodes.CASTORE);
14162: }
14163:
14164: private int handleCheckCast(OperandStack stack, byte[] info) {
14165: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
14166: JvmOpCodes.CHECKCAST);
14167:
14168: }
14169:
14170: private int handleDALOAD(OperandStack stack) {
14171: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14172: JvmOpCodes.DALOAD);
14173: }
14174:
14175: private int handleDASTORE(OperandStack opStack) {
14176: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.DOUBLE,
14177: JvmOpCodes.DASTORE);
14178: }
14179:
14180: private int handleDCONST(OperandStack stack, double val) {
14181: if (val == 0)
14182: return execute(InstrConstants.LOAD_INSTR_TYPE,
14183: InstrConstants.DOUBLE, JvmOpCodes.DCONST_0);
14184:
14185: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14186: JvmOpCodes.DCONST_1);
14187: }
14188:
14189: private int handleDDIV(OperandStack stack) {
14190: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14191: JvmOpCodes.DDIV);
14192: }
14193:
14194: private int handleDLOADCase(int opcode) {
14195: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14196: opcode);
14197: }
14198:
14199: private int handleDMUL(OperandStack stack) {
14200: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14201: JvmOpCodes.DMUL);
14202: }
14203:
14204: private int handleDNEG(OperandStack stack) {
14205: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14206: JvmOpCodes.DNEG);
14207: }
14208:
14209: private int handleDREM(OperandStack stack) {
14210: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14211: JvmOpCodes.DREM);
14212: }
14213:
14214: private int handleDUP2X2(OperandStack stack) {
14215: return execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
14216: JvmOpCodes.DUP2_X2);
14217: }
14218:
14219: private int handleFCONST(OperandStack stack, java.lang.String val) {
14220: int opcodeval;
14221: if (val.equals("0.0f")) {
14222: opcodeval = JvmOpCodes.FCONST_0;
14223: } else if (val.equals("0.0f")) {
14224: opcodeval = JvmOpCodes.FCONST_1;
14225: } else {
14226: opcodeval = JvmOpCodes.FCONST_2;
14227: }
14228:
14229: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
14230: opcodeval);
14231: }
14232:
14233: private int handleFDIV(OperandStack stack) {
14234: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
14235: JvmOpCodes.FDIV);
14236:
14237: }
14238:
14239: private int handleFLOAD(int opcodeval) {
14240: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
14241: opcodeval);
14242: }
14243:
14244: private boolean isIFShortcutORComp(byte[] info, int j) {
14245:
14246: boolean b = sanalyser.isIFShortcutIfCondition(j);
14247: return b;
14248:
14249: }
14250:
14251: private void handleLCONST(OperandStack stack, java.lang.String str) {
14252: int opcodeval;
14253: if (str.equals("0")) {
14254: opcodeval = JvmOpCodes.LCONST_0;
14255: } else {
14256: opcodeval = JvmOpCodes.LCONST_1;
14257: }
14258: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG, opcodeval);
14259: }
14260:
14261: private void handleLDIV(OperandStack stack) {
14262: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
14263: JvmOpCodes.LDIV);
14264: }
14265:
14266: private void handleSIMPLELLOAD(OperandStack stack, int index) {
14267:
14268: int opcodeval;
14269: switch (index) {
14270: case 0:
14271: opcodeval = JvmOpCodes.LLOAD_0;
14272: break;
14273: case 1:
14274: opcodeval = JvmOpCodes.LLOAD_1;
14275: break;
14276: case 2:
14277: opcodeval = JvmOpCodes.LLOAD_2;
14278: break;
14279: default:
14280: opcodeval = JvmOpCodes.LLOAD_3;
14281: break;
14282: }
14283:
14284: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG, opcodeval);
14285: }
14286:
14287: private int handleDCMPG(OperandStack stack, byte[] info) {
14288: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14289: JvmOpCodes.DCMPG);
14290: }
14291:
14292: private int handleDCMPL(OperandStack stack, byte[] info) {
14293: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
14294: JvmOpCodes.DCMPL);
14295: }
14296:
14297: private boolean addRETURNatI(int i, IFBlock ifst) {
14298:
14299: /*
14300: * byte[] info=behaviour.getCode();
14301: *
14302: * boolean shortcut=isIFShortcutORComp(info,ifst.getIfStart());
14303: * if(shortcut)return true; int ifclose=ifst.getIfCloseLineNumber(); int
14304: * x=ifclose-3;
14305: * if(isThisInstrStart(behaviour.getInstructionStratPositions(),x) &&
14306: * x!=ifst.getIfStart()) { boolean isif=isInstructionIF(info[x]);
14307: * if(isif)return true; }
14308: */
14309:
14310: boolean oktoadd = true;
14311: Iterator mapIT = GlobalVariableStore.getReturnsAtI().entrySet()
14312: .iterator();
14313: while (mapIT.hasNext()) {
14314: Map.Entry entry = (Map.Entry) mapIT.next();
14315: Object key = entry.getKey();
14316: Object retStatus = entry.getValue().toString();
14317: if (key instanceof Integer) {
14318: Integer position = (Integer) key;
14319: int posValue = position.intValue();
14320: if (posValue == i) {
14321: if (retStatus.equals("true")) {
14322:
14323: oktoadd = false;
14324: break;
14325: }
14326: }
14327: }
14328:
14329: }
14330: return oktoadd;
14331: }
14332:
14333: private boolean lastIFinShortCutChain(byte[] info, IFBlock ifst, int i) {
14334:
14335: return sanalyser.isLastIfInChain(i);
14336: }
14337:
14338: private boolean isInstAnyCMPInst(byte[] info, int i) {
14339: ArrayList starts = behaviour.getInstructionStartPositions();
14340: if (isThisInstrStart(starts, i)) {
14341: switch (info[i]) {
14342: case JvmOpCodes.DCMPG:
14343: case JvmOpCodes.DCMPL:
14344: case JvmOpCodes.FCMPG:
14345: case JvmOpCodes.FCMPL:
14346: case JvmOpCodes.LCMP:
14347: return true;
14348: }
14349: }
14350: return false;
14351: }
14352:
14353: private int handleFCMPG(OperandStack stack, byte[] info) {
14354: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
14355: JvmOpCodes.FCMPG);
14356: }
14357:
14358: private int handleFCMPL(OperandStack stack, byte[] info) {
14359: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
14360: JvmOpCodes.FCMPL);
14361: }
14362:
14363: private void handleLCMP(OperandStack stack, byte[] info) {
14364: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
14365: JvmOpCodes.LCMP);
14366: }
14367:
14368: private int handleISTORE(int opcodeval) {
14369:
14370: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.INT,
14371: opcodeval);
14372:
14373: }
14374:
14375: private void adjustBracketCount(Operand op) {
14376: java.lang.String value = op.getOperandValue();
14377: int openB = 0;
14378: int closeB = 0;
14379: if (value != null && value.indexOf("(") != -1
14380: && value.indexOf(")") != -1) {
14381: for (int c = 0; c < value.length(); c++) {
14382: char ch = value.charAt(c);
14383: if (ch == ')')
14384: closeB++;
14385: else if (ch == '(')
14386: openB++;
14387: }
14388: if (closeB > openB) {
14389:
14390: java.lang.String temp = value.trim();
14391: int number = closeB - openB;
14392: if (temp.charAt(temp.length() - 1) == ')') {
14393: if (temp.length() - number < 0)
14394: number = 1; // A Crude way of avoiding Exception If any
14395: java.lang.String str = value.substring(0, temp.length()
14396: - number);
14397: op.setOperandValue(str);
14398: }
14399:
14400: }
14401: if (closeB < openB) {
14402:
14403: java.lang.String temp = value.trim();
14404: int number = openB - closeB;
14405: java.lang.String str = "";
14406: for (int z = 1; z <= number; z++)
14407: str += ")";
14408: op.setOperandValue(temp + str);
14409: }
14410:
14411: }
14412:
14413: }
14414:
14415: private boolean checkForLoadBeforeIINC(byte[] info, OperandStack opStack,
14416: int current, LocalVariable local, int index, java.lang.String c) {
14417:
14418: boolean b = false;
14419: int loadindex = -1;
14420: boolean ok = false;
14421: boolean iloadfnd = false;
14422: int j = getPrevStartOfInst(current, info);
14423: if (isThisInstrStart(behaviour.getInstructionStartPositions(), j)) {
14424:
14425: switch (info[j]) {
14426:
14427: case JvmOpCodes.ILOAD:
14428: loadindex = info[(j + 1)];
14429: iloadfnd = true;
14430: break;
14431:
14432: case JvmOpCodes.ILOAD_0:
14433: loadindex = 0;
14434: iloadfnd = true;
14435: break;
14436:
14437: case JvmOpCodes.ILOAD_1:
14438: loadindex = 1;
14439: iloadfnd = true;
14440: break;
14441:
14442: case JvmOpCodes.ILOAD_2:
14443: loadindex = 2;
14444: iloadfnd = true;
14445: break;
14446:
14447: case JvmOpCodes.ILOAD_3:
14448: loadindex = 3;
14449: iloadfnd = true;
14450: break;
14451:
14452: case JvmOpCodes.IALOAD:
14453: loadindex = -1;
14454: ok = true;
14455: break;
14456:
14457: }
14458:
14459: if (loadindex != -1) {
14460: if (loadindex == index) {
14461:
14462: if (c.trim().indexOf("-1") != -1) {
14463: b = true;
14464: local.setTempVarName(local.getVarName() + "--");
14465: opStack.peekTopOfStack().setOperandValue(
14466: local.getTempVarName());
14467: } else if (c.trim().indexOf("1") != -1) {
14468: b = true;
14469: local.setTempVarName(local.getVarName() + "++");
14470: opStack.peekTopOfStack().setOperandValue(
14471: local.getTempVarName());
14472:
14473: } else {
14474: b = false;
14475: }
14476: }
14477: } else {
14478: b = false;
14479: }
14480:
14481: if (ok) {
14482: if (c.trim().indexOf("-1") != -1) {
14483: b = true;
14484: Operand currentTop = opStack.peekTopOfStack();
14485: if (currentTop != null) {
14486: java.lang.String topval = currentTop.getOperandValue();
14487: topval = topval + "--";
14488: currentTop.setOperandValue(topval);
14489: b = true;
14490: } else {
14491: b = false;
14492: }
14493: } else if (c.trim().indexOf("1") != -1) {
14494: b = true;
14495: Operand currentTop = opStack.peekTopOfStack();
14496: if (currentTop != null) {
14497: java.lang.String topval = currentTop.getOperandValue();
14498: topval = topval + "++";
14499: currentTop.setOperandValue(topval);
14500: b = true;
14501: } else {
14502: b = false;
14503: }
14504: } else {
14505: b = false;
14506: }
14507: }
14508: /*
14509: * if(!b && !iloadfnd) { j=current+3; StringBuffer buf=new
14510: * StringBuffer(""); boolean
14511: * istore=isThisInstructionIStoreInst(info,j,buf); if(istore==false) {
14512: * if(c.trim().indexOf("-1")!=-1) { b=true; Operand
14513: * currentTop=opStack.peekTopOfStack(); if(currentTop!=null) {
14514: * java.lang.String topval=currentTop.getOperandValue();
14515: * topval=topval+"--"; currentTop.setOperandValue(topval); b=true; }
14516: * else { b=false; } } else if(c.trim().indexOf("1")!=-1) { b=true;
14517: * Operand currentTop=opStack.peekTopOfStack(); if(currentTop!=null) {
14518: * java.lang.String topval=currentTop.getOperandValue();
14519: * topval=topval+"++"; currentTop.setOperandValue(topval); b=true; }
14520: * else { b=false; } } else { b=false; } } }
14521: */
14522:
14523: }
14524:
14525: return b;
14526: }
14527:
14528: private boolean checkForLoadAfterIINC(byte[] info, OperandStack opStack,
14529: int current, LocalVariable local, int index, java.lang.String c) {
14530:
14531: boolean b = false;
14532: int j = current + 1 + 1 + 1;
14533: int loadindex = -1;
14534: boolean ok = false;
14535: boolean iloadfnd = false;
14536: if (isThisInstrStart(behaviour.getInstructionStartPositions(), j)) {
14537:
14538: switch (info[j]) {
14539: case JvmOpCodes.ILOAD:
14540: loadindex = info[(j + 1)];
14541: iloadfnd = true;
14542: break;
14543:
14544: case JvmOpCodes.ILOAD_0:
14545: loadindex = 0;
14546: iloadfnd = true;
14547: break;
14548:
14549: case JvmOpCodes.ILOAD_1:
14550: loadindex = 1;
14551: iloadfnd = true;
14552: break;
14553:
14554: case JvmOpCodes.ILOAD_2:
14555: loadindex = 2;
14556: iloadfnd = true;
14557: break;
14558:
14559: case JvmOpCodes.ILOAD_3:
14560: loadindex = 3;
14561: iloadfnd = true;
14562: break;
14563:
14564: case JvmOpCodes.IALOAD:
14565: loadindex = -1;
14566: ok = true;
14567: break;
14568: }
14569:
14570: if (loadindex != -1) {
14571: if (loadindex == index) {
14572:
14573: if (c.trim().indexOf("-1") != -1) {
14574: b = true;
14575: local.setTempVarName("--" + local.getVarName());
14576: } else if (c.trim().indexOf("1") != -1) {
14577: b = true;
14578: local.setTempVarName("++" + local.getVarName());
14579: } else {
14580: b = false;
14581: }
14582: }
14583: } else {
14584: b = false;
14585: }
14586:
14587: if (ok) {
14588: if (c.trim().indexOf("-1") != -1) {
14589: b = true;
14590: Operand currentTop = opStack.peekTopOfStack();
14591: if (currentTop != null) {
14592: java.lang.String topval = currentTop.getOperandValue();
14593: topval = topval + "--";
14594: currentTop.setOperandValue(topval);
14595: b = true;
14596: } else {
14597: b = false;
14598: }
14599: } else if (c.trim().indexOf("1") != -1) {
14600: b = true;
14601: Operand currentTop = opStack.peekTopOfStack();
14602: if (currentTop != null) {
14603: java.lang.String topval = currentTop.getOperandValue();
14604: topval = topval + "++";
14605: currentTop.setOperandValue(topval);
14606: b = true;
14607: } else {
14608: b = false;
14609: }
14610: } else {
14611: b = false;
14612: }
14613: }
14614: /*
14615: * if(!b && !iloadfnd) { j=current+1+1+1; StringBuffer buf=new
14616: * StringBuffer(""); boolean
14617: * istore=isThisInstructionIStoreInst(info,j,buf); if(istore==false) {
14618: * if(c.trim().indexOf("-1")!=-1) { b=true; Operand
14619: * currentTop=opStack.peekTopOfStack(); if(currentTop!=null) {
14620: * java.lang.String topval=currentTop.getOperandValue();
14621: * topval=topval+"--"; currentTop.setOperandValue(topval); b=true; }
14622: * else { b=false; } } else if(c.trim().indexOf("1")!=-1) { b=true;
14623: * Operand currentTop=opStack.peekTopOfStack(); if(currentTop!=null) {
14624: * java.lang.String topval=currentTop.getOperandValue();
14625: * topval=topval+"++"; currentTop.setOperandValue(topval); b=true; }
14626: * else { b=false; } } else { b=false; } } }
14627: */
14628:
14629: }
14630:
14631: return b;
14632: }
14633:
14634: private boolean isPrevInstIINC(byte[] info, int current, int index) {
14635: int prev = current - 3;
14636: if (isThisInstrStart(behaviour.getInstructionStartPositions(), prev)) {
14637:
14638: if (info[prev] == JvmOpCodes.IINC) {
14639: int j = info[prev + 1];
14640: if (index == j) {
14641: return true;
14642: }
14643: }
14644:
14645: }
14646:
14647: return false;
14648:
14649: }
14650:
14651: private boolean isNextInstIINC(byte[] info, int current, int index,
14652: java.lang.String type) {
14653: int next;
14654: if (type.equals("complex")) {
14655: next = current + 2;
14656: } else {
14657: next = current + 1;
14658: }
14659: if (isThisInstrStart(behaviour.getInstructionStartPositions(), next)) {
14660:
14661: if (info[next] == JvmOpCodes.IINC) {
14662: int j = info[next + 1];
14663: if (index == j) {
14664: return true;
14665: }
14666: }
14667:
14668: }
14669:
14670: return false;
14671:
14672: }
14673:
14674: private boolean addReturnAtIFElseEnd(int i) {
14675:
14676: if (returnsaddedAtIfElse.size() == 0)
14677: return true;
14678: for (int z = 0; z < returnsaddedAtIfElse.size(); z++) {
14679: Integer in = new Integer(i);
14680: Integer val = (Integer) returnsaddedAtIfElse.get(z);
14681: if (val.intValue() == in.intValue()) {
14682: return false;
14683: }
14684: }
14685: return true;
14686: }
14687:
14688: private boolean isByteCodeALoopStart(ArrayList loops, int bytecodeend) {
14689: if (loops == null || loops.size() == 0)
14690: return false;
14691: for (int z = 0; z < loops.size(); z++) {
14692: Loop loop = (Loop) loops.get(z);
14693: int loopstart = loop.getStartIndex();
14694: if (loopstart == bytecodeend) {
14695: return true;
14696: }
14697: }
14698: return false;
14699: }
14700:
14701: private int getIfCloseNumberForThisIF(byte[] info, int k) {
14702: IFBlock ifst = new IFBlock();
14703: ifst.setIfStart(k);
14704: ifst.setHasIfBeenGenerated(true);
14705:
14706: behaviour.getMethodIfs().add(ifst);
14707: // addBranchLabel(classIndex,i,ifst,currentForIndex,info);
14708: int i = k;
14709: int classIndex = getJumpAddress(info, i);
14710: i++;
14711: i++;
14712: boolean continuetofind = false;
14713: if (classIndex < i) {
14714: ifst.setIfCloseLineNumber(findCodeIndexFromInfiniteLoop(ifst,
14715: behaviour.getBehaviourLoops(), classIndex));
14716: if (ifst.getIfCloseLineNumber() == -1)
14717: continuetofind = true;
14718: }
14719: if (classIndex > i || continuetofind) {
14720: if (isThisInstrStart(behaviour.getInstructionStartPositions(),
14721: classIndex - 3)
14722: && info[classIndex - 3] == JvmOpCodes.GOTO) // GOTO_W?
14723: {
14724:
14725: int resetVal = checkIfElseCloseNumber(classIndex - 3, ifst);
14726: ifst.setIfCloseLineNumber(resetVal);
14727: } else {
14728:
14729: int resetVal = checkIfElseCloseNumber(classIndex, ifst);
14730: ifst.setIfCloseLineNumber(resetVal);
14731: }
14732:
14733: }
14734:
14735: int if_start = ifst.getIfStart();
14736: int if_end = ifst.getIfCloseLineNumber();
14737: if (if_end == -1 || if_end < if_start) {
14738: boolean b = false;
14739: int bytecodeend = ifst.getIfCloseFromByteCode();
14740: b = isByteCodeALoopStart(behaviour.getBehaviourLoops(), bytecodeend);
14741: if (b) {
14742: int loopend = getloopEndForStart(behaviour.getBehaviourLoops(),
14743: bytecodeend);
14744: if (loopend != -1) {
14745: ifst.setIfCloseLineNumber(loopend);
14746: }
14747: }
14748: }
14749:
14750: return ifst.getIfCloseLineNumber();
14751:
14752: }
14753:
14754: private ArrayList addedHandlerEnds = new ArrayList();
14755:
14756: private ArrayList handlerEndLocationsAdded = new ArrayList();
14757:
14758: // TODO : Need to rethink why this method was introduced
14759: // Commented for 1.2 release Feb 25 2007
14760: private boolean isHandlerEndPresentAtGuardEnd(int i) {
14761: /*
14762: * if(addedHandlerEnds.size()==0)return false; for(int z=0;z<addedHandlerEnds.size();z++) {
14763: * Integer in=(Integer)addedHandlerEnds.get(z); if(in.intValue()==i) {
14764: * return true; } }
14765: */
14766: return false;
14767: }
14768:
14769: /**
14770: * s--> dummy
14771: *
14772: * @param i
14773: * @param s
14774: * @return
14775: */
14776: private boolean isHandlerEndPresentAtGuardEnd(int i, String s) {
14777:
14778: if (handlerEndLocationsAdded.size() == 0)
14779: return false;
14780: for (int z = 0; z < handlerEndLocationsAdded.size(); z++) {
14781: Integer in = (Integer) handlerEndLocationsAdded.get(z);
14782: if (in.intValue() == i) {
14783: return true;
14784: }
14785: }
14786:
14787: return false;
14788: }
14789:
14790: private boolean isThisTryStart(int i) {
14791: ArrayList tries = behaviour.getAllTriesForMethod();
14792: if (tries != null) {
14793: for (int z = 0; z < tries.size(); z++) {
14794:
14795: TryBlock TRY = (TryBlock) tries.get(z);
14796: if (TRY.getEnd() == i)
14797: return true;
14798:
14799: }
14800:
14801: }
14802: return false;
14803:
14804: }
14805:
14806: private ArrayList storesatifend = new ArrayList();
14807:
14808: private boolean storealreadyhandledatifend(int i) {
14809: if (storesatifend.size() == 0)
14810: return false;
14811: for (int z = 0; z < storesatifend.size(); z++) {
14812: Integer in = (Integer) storesatifend.get(z);
14813: if (in.intValue() == i) {
14814: return true;
14815: }
14816: }
14817:
14818: return false;
14819: }
14820:
14821: private boolean addElseStart(int i) {
14822: if (GlobalVariableStore.getElsestartadded().size() == 0) {
14823: return true;
14824: }
14825: for (int z = 0; z < GlobalVariableStore.getElsestartadded().size(); z++) {
14826: Integer in = (Integer) GlobalVariableStore.getElsestartadded().get(
14827: z);
14828: if (in.intValue() == i) {
14829: return false;
14830: }
14831: }
14832: return true;
14833: }
14834:
14835: private boolean isInstStore0(byte[] info, int i) {
14836:
14837: boolean flag = false;
14838: boolean b = isThisInstrStart(behaviour.getInstructionStartPositions(),
14839: i);
14840: if (!b)
14841: return false;
14842: switch (info[i]) {
14843: case JvmOpCodes.AASTORE:
14844: flag = true;
14845: break;
14846:
14847: case JvmOpCodes.BASTORE:
14848: flag = true;
14849: break;
14850: case JvmOpCodes.CASTORE:
14851: flag = true;
14852: break;
14853: case JvmOpCodes.DASTORE:
14854: flag = true;
14855: break;
14856:
14857: case JvmOpCodes.FASTORE:
14858: flag = true;
14859: break;
14860:
14861: case JvmOpCodes.IASTORE:
14862: flag = true;
14863: break;
14864:
14865: case JvmOpCodes.LASTORE:
14866: flag = true;
14867: break;
14868:
14869: case JvmOpCodes.SASTORE:
14870: flag = true;
14871: break;
14872:
14873: default:
14874: flag = false;
14875: }
14876: return flag;
14877: }
14878:
14879: private HashMap putfieldObjRefMap = new HashMap();
14880:
14881: private Operand checkAnyStoredPUTFIELDObjRef(int i) {
14882: if (putfieldObjRefMap.size() == 0)
14883: return null;
14884: Set s = putfieldObjRefMap.entrySet();
14885: Iterator it = s.iterator();
14886: while (it.hasNext()) {
14887: Map.Entry entry = (Map.Entry) it.next();
14888: Integer in = (Integer) entry.getKey();
14889: if (in.intValue() == i) {
14890: return (Operand) entry.getValue();
14891: }
14892: }
14893: return null;
14894: }
14895:
14896: private boolean checkForEndOfTryCatch(int i) {
14897:
14898: boolean flag = false;
14899: ArrayList list = behaviour.getAllTriesForMethod();
14900: if (list == null || list.size() == 0)
14901: return false;
14902: for (int z = 0; z < list.size(); z++) {
14903: TryBlock tryb = (TryBlock) list.get(z);
14904: int tryend = tryb.getEnd();
14905: if (tryend == i) {
14906: behaviour.appendToBuffer(Util
14907: .formatDecompiledStatement("\n}\n"));
14908: flag = true;
14909: }
14910: ArrayList catchlist = tryb.getAllCatchesForThisTry();
14911: for (int x = 0; x < catchlist.size(); x++) {
14912: CatchBlock cb = (CatchBlock) catchlist.get(x);
14913: int ce = cb.getEnd();
14914: if (ce == i) {
14915: boolean empty = checkForEmptyCatch(cb.getStart(), cb
14916: .getEnd());
14917: if (empty) {
14918: // codeStatements+=Util.formatDecompiledStatement("\n/*Empty
14919: // Handler Block*/\n");
14920: }
14921: behaviour.appendToBuffer(Util
14922: .formatDecompiledStatement("\n}\n"));
14923: flag = true;
14924: }
14925: }
14926: FinallyBlock finb = tryb.getFinallyBlock();
14927: if (finb != null) {
14928: int fine = finb.getEnd();
14929: int fins = finb.getStart();
14930: if (fine == i) {
14931: boolean empty = checkForEmptyFinally(fins, fine);
14932: if (empty) {
14933: // codeStatements+=Util.formatDecompiledStatement("\n/*Empty
14934: // Handler Block*/\n");
14935: }
14936: behaviour.appendToBuffer(Util
14937: .formatDecompiledStatement("\n}\n"));
14938: flag = true;
14939: }
14940: if (fins == i) {
14941: boolean addfin = okToaddFinally(i);
14942: if (addfin) {
14943: behaviour.appendToBuffer(Util
14944: .formatDecompiledStatement("\nfinally\n{\n"));
14945: Integer in = new Integer(i);
14946: somefinallystarts.put(in, in);
14947: }
14948: flag = true;
14949: }
14950:
14951: }
14952:
14953: }
14954: return flag;
14955: }
14956:
14957: private boolean okToaddFinally(int i) {
14958: if (somefinallystarts.size() == 0)
14959: return true;
14960: Object ob = somefinallystarts.get(new Integer(i));
14961: if (ob == null)
14962: return true;
14963: return false;
14964:
14965: }
14966:
14967: private HashMap somefinallystarts = new HashMap();
14968:
14969: private ArrayList getFinallyCount(ArrayList tableList) {
14970: if (tableList == null || tableList.size() == 0)
14971: return null;
14972: ArrayList temp = new ArrayList();
14973: for (int z = 0; z < tableList.size(); z++) {
14974: ExceptionTable t = (ExceptionTable) tableList.get(z);
14975: int x = t.getStartOfHandler();
14976: temp.add(new Integer(x));
14977: }
14978: /*
14979: * Integer in[]=(Integer[])temp.toArray(new Integer[temp.size()]);
14980: * Arrays.sort(in);
14981: */
14982: temp = (ArrayList) Util.genericRemoveDuplicates(temp);
14983: return temp;
14984:
14985: }
14986:
14987: private int handleFASTORE() {
14988: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.FLOAT,
14989: JvmOpCodes.FASTORE);
14990:
14991: }
14992:
14993: private void handleIASTORE() {
14994: execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.INT,
14995: JvmOpCodes.IASTORE);
14996: }
14997:
14998: private void addAnyReurnAtDefaultEnd(int i, OperandStack stack,
14999: byte[] info, StringBuffer S) {
15000: StringBuffer sg = new StringBuffer("");
15001: boolean r = isInstReturnInst(info, i, sg);
15002:
15003: if (r) {
15004: if (sg.toString().equals("return") == false && stack.size() > 0) {
15005: java.lang.String t = stack.getTopOfStack().getOperandValue();
15006: boolean b = isMethodRetBoolean(behaviour);
15007: if (t != null) {
15008: if (t.equals("1") && b)
15009: t = "true";
15010: if (t.equals("0") && b)
15011: t = "false";
15012: java.lang.String retst = "return " + t + ";";
15013: boolean a = addRETURNatI(i, null);
15014: if (a) {
15015: S.append(Util.formatDecompiledStatement(retst));
15016: GlobalVariableStore.getReturnsAtI().put(new Integer(i),
15017: "true");
15018: }
15019: }
15020:
15021: } else if (sg.toString().equals("return") == true) {
15022: boolean a = addRETURNatI(i, null);
15023: if (a) {
15024: java.lang.String retst = "return ;";
15025: S.append(Util.formatDecompiledStatement(retst));
15026: GlobalVariableStore.getReturnsAtI().put(new Integer(i),
15027: "true");
15028: }
15029: } else {
15030:
15031: }
15032: }
15033: }
15034:
15035: private boolean checkForParentLoopForIF(IFBlock ifst) {
15036: ArrayList loops = behaviour.getBehaviourLoops();
15037: if (loops != null) {
15038: Object[] sortedLoops = sortLoops(loops);
15039: int parentLoopStart = getParentLoopStartForIf(sortedLoops, ifst
15040: .getIfStart());
15041: if (parentLoopStart == -1) {
15042: return false;
15043: } else {
15044: int by = ifst.getIfCloseFromByteCode();
15045: Loop l = getParentLoopForIf(sortedLoops, ifst.getIfStart());
15046: if (l != null) {
15047: int le = l.getEndIndex();
15048: if (by > ifst.getIfStart() && by < le) {
15049: return false;
15050: }
15051: }
15052:
15053: return true;
15054: }
15055: }
15056: return false;
15057: }
15058:
15059: private void handleSimpleILoad(int index, byte[] info) {
15060: int opcodeval;
15061: switch (index) {
15062: case 0:
15063: opcodeval = JvmOpCodes.ILOAD_0;
15064: break;
15065: case 1:
15066: opcodeval = JvmOpCodes.ILOAD_1;
15067: break;
15068: case 2:
15069: opcodeval = JvmOpCodes.ILOAD_2;
15070: break;
15071: default:
15072: opcodeval = JvmOpCodes.ILOAD_3;
15073: break;
15074: }
15075:
15076: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT, opcodeval);
15077: }
15078:
15079: private int handleComplexFSTORE() {
15080: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.FLOAT,
15081: JvmOpCodes.FSTORE);
15082: }
15083:
15084: private boolean isIfForLoadClass(IFBlock ifst, byte[] info) {
15085: boolean p = true;
15086: int by = ifst.getIfCloseFromByteCode();
15087:
15088: if (by > ifst.getIfStart()) {
15089: int j = by - 3;
15090: ArrayList list = behaviour.getInstructionStartPositions();
15091: if (isThisInstrStart(list, j) && info[j] == JvmOpCodes.GOTO) {
15092: int k = getJumpAddress(info, j);
15093: if ((k - j) == 6) {
15094: int s = ifst.getIfStart();
15095: s = s + 3;
15096: if (info[s] == JvmOpCodes.LDC) {
15097: int d = (s + 1);
15098: int offset = info[d];
15099: if (offset < 0)
15100: offset += 256;
15101: CPString constString = cd
15102: .getStringsAtCPoolPosition(offset);
15103: if (constString == null) {
15104: return true;
15105: }
15106: java.lang.String stringLiteral = cd
15107: .getUTF8String(constString.getUtf8pointer());
15108: if (stringLiteral == null) {
15109: return true;
15110: }
15111: s = s + 2;
15112: if (isThisInstrStart(list, s)
15113: && info[s] == JvmOpCodes.INVOKESTATIC) {
15114: int classIndex = getOffset(info, s);
15115: MethodRef mref = cd
15116: .getMethodRefAtCPoolPosition(classIndex);
15117: java.lang.String name = mref.getMethodName();
15118: if (name != null && name.indexOf("class$") != -1) {
15119:
15120: Operand op = new Operand();
15121: StringBuffer sb = new StringBuffer("");
15122: Util.checkForImport(stringLiteral, sb);
15123: java.lang.String classToLoad = sb.toString()
15124: + ".class";
15125: boolean yes = isIfPartOfTernaryIfCond(info,
15126: currentForIndex);
15127: /*
15128: * if(yes) {
15129: * op.setOperandValue(opStack.getTopOfStack().getOperandValue()+classToLoad); }
15130: * else
15131: */
15132: op.setOperandValue(classToLoad);
15133: boolean terend = isTernaryEnd(currentForIndex);
15134: if (terend) {
15135: op.setOperandValue(op.getOperandValue()
15136: + ")");
15137: }
15138:
15139: opStack.push(op);
15140: op.setClassType("Class");
15141: ArrayList instStart = behaviour
15142: .getInstructionStartPositions();
15143: int next = k + 1;
15144:
15145: if (info[k] == JvmOpCodes.DUP
15146: || info[k] == JvmOpCodes.DUP2) {
15147: boolean store = isStoreInst(next, info);
15148: if (store)
15149: k = next;
15150: }
15151: GlobalVariableStore.getSkipWRTClassLoadIf()
15152: .put(
15153: new Integer(
15154: ifst.getIfStart() + 3),
15155: new Integer(k));
15156: return false;
15157: }
15158: } else
15159: return true;
15160:
15161: } else if (info[s] == JvmOpCodes.LDC_W) {
15162: // int d=(s+1);
15163: int offset = getOffset(info, s);
15164: // if(offset < 0)offset+=256;
15165: CPString constString = cd
15166: .getStringsAtCPoolPosition(offset);
15167: if (constString == null) {
15168: return true;
15169: }
15170: java.lang.String stringLiteral = cd
15171: .getUTF8String(constString.getUtf8pointer());
15172: if (stringLiteral == null) {
15173: return true;
15174: }
15175: s = s + 3;
15176: if (isThisInstrStart(list, s)
15177: && info[s] == JvmOpCodes.INVOKESTATIC) {
15178: int classIndex = getOffset(info, s);
15179: MethodRef mref = cd
15180: .getMethodRefAtCPoolPosition(classIndex);
15181: java.lang.String name = mref.getMethodName();
15182: if (name != null && name.indexOf("class$") != -1) {
15183:
15184: Operand op = new Operand();
15185: StringBuffer sb = new StringBuffer("");
15186: Util.checkForImport(stringLiteral, sb);
15187: java.lang.String classToLoad = sb.toString()
15188: + ".class";
15189: op.setOperandValue(classToLoad);
15190: opStack.push(op);
15191: op.setClassType("Class");
15192: GlobalVariableStore.getSkipWRTClassLoadIf()
15193: .put(
15194: new Integer(
15195: ifst.getIfStart() + 3),
15196: new Integer(k));
15197: return false;
15198: }
15199: } else
15200: return true;
15201:
15202: } else {
15203: return true;
15204:
15205: }
15206:
15207: }
15208:
15209: }
15210:
15211: }
15212:
15213: return p;
15214: }
15215:
15216: private boolean checkWRTClassLoadIF(int i) {
15217: if (GlobalVariableStore.getSkipWRTClassLoadIf().size() == 0)
15218: return false;
15219: boolean skip = false;
15220: Set s = GlobalVariableStore.getSkipWRTClassLoadIf().entrySet();
15221: Iterator it = s.iterator();
15222: while (it.hasNext()) {
15223: Map.Entry entry = (Map.Entry) it.next();
15224: Integer st = (Integer) entry.getKey();
15225: Integer end = (Integer) entry.getValue();
15226: if (i >= st.intValue() && i < end.intValue()) {
15227: skip = true;
15228: break;
15229: }
15230:
15231: }
15232: return skip;
15233:
15234: }
15235:
15236: private boolean isStoreInst(int index, byte[] info) {
15237:
15238: if (index < 0)
15239: return false;
15240: boolean b = isThisInstrStart(behaviour.getInstructionStartPositions(),
15241: index);
15242: if (!b)
15243: return false;
15244: switch (info[index]) {
15245: case JvmOpCodes.AASTORE:
15246: case JvmOpCodes.ASTORE:
15247: case JvmOpCodes.ASTORE_0:
15248: case JvmOpCodes.ASTORE_1:
15249: case JvmOpCodes.ASTORE_2:
15250: case JvmOpCodes.ASTORE_3:
15251:
15252: case JvmOpCodes.BASTORE:
15253: case JvmOpCodes.CASTORE:
15254: case JvmOpCodes.DASTORE:
15255: case JvmOpCodes.DSTORE:
15256: case JvmOpCodes.DSTORE_0:
15257: case JvmOpCodes.DSTORE_1:
15258: case JvmOpCodes.DSTORE_2:
15259: case JvmOpCodes.DSTORE_3:
15260: case JvmOpCodes.FASTORE:
15261: case JvmOpCodes.FSTORE:
15262: case JvmOpCodes.FSTORE_0:
15263: case JvmOpCodes.FSTORE_1:
15264: case JvmOpCodes.FSTORE_2:
15265: case JvmOpCodes.FSTORE_3:
15266: case JvmOpCodes.IASTORE:
15267: case JvmOpCodes.ISTORE:
15268: case JvmOpCodes.ISTORE_0:
15269: case JvmOpCodes.ISTORE_1:
15270: case JvmOpCodes.ISTORE_2:
15271: case JvmOpCodes.ISTORE_3:
15272: case JvmOpCodes.LASTORE:
15273: case JvmOpCodes.LSTORE:
15274: case JvmOpCodes.LSTORE_0:
15275: case JvmOpCodes.LSTORE_1:
15276: case JvmOpCodes.LSTORE_2:
15277: case JvmOpCodes.LSTORE_3:
15278: case JvmOpCodes.SASTORE:
15279: return true;
15280: default:
15281: return false;
15282:
15283: }
15284:
15285: }
15286:
15287: private boolean checkForCodeInRange(int start, int end, byte[] info,
15288: int lookfor) {
15289: ArrayList list = behaviour.getInstructionStartPositions();
15290: for (int z = start; z < end; z++) {
15291: if (info[z] == lookfor && isThisInstrStart(list, z)) {
15292: return true;
15293: }
15294: }
15295: return false;
15296: }
15297:
15298: private int handleGetField(byte[] info) {
15299: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
15300: JvmOpCodes.GETFIELD);
15301: }
15302:
15303: // op.setClassType();
15304:
15305: private boolean checkForSizeOfArrayTimesStack() {
15306: if (GlobalVariableStore.getArraytimesstack().size() > 0) {
15307: return true;
15308: } else
15309: return false;
15310: }
15311:
15312: private int handleComplexDStore() {
15313: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.DOUBLE,
15314: JvmOpCodes.DSTORE);
15315: }
15316:
15317: private int checkEndOFTernary(IFBlock ifs, int terend, int gotos,
15318: byte[] info) {
15319:
15320: int start = gotos + 3;
15321: ArrayList list = behaviour.getInstructionStartPositions();
15322: for (int z = start; z < terend; z++) {
15323: if (info[z] == JvmOpCodes.GOTO && isThisInstrStart(list, z)) {
15324: return z;
15325: }
15326:
15327: }
15328:
15329: return terend;
15330:
15331: }
15332:
15333: private boolean isTernaryEnd(int i) {
15334: return false;
15335: }
15336:
15337: private boolean isIFForThisElseATernaryIF(int current, Hashtable allifs,
15338: StringBuffer sb, byte[] info) {
15339: boolean yes = false;
15340:
15341: Iterator iterIfHash = behaviour.getMethodIfs().iterator();
15342: while (iterIfHash.hasNext()) {
15343: IFBlock ifs = (IFBlock) iterIfHash.next();
15344:
15345: int this ifclose = ifs.getIfCloseLineNumber();
15346: if ((ifs.getIfCloseLineNumber() - (current)) == 0) {
15347: boolean present = isIFpresentInTernaryList(ifs);
15348: if (present) {
15349: boolean end = isThisGotoTernaryEnd(ifs, current);
15350: if (end) {
15351: sb.append("end");
15352: }
15353: return true;
15354: }
15355: }
15356: }
15357: return yes;
15358: }
15359:
15360: private boolean isIFpresentInTernaryList(IFBlock ifst) {
15361:
15362: return false;
15363:
15364: }
15365:
15366: private boolean isThisGotoTernaryEnd(IFBlock ifst, int end) {
15367:
15368: return false;
15369:
15370: }
15371:
15372: private boolean isTernaryCondition(int i, byte[] info) {
15373:
15374: return false;
15375:
15376: }
15377:
15378: private IFBlock getIFFromTernaryListGivenByteCodeEnd(int by, StringBuffer sb) {
15379: return null;
15380:
15381: }
15382:
15383: private IFBlock getIFFromTernaryListGivenIFStart(int start, StringBuffer sb) {
15384:
15385: return null;
15386:
15387: }
15388:
15389: private boolean isIfPartOfTernaryIfCond(byte[] info, int current) {
15390: return false;
15391:
15392: }
15393:
15394: private boolean isLoadTernaryEnd(int current) {
15395: return false;
15396: }
15397:
15398: private boolean isGotoPrecededByDUPSTORE(int current, byte[] info) // FIXME
15399: {
15400: boolean yes = false;
15401: int prev = current - 1;
15402: ArrayList list = behaviour.getInstructionStartPositions();
15403: boolean store = false;
15404: boolean dup = false;
15405: int x = -1;
15406: while (prev > 0) {
15407: if (isThisInstrStart(list, prev)) {
15408: store = isNextInstructionStore(info[prev]);
15409: x = prev;
15410: if (store) {
15411: dup = isPrevInstDup(info, x);
15412: if (dup)
15413: return true;
15414: }
15415:
15416: if (info[prev] == JvmOpCodes.GOTO) {
15417: return false;
15418: }
15419: }
15420: prev--;
15421: }
15422:
15423: return yes;
15424: }
15425:
15426: private int handleComplexIload() {
15427: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15428: JvmOpCodes.ILOAD);
15429: }
15430:
15431: private boolean checkForDUPStoreAtEndOFTernaryIF(int current, byte[] info,
15432: StringBuffer in, StringBuffer ty, StringBuffer lpos) {
15433: int x = current - 3;
15434: ArrayList list = behaviour.getInstructionStartPositions();
15435: if (isThisInstrStart(list, x) && info[x] == JvmOpCodes.GOTO) {
15436: int gotoj = getJumpAddress(info, x);
15437: boolean dup = isPrevInstDup(info, gotoj + 1);
15438: if (dup) {
15439:
15440: boolean store = isStoreInst(gotoj + 1, info, in, ty);// /isNextInstructionStore(info[gotoj+1]);
15441: if (store) {
15442: lpos.append(gotoj + 1);
15443: return true;
15444: }
15445: }
15446:
15447: }
15448: return false;
15449:
15450: }
15451:
15452: private boolean isThisDUPSTOREAtEndOFTernaryIF(int pos, byte[] info,
15453: java.lang.String type) {
15454:
15455: return false;
15456:
15457: }
15458:
15459: private boolean isThisTernaryListEnd(int current) {
15460:
15461: return false;
15462:
15463: }
15464:
15465: private boolean isThisTernaryListEndForParentIF(int current) {
15466:
15467: return false;
15468:
15469: }
15470:
15471: private void handleIFEQ(byte[] info) {
15472: execute(InstrConstants.BRANCH_INSTR_TYPE, null, JvmOpCodes.IFEQ);
15473: }
15474:
15475: private java.lang.String tempstr = "";
15476:
15477: private java.lang.String tempString = "";
15478:
15479: private int handleComplexLSTORE() {
15480: return execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.LONG,
15481: JvmOpCodes.LSTORE);
15482: }
15483:
15484: private boolean checkIFLoadInstIsPartOFTernaryCond(int current) {
15485:
15486: return false;
15487: }
15488:
15489: private boolean checkIFNewIsPartOFTernaryCond(int current) {
15490:
15491: return false;
15492: }
15493:
15494: private boolean newfound() {
15495: // return true;
15496: if (GlobalVariableStore.getNewfoundstack().size() > 0)
15497: return true;
15498: return false;
15499: }
15500:
15501: private boolean prevNewPresent() {
15502: if (GlobalVariableStore.getNewfoundstack().size() < 2)
15503: return false;
15504: return true;
15505: }
15506:
15507: private boolean anydupstoreinternarybesidesthis (int current, byte[] info) {
15508: boolean yes = false;
15509: IFBlock iF = getParentIFInTernaryList();
15510: if (iF == null)
15511: return false;
15512: int x = iF.getIfStart() + 3;
15513: ArrayList list = behaviour.getInstructionStartPositions();
15514: while (x < current - 1) {
15515: if (isThisInstrStart(list, x)) {
15516: boolean dup = false;
15517: if (info[x] == JvmOpCodes.DUP || info[x] == JvmOpCodes.DUP2) {
15518: int next = x + 1;
15519: if (isStoreInst(next, info)) {
15520: return true;
15521: }
15522: }
15523: }
15524: x++;
15525:
15526: }
15527:
15528: return yes;
15529:
15530: }
15531:
15532: private IFBlock getParentIFInTernaryList() {
15533:
15534: return null;
15535:
15536: }
15537:
15538: private int getPrevStartOfInst(int current, byte[] info) {
15539: int start = current - 1;
15540: ArrayList list = behaviour.getInstructionStartPositions();
15541: while (start >= 0) {
15542: boolean s = isThisInstrStart(list, start);
15543: if (s)
15544: return start;
15545: start--;
15546: }
15547: return start;
15548: }
15549:
15550: private void handleICONST(int value) {
15551: int opcode;
15552: switch (value) {
15553: case 0:
15554: opcode = JvmOpCodes.ICONST_0;
15555: break;
15556: case 1:
15557: opcode = JvmOpCodes.ICONST_1;
15558: break;
15559: case 2:
15560: opcode = JvmOpCodes.ICONST_2;
15561: break;
15562: case 3:
15563: opcode = JvmOpCodes.ICONST_3;
15564: break;
15565: case 4:
15566: opcode = JvmOpCodes.ICONST_4;
15567: break;
15568: case 5:
15569: opcode = JvmOpCodes.ICONST_5;
15570: break;
15571: default:
15572:
15573: opcode = JvmOpCodes.ICONST_M1;
15574: break;
15575: }
15576: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT, opcode);
15577:
15578: }
15579:
15580: private void handleIDIV() {
15581: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15582: JvmOpCodes.IDIV);
15583: }
15584:
15585: private int handleATHROW(byte[] info) {
15586: return execute(InstrConstants.BRANCH_INSTR_TYPE, null,
15587: JvmOpCodes.ATHROW);
15588: }
15589:
15590: private int handleD2F() {
15591: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15592: JvmOpCodes.D2F);
15593:
15594: }
15595:
15596: private int handleD2I() {
15597: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15598: JvmOpCodes.D2I);
15599: }
15600:
15601: private int handleD2L() {
15602: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
15603: JvmOpCodes.D2L);
15604: }
15605:
15606: private int handleDADD() {
15607: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
15608: JvmOpCodes.DADD);
15609: }
15610:
15611: private int handleDSUB() {
15612: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
15613: JvmOpCodes.DSUB);
15614: }
15615:
15616: private int handleF2D() {
15617: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
15618: JvmOpCodes.F2D);
15619: }
15620:
15621: private int handleF2I() {
15622: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15623: JvmOpCodes.F2I);
15624: }
15625:
15626: private int handleF2L() {
15627: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
15628: JvmOpCodes.F2L);
15629: }
15630:
15631: private int handleFADD() {
15632: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15633: JvmOpCodes.FADD);
15634: }
15635:
15636: private int handleFALOAD() {
15637: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15638: JvmOpCodes.FALOAD);
15639: }
15640:
15641: private int handleFMUL() {
15642: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15643: JvmOpCodes.FMUL);
15644: }
15645:
15646: private int handleFNEG() {
15647: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15648: JvmOpCodes.FNEG);
15649: }
15650:
15651: private int handleFREM() {
15652: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15653: JvmOpCodes.FREM);
15654: }
15655:
15656: private int handleFRETURN() {
15657: return execute(InstrConstants.BRANCH_INSTR_TYPE, null,
15658: JvmOpCodes.FRETURN);
15659: }
15660:
15661: private boolean isSuperClass(java.lang.String someClassName,
15662: java.lang.String currentSuperClass) {
15663: boolean yes = false;
15664: if (someClassName == null || currentSuperClass == null)
15665: return false;
15666: someClassName = someClassName.replaceAll("/", ".").trim();
15667: currentSuperClass = currentSuperClass.replaceAll("/", ".").trim();
15668: if (someClassName.equals(currentSuperClass)) {
15669: return !yes;
15670: }
15671: java.lang.String temp = currentSuperClass;
15672: do {
15673: try {
15674:
15675: Class z = Class.forName(temp + ".class");
15676: Class parent = z.getSuperclass();
15677: if (parent != null) {
15678: if (parent.getName().replaceAll("/", ".").trim().equals(
15679: someClassName)) {
15680: return true;
15681: }
15682: } else {
15683: return false;
15684: }
15685: temp = parent.getName().replaceAll("/", ".").trim();
15686: } catch (ClassNotFoundException cne) {
15687: Writer writer = null;
15688: try {
15689: writer = Writer.getWriter("log");
15690: cne.printStackTrace(writer);
15691: } catch (IOException ex) {
15692:
15693: }
15694:
15695: }
15696: } while (true);
15697:
15698: }
15699:
15700: private void handleIUSHR() {
15701: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15702: JvmOpCodes.IUSHR);
15703: }
15704:
15705: private void handleIXOR() {
15706: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15707: JvmOpCodes.IXOR);
15708: }
15709:
15710: private void handleL2D() {
15711: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.DOUBLE,
15712: JvmOpCodes.L2D);
15713: }
15714:
15715: private void handleL2F() {
15716: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15717: JvmOpCodes.L2F);
15718: }
15719:
15720: private int handleFSUB() {
15721: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.FLOAT,
15722: JvmOpCodes.FSUB);
15723: }
15724:
15725: private int handleGetStatic() {
15726:
15727: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
15728: JvmOpCodes.GETSTATIC);
15729: }
15730:
15731: private void handleI2B() {
15732: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15733: JvmOpCodes.I2B);
15734: }
15735:
15736: private void handleI2C() {
15737: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15738: JvmOpCodes.I2C);
15739: }
15740:
15741: private void handleI2D() {
15742: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15743: JvmOpCodes.I2D);
15744: }
15745:
15746: private void handleI2F() {
15747: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15748: JvmOpCodes.I2F);
15749: }
15750:
15751: private void handleI2L() {
15752: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15753: JvmOpCodes.I2L);
15754: }
15755:
15756: private void handleI2S() {
15757: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15758: JvmOpCodes.I2S);
15759: }
15760:
15761: private void handleIADD() {
15762: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15763: JvmOpCodes.IADD);
15764: }
15765:
15766: private void handleIALOAD() {
15767: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15768: JvmOpCodes.IALOAD);
15769: }
15770:
15771: private void handleIAND() {
15772: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
15773: JvmOpCodes.IAND);
15774: }
15775:
15776: private int handleDRETURN(byte[] info) {
15777: return execute(InstrConstants.BRANCH_INSTR_TYPE, null,
15778: JvmOpCodes.DRETURN);
15779: }
15780:
15781: private void handleIRETURN() {
15782: execute(InstrConstants.BRANCH_INSTR_TYPE, null, JvmOpCodes.IRETURN);
15783: }
15784:
15785: private void checkForBooleanOperandValue(Operand needToCheck, Operand op1) {
15786: java.lang.String type = op1.getLocalVarType();
15787: java.lang.String type2 = op1.getClassType();
15788: if ((type != null && type.trim().equals("boolean"))
15789: || (type2 != null && type2.trim().equals("boolean"))) {
15790: java.lang.String val = needToCheck.getOperandValue();
15791: if (val != null && val.trim().equals("1")) {
15792: needToCheck.setOperandValue("true");
15793: }
15794: if (val != null && val.trim().equals("0")) {
15795: needToCheck.setOperandValue("false");
15796: }
15797:
15798: }
15799:
15800: }
15801:
15802: private int handleIFACMPEQ(byte[] info) {
15803: return execute(InstrConstants.BRANCH_INSTR_TYPE, null,
15804: JvmOpCodes.IF_ACMPEQ);
15805: }
15806:
15807: private boolean checkForInvalidElse(int current, IFBlock ifs, byte[] info) {
15808: boolean add = true;
15809: int ifstart = ifs.getIfStart();
15810: int ifjump = getJumpAddress(info, ifstart);
15811: int from = ifstart + 3;
15812: int till = current - 1;
15813: ArrayList starts = behaviour.getInstructionStartPositions();
15814: for (int z = from; z <= till; z++) {
15815: boolean isStart = isThisInstrStart(starts, z);
15816: if (isStart) {
15817: boolean isif = isInstructionIF(info[z]);
15818: if (isif) {
15819: int jump = getJumpAddress(info, z);
15820: if (jump == ifjump) {
15821: return false;
15822: }
15823: }
15824: if (info[z] == JvmOpCodes.GOTO) {
15825: int jump = getJumpAddress(info, z);
15826: if (jump == ifjump) {
15827: return false;
15828: }
15829: }
15830: }
15831:
15832: }
15833:
15834: return add;
15835: }
15836:
15837: private boolean doesLoopHaveAnIfAtEnd(int i, byte[] info, Loop iloop) {
15838: ArrayList loops = behaviour.getBehaviourLoops();
15839: ArrayList starts = behaviour.getInstructionStartPositions();
15840: for (int z = 0; z < loops.size(); z++) {
15841: Loop loop = (Loop) loops.get(z);
15842: int loopstart = loop.getStartIndex();
15843: if (loopstart == i && loop == iloop) {
15844: int loopend = loop.getEndIndex();
15845: boolean isStart = isThisInstrStart(starts, loopend);
15846: // NOTE: belurs
15847: // No Need to Do this Actually.
15848: // Just checking to be 100% sure that no mistake happens due to
15849: // this
15850: if (isStart) {
15851: boolean isIf = isInstructionIF(info[loopend]);
15852: if (isIf) {
15853: return true;
15854: }
15855: }
15856:
15857: }
15858:
15859: }
15860: return false;
15861: }
15862:
15863: private boolean skipIterationIf_IFEndOfloop(int i, byte[] info) {
15864: ArrayList loops = behaviour.getBehaviourLoops();
15865: ArrayList starts = behaviour.getInstructionStartPositions();
15866: for (Iterator iter = loops.iterator(); iter.hasNext();) {
15867: Loop element = (Loop) iter.next();
15868: int loopEnd = element.getEndIndex();
15869: if (loopEnd == i) {
15870: boolean isStart = isThisInstrStart(starts, loopEnd);
15871: if (isStart) {
15872: boolean isif = isInstructionIF(info[loopEnd]);
15873: if (isif) {
15874: int loopstart = element.getStartIndex();
15875: int ifjump = getJumpAddress(info, i);
15876: if (ifjump == loopstart && (ifjump < i)) {
15877: return false;
15878: // do while loop
15879: }
15880: return true;
15881: }
15882: }
15883:
15884: }
15885:
15886: }
15887:
15888: return false;
15889:
15890: }
15891:
15892: private boolean checkToEvaluateAnyLoopBody(int i, byte[] info) {
15893: boolean eval = true;
15894: ArrayList loops = behaviour.getBehaviourLoops();
15895: ArrayList starts = behaviour.getInstructionStartPositions();
15896: for (Iterator iter = loops.iterator(); iter.hasNext();) {
15897: Loop element = (Loop) iter.next();
15898: int loopEnd = element.getEndIndex();
15899: if (loopEnd == i) {
15900: boolean isStart = isThisInstrStart(starts, loopEnd);
15901: if (isStart) {
15902: boolean isif = isInstructionIF(info[loopEnd]);
15903: if (isif) {
15904: int loopstart = element.getStartIndex();
15905: int ifjump = getJumpAddress(info, i);
15906: if (ifjump == loopstart && (ifjump < i)) {
15907: eval = false;
15908: return eval;
15909: // do while loop
15910: }
15911: eval = true;
15912: return eval;
15913: }
15914: }
15915:
15916: }
15917:
15918: }
15919:
15920: return eval;
15921:
15922: }
15923:
15924: private HashMap ifsbeginends_dowhile = new HashMap();
15925:
15926: private boolean checkForDoWhile(int i, byte[] info, Loop lp) {
15927: ArrayList loops = behaviour.getBehaviourLoops();
15928: ArrayList starts = behaviour.getInstructionStartPositions();
15929: for (Iterator iter = loops.iterator(); iter.hasNext();) {
15930: Loop element = (Loop) iter.next();
15931: int loopEnd = element.getEndIndex();
15932: if (loopEnd == i) {
15933: boolean isStart = isThisInstrStart(starts, loopEnd);
15934: if (isStart) {
15935: boolean isif = isInstructionIF(info[loopEnd]);
15936: if (isif) {
15937: int loopstart = element.getStartIndex();
15938: int ifjump = getJumpAddress(info, i);
15939: StringBuffer le = new StringBuffer();
15940: boolean invalid = isIfConditionForSomeOtherLoop(i,
15941: info, loops, le);
15942: if (ifjump == loopstart && (ifjump < i)) {
15943: if (!invalid) {
15944: boolean loopreset = element.getLoopendreset();
15945: if (!loopreset) {
15946: DowhileHelper dow = new DowhileHelper(
15947: i + 3, element);
15948: boolean present = false;
15949: for (int p = 0; p < doWhileHelperList
15950: .size(); p++) {
15951: DowhileHelper helper = (DowhileHelper) doWhileHelperList
15952: .get(p);
15953: if (helper.getLoop() == element) {
15954: present = true;
15955: break;
15956: }
15957: }
15958: if (!present)
15959: doWhileHelperList.add(dow);
15960: }
15961: if (loopreset) {
15962: int lend = element.getLoopendDueToReset();
15963: ifsbeginends_dowhile.put("" + loopEnd, ""
15964: + lend);
15965: }
15966: return true;
15967: } else {
15968: try {
15969: lp.setEndIndex(Integer.parseInt(le
15970: .toString()));
15971: } catch (NumberFormatException ne) {
15972: return false;
15973: }
15974: return true;
15975: }
15976: // do while loop
15977: }
15978: return false;
15979: }
15980: }
15981:
15982: }
15983:
15984: }
15985:
15986: return false;
15987:
15988: }
15989:
15990: private boolean isIfConditionForSomeOtherLoop(int i, byte[] info,
15991: ArrayList loops, StringBuffer lend) {
15992: ArrayList starts = behaviour.getInstructionStartPositions();
15993: Object[] sortedLoops = sortLoops(loops);
15994: int parentLoopStart = getParentLoopStartForIf(sortedLoops, i);
15995: for (int z = 0; z < loops.size(); z++) {
15996: Loop l = (Loop) loops.get(z);
15997: int end = l.getEndIndex();
15998: boolean start = isThisInstrStart(starts, end);
15999: if (start) {
16000:
16001: int ls = l.getStartIndex();
16002: if (info[end] == JvmOpCodes.GOTO && ls < end && ls < i
16003: && i < end && (parentLoopStart == ls)) {
16004: for (int k = ls; k < end; k++) {
16005: start = isThisInstrStart(starts, k);
16006: if (start) {
16007: boolean isif = isInstructionIF(info[k]);
16008: if (isif) {
16009: if (k == i) {
16010: lend.append("" + end);
16011: return true;
16012: } else {
16013: return false;
16014: }
16015: }
16016: }
16017: }
16018: }
16019: }
16020:
16021: }
16022:
16023: return false;
16024:
16025: }
16026:
16027: private java.lang.String closeDoWhile(int index) {
16028: return LoopHelper.closeDoWhile(index, doWhileHelperList);
16029: }
16030:
16031: private ArrayList doWhileHelperList = new ArrayList();
16032:
16033: public class DowhileHelper {
16034: private boolean closed = false;
16035:
16036: private int index = -1;
16037:
16038: private Loop loop;
16039:
16040: public DowhileHelper(int in, Loop loop) {
16041: index = in;
16042: this .loop = loop;
16043:
16044: }
16045:
16046: public Loop getLoop() {
16047: return loop;
16048: }
16049:
16050: public void setClosed(boolean isClosed) {
16051: closed = isClosed;
16052: }
16053:
16054: public boolean getIsClosed() {
16055: return closed;
16056: }
16057:
16058: public int getIndex() {
16059: return index;
16060: }
16061: }
16062:
16063: /***************************************************************************
16064: * Formerly handleIFStmtAtLoopEnd
16065: *
16066: * @param current
16067: * @param info
16068: * @return
16069: */
16070: private boolean markLoopAsDoWhileType(int current, byte[] info) {
16071: boolean gotoinst = info[current] == JvmOpCodes.GOTO;
16072: ArrayList starts = behaviour.getInstructionStartPositions();
16073: boolean isStart = isThisInstrStart(starts, current);
16074: if (gotoinst && isStart) {
16075: int gotojump = getJumpAddress(info, current);
16076: if (gotojump < current)
16077: return false;
16078: int nextInstPos = current + 3;
16079: boolean someLoopStart = isInstLoopStart(nextInstPos);
16080: if (!someLoopStart)
16081: return false;
16082: for (int k = gotojump; k < info.length; k++) {
16083: boolean b2 = isThisInstrStart(starts, k);
16084: if (b2) {
16085: boolean isif = isInstructionIF(info[k]);
16086: if (isif) {
16087: int offset = getJumpAddress(info, k);
16088: if (offset == nextInstPos) {
16089:
16090: EndOfLoopUtility utilityClass = new EndOfLoopUtility(
16091: current, nextInstPos, k, gotojump, k);
16092: endofLooplist.add(utilityClass);
16093: return true;
16094: } else if (offset > k) {
16095: int ifatend = doesLoopEndAtIf(info, gotojump,
16096: nextInstPos);
16097: if (ifatend != -1) {
16098: EndOfLoopUtility utilityClass = new EndOfLoopUtility(
16099: current, nextInstPos, ifatend,
16100: gotojump, ifatend);
16101: endofLooplist.add(utilityClass);
16102: return true;
16103: } else
16104: return false;
16105: } else {
16106: return false;
16107: }
16108:
16109: }
16110: }
16111: }
16112: return false;
16113:
16114: } else
16115: return false;
16116:
16117: }
16118:
16119: private ArrayList endofLooplist = new ArrayList();
16120:
16121: private boolean isInstLoopStart(int pos) {
16122: ArrayList loops = behaviour.getBehaviourLoops();
16123: for (int z = 0; z < loops.size(); z++) {
16124: Loop loop = (Loop) loops.get(z);
16125: int loopstart = loop.getStartIndex();
16126: if (loopstart == pos) {
16127: return true;
16128: }
16129: }
16130: return false;
16131:
16132: }
16133:
16134: class EndOfLoopUtility {
16135: private int gotostart = -1;
16136:
16137: private int continuepos = -1;
16138:
16139: private int ifpos = -1;
16140:
16141: private int rangeStart = -1;
16142:
16143: private int rangeEnd = -1;
16144:
16145: private boolean rangeVisited = false;
16146:
16147: EndOfLoopUtility(int gotos, int contpos, int IFPOS, int rstart,
16148: int estart) {
16149: gotostart = gotos;
16150: continuepos = contpos;
16151: ifpos = IFPOS;
16152: rangeStart = rstart;
16153: rangeEnd = estart;
16154: }
16155:
16156: public int getContinuepos() {
16157: return continuepos;
16158: }
16159:
16160: public void setContinuepos(int continuepos) {
16161: this .continuepos = continuepos;
16162: }
16163:
16164: public int getGotostart() {
16165: return gotostart;
16166: }
16167:
16168: public void setGotostart(int gotostart) {
16169: this .gotostart = gotostart;
16170: }
16171:
16172: public int getIfpos() {
16173: return ifpos;
16174: }
16175:
16176: public void setIfpos(int ifpos) {
16177: this .ifpos = ifpos;
16178: }
16179:
16180: public int getRangeEnd() {
16181: return rangeEnd;
16182: }
16183:
16184: public void setRangeEnd(int rangeEnd) {
16185: this .rangeEnd = rangeEnd;
16186: }
16187:
16188: public int getRangeStart() {
16189: return rangeStart;
16190: }
16191:
16192: public void setRangeStart(int rangeStart) {
16193: this .rangeStart = rangeStart;
16194: }
16195:
16196: public boolean wasRangeVisited() {
16197: return rangeVisited;
16198: }
16199:
16200: public void setRangeVisited(boolean rangeVisited) {
16201: this .rangeVisited = rangeVisited;
16202: }
16203:
16204: }
16205:
16206: private boolean checkForForLoopIndexReset(int i, StringBuffer resetPos,
16207: byte[] info) {
16208: if (endofLooplist.size() == 0)
16209: return false;
16210: for (int z = 0; z < endofLooplist.size(); z++) {
16211: EndOfLoopUtility utility = (EndOfLoopUtility) endofLooplist.get(z);
16212: int ifpos = utility.getIfpos();
16213: if (ifpos == i) {
16214: boolean isif = isInstructionIF(info[i]);
16215: if (isif) {
16216: int resume = utility.getContinuepos();
16217: if (resume != -1) {
16218: if (info[i] == JvmOpCodes.IFEQ
16219: || info[i] == JvmOpCodes.IFNE) {
16220: java.lang.String val = getReturnTypeIfPreviousInvoke(
16221: i, info);
16222: Operand top = opStack.peekTopOfStack();
16223: if (top != null) {
16224: if (val != null) {
16225: if (val.indexOf("false") != -1) {
16226: val = "boolean";
16227: }
16228: }
16229: top.setClassType(val);
16230: }
16231: }
16232: resetPos.append(resume);
16233: utility.setRangeVisited(true);
16234:
16235: return true;
16236: }
16237: }
16238: }
16239:
16240: }
16241: return false;
16242:
16243: }
16244:
16245: private boolean skipIterationWRTIFSAtEndOFLoop(int i, byte[] info) {
16246: boolean skip = false;
16247: if (endofLooplist.size() == 0)
16248: return false;
16249: ArrayList starts = behaviour.getInstructionStartPositions();
16250: for (int z = 0; z < endofLooplist.size(); z++) {
16251: EndOfLoopUtility utility = (EndOfLoopUtility) endofLooplist.get(z);
16252: int beginRange = utility.getRangeStart();
16253: int endRange = utility.getRangeEnd();
16254: if (i >= beginRange && i < endRange && utility.wasRangeVisited()) {
16255:
16256: // Need to check here for iinc before a iload
16257: boolean isS = isThisInstrStart(starts, i);
16258: if (isS) {
16259: int index = -1;
16260: switch (info[i]) {
16261: case JvmOpCodes.ILOAD:
16262: index = info[(i + 1)];
16263: break;
16264: case JvmOpCodes.ILOAD_0:
16265: index = 0;
16266: break;
16267: case JvmOpCodes.ILOAD_1:
16268: index = 1;
16269: break;
16270: case JvmOpCodes.ILOAD_2:
16271: index = 2;
16272: break;
16273: case JvmOpCodes.ILOAD_3:
16274: index = 3;
16275: break;
16276:
16277: }
16278: if (index != -1) {
16279: int prev = i - 3;
16280: isS = isThisInstrStart(starts, prev);
16281: if (isS) {
16282: if (info[prev] == JvmOpCodes.IINC) {
16283: int varindex = info[(prev + 1)];
16284: java.lang.String constantStr = "";
16285: int constant = info[(prev + 2)];
16286: java.lang.String varName = "";
16287: if (index == varindex) {
16288: LocalVariable loc = getLocalVariable(
16289: varindex, "load", "int", true,
16290: currentForIndex);
16291: if (loc != null) {
16292: java.lang.String name = loc
16293: .getVarName();
16294: java.lang.String temp = name + "="
16295: + name + "+" + (constant);
16296: behaviour.appendToBuffer(Util
16297: .formatDecompiledStatement("\n"
16298: + temp + ";\n"));
16299: }
16300:
16301: }
16302:
16303: }
16304: }
16305:
16306: }
16307: }
16308:
16309: StringBuffer ifelsecode = new StringBuffer("");
16310: StringBuffer reset = new StringBuffer("");
16311: checkForIFElseEndStatement(info, behaviour.getMethodIfs(), i,
16312: reset, opStack, ifelsecode, "if");
16313:
16314: behaviour.appendToBuffer(ifelsecode.toString());
16315: if (ifelsecode.toString().trim().length() > 0) {
16316: // checkToAddElseAtIFEnd(currentForIndex);
16317: }
16318: return true;
16319: }
16320: if (i == endRange && utility.wasRangeVisited()) {
16321: /***************************************************************
16322: * End Loop Here
16323: */
16324: Iterator loopIterator = behaviour.getBehaviourLoops()
16325: .iterator();
16326: while (loopIterator.hasNext()) {
16327: Loop iloop = (Loop) loopIterator.next();
16328:
16329: if (iloop.getEndIndex() == i) {
16330: if (iloop.wasLoopClosedInCode() == false) {
16331: tempString = "}\n";
16332: behaviour.appendToBuffer(Util
16333: .formatDecompiledStatement(tempString));
16334: iloop.setWasLoopClosedInCode(true);
16335: }
16336:
16337: } else if (iloop.getLoopEndForBracket() == i
16338: && iloop.wasLoopClosedInCode() == false) {
16339:
16340: tempString = "}\n";
16341: behaviour.appendToBuffer(Util
16342: .formatDecompiledStatement(tempString));
16343: iloop.setWasLoopClosedInCode(true);
16344: }
16345:
16346: }
16347:
16348: StringBuffer ifelsecode = new StringBuffer("");
16349: StringBuffer reset = new StringBuffer("");
16350: checkForIFElseEndStatement(info, behaviour.getMethodIfs(), i,
16351: reset, opStack, ifelsecode, "if");
16352: behaviour.appendToBuffer(ifelsecode.toString());
16353: if (ifelsecode.toString().trim().length() > 0) {
16354: // checkToAddElseAtIFEnd(currentForIndex);
16355: }
16356: return true;
16357: }
16358: }
16359: return skip;
16360: }
16361:
16362: private int doesLoopEndAtIf(byte[] info, int from, int lookfor) {
16363: int i = -1;
16364: ArrayList starts = behaviour.getInstructionStartPositions();
16365: for (int z = from; z < info.length; z++) {
16366: boolean start = isThisInstrStart(starts, z);
16367: if (start) {
16368: boolean b = isInstructionIF(info[z]);
16369: if (b) {
16370: int ifo = getJumpAddress(info, z);
16371: // Check 1
16372: if (ifo == lookfor) {
16373: return z;
16374: }
16375:
16376: if (ifo > z) {
16377: int x = ifo - 3;
16378: boolean s = isThisInstrStart(starts, x);
16379: if (s == false) {
16380: return i;
16381: } else {
16382: boolean isif = isInstructionIF(info[x]);
16383: if (isif) {
16384: int offset = getJumpAddress(info, x);
16385: if (offset == lookfor) {
16386: return x;
16387: }
16388: if (offset > x) {
16389: int j = doesLoopEndAtIf(info, ifo, lookfor);
16390: return j;
16391: } else {
16392: return i;
16393: }
16394:
16395: } else {
16396: return i;
16397: }
16398:
16399: }
16400:
16401: }
16402:
16403: }
16404:
16405: }
16406:
16407: }
16408:
16409: return i;
16410: }
16411:
16412: private boolean isItoktoendifelse(int i) {
16413: boolean ok = true;
16414: if (endofLooplist.size() == 0)
16415: return ok;
16416: for (int z = 0; z < endofLooplist.size(); z++) {
16417: EndOfLoopUtility utility = (EndOfLoopUtility) endofLooplist.get(z);
16418: int beginRange = utility.getRangeStart();
16419: int endRange = utility.getRangeEnd();
16420: if (i >= beginRange && i <= endRange && utility.wasRangeVisited()) {
16421: return true;
16422: }
16423: if (i >= beginRange && i <= endRange && !utility.wasRangeVisited()) {
16424: return false;
16425: }
16426:
16427: }
16428:
16429: return ok;
16430: }
16431:
16432: private ArrayList checkForskipWithinSkip(int start, int end, byte[] info) {
16433: ArrayList list = new ArrayList();
16434: ArrayList starts = behaviour.getInstructionStartPositions();
16435: outer: for (int z = start; z < end; z++) {
16436: boolean b = isThisInstrStart(starts, z);
16437: if (b) {
16438: if (info[z] == JvmOpCodes.JSR) {
16439: int jsroffset = getJumpAddress(info, z);
16440: if (jsroffset < end) {
16441: int jvmCode = info[jsroffset];
16442: int next = -1;
16443: if (jvmCode == JvmOpCodes.ASTORE) {
16444: next = jsroffset + 2;
16445: } else if (jvmCode == JvmOpCodes.ASTORE_0) {
16446: next = jsroffset + 1;
16447: }
16448:
16449: else if (jvmCode == JvmOpCodes.ASTORE_1) {
16450: next = jsroffset + 1;
16451: }
16452:
16453: else if (jvmCode == JvmOpCodes.ASTORE_2) {
16454: next = jsroffset + 1;
16455: }
16456:
16457: else if (jvmCode == JvmOpCodes.ASTORE_3) {
16458: next = jsroffset + 1;
16459: }
16460: if (next != -1) {
16461: for (int k1 = next; k1 < end; k1++) {
16462: b = isThisInstrStart(starts, k1);
16463: if (b) {
16464: if (info[k1] == JvmOpCodes.GOTO
16465: || info[k1] == JvmOpCodes.RET) {
16466: break outer;
16467: }
16468: list.add(new Integer(k1));
16469: }
16470:
16471: }
16472:
16473: }
16474:
16475: }
16476:
16477: }
16478:
16479: }
16480:
16481: }
16482:
16483: return list;
16484: }
16485:
16486: private boolean skipGetStaticCall(byte[] info) {
16487: int n = currentForIndex + 3;
16488: if (n >= info.length)
16489: return false;
16490: int l = info.length;
16491: ArrayList starts = behaviour.getInstructionStartPositions();
16492: if (info[n] == JvmOpCodes.DUP || info[n] == JvmOpCodes.DUP2) {
16493: n = n + 1;
16494: boolean b = isThisInstrStart(starts, n);
16495: if (b) {
16496:
16497: boolean isif = info[n] == JvmOpCodes.IFNONNULL;
16498: if (isif) {
16499: int j = getJumpAddress(info, n);
16500: if (j < n)
16501: return false;
16502: boolean ok = isThisInstrStart(starts, j);
16503: if (ok) {
16504: ok = info[j] == JvmOpCodes.AASTORE;
16505: if (ok) {
16506: for (int x = n + 3; x < l; x++) {
16507: boolean b2 = isThisInstrStart(starts, x);
16508: if (b2) {
16509: if (info[x] == JvmOpCodes.LDC) {
16510:
16511: int offset = info[x + 1];
16512: if (offset < 0)
16513: offset += 256;
16514: CPString constString = cd
16515: .getStringsAtCPoolPosition(offset);
16516: if (constString == null) {
16517: return false;
16518: }
16519: java.lang.String stringLiteral = cd
16520: .getUTF8String(constString
16521: .getUtf8pointer());
16522: if (stringLiteral == null) {
16523: return false;
16524: }
16525: StringBuffer sb = new StringBuffer("");
16526: Util.checkForImport(stringLiteral, sb);
16527: java.lang.String classToLoad = sb
16528: .toString()
16529: + ".class";
16530: Operand op = new Operand();
16531: op.setOperandValue(classToLoad);
16532: opStack.push(op);
16533: op.setClassType("Class");
16534: GlobalVariableStore
16535: .getSkipWRTClassLoadIf()
16536: .put(
16537: new Integer(
16538: currentForIndex + 3),
16539: new Integer(j));
16540: GlobalVariableStore
16541: .getSkipWRTClassLoadIfUpperLimits()
16542: .add(new Integer(j));
16543: return true;
16544:
16545: }
16546: if (info[x] == JvmOpCodes.LDC_W) {
16547: int offset = getOffset(info, x);
16548: CPString constString = cd
16549: .getStringsAtCPoolPosition(offset);
16550: if (constString == null) {
16551: return false;
16552: }
16553: java.lang.String stringLiteral = cd
16554: .getUTF8String(constString
16555: .getUtf8pointer());
16556: if (stringLiteral == null) {
16557: return false;
16558: }
16559:
16560: Operand op = new Operand();
16561: StringBuffer sb = new StringBuffer("");
16562: Util.checkForImport(stringLiteral, sb);
16563: java.lang.String classToLoad = sb
16564: .toString()
16565: + ".class";
16566: op.setOperandValue(classToLoad);
16567: opStack.push(op);
16568: op.setClassType("Class");
16569: GlobalVariableStore
16570: .getSkipWRTClassLoadIf()
16571: .put(
16572: new Integer(
16573: currentForIndex + 3),
16574: new Integer(j));
16575: GlobalVariableStore
16576: .getSkipWRTClassLoadIfUpperLimits()
16577: .add(new Integer(j));
16578: return true;
16579: }
16580:
16581: }
16582:
16583: }
16584:
16585: }
16586: }
16587: }
16588:
16589: }
16590: }
16591: return false;
16592:
16593: }
16594:
16595: private boolean skipExceptionTables(int i) {
16596: if (GlobalVariableStore.getSkipWRTClassLoadIfUpperLimits().contains(
16597: new Integer(i))) {
16598: return true;
16599: } else
16600: return false;
16601: }
16602:
16603: // j-->monitorexit pos in code
16604: private boolean confirmSynchronizedSkip(byte[] info, int j) {
16605: boolean ok = false;
16606: j = j - 1;
16607: ArrayList starts = behaviour.getInstructionStartPositions();
16608: for (; j >= 0; j--) {
16609: if (isThisInstrStart(starts, j)
16610: && info[j] == JvmOpCodes.MONITORENTER) {
16611: break;
16612: }
16613: if (isThisInstrStart(starts, j)
16614: && info[j] == JvmOpCodes.MONITOREXIT) {
16615: ok = true;
16616: break;
16617: }
16618: }
16619: return ok;
16620:
16621: }
16622:
16623: private ExceptionTable getSynchTableGivenEnd(ArrayList synchlist, int endpc) {
16624:
16625: ExceptionTable table = null;
16626: for (Iterator iter = synchlist.iterator(); iter.hasNext();) {
16627: ExceptionTable element = (ExceptionTable) iter.next();
16628: if (element.getEndPC() == endpc) {
16629: table = element;
16630: break;
16631: }
16632: }
16633: return table;
16634:
16635: }
16636:
16637: private void checkForAthrowAtSynchEnd(int end) {
16638: boolean athrow = false;
16639: ArrayList starts = behaviour.getInstructionStartPositions();
16640: byte[] code = behaviour.getCode();
16641: boolean isstart = isThisInstrStart(starts, end);
16642: OperandStack opStack = behaviour.getOpStack();
16643: if (isstart) {
16644: if (code[end] == JvmOpCodes.ATHROW) {
16645:
16646: boolean x = addATHROWOutput(end);
16647: if (opStack.size() > 0 && x) {
16648: Operand op = (Operand) opStack.pop();
16649: opStack.push(op);
16650: java.lang.String tempString = "throw "
16651: + op.getOperandValue() + ";\n";
16652: behaviour
16653: .appendToBuffer((Util
16654: .formatDecompiledStatement("\n"
16655: + tempString + "\n")));
16656: GlobalVariableStore.getAthrowmap().put(new Integer(end),
16657: "true");
16658: }
16659: }
16660: }
16661:
16662: }
16663:
16664: private boolean isLocalVariableWithNameAlreadyPresent(
16665: java.lang.String name, ArrayList list) {
16666: boolean b = false;
16667: for (Iterator iter = list.iterator(); iter.hasNext();) {
16668: LocalVariable element = (LocalVariable) iter.next();
16669: if (element.getVarName().equals(name)) {
16670: b = true;
16671: break;
16672: }
16673: }
16674: return b;
16675: }
16676:
16677: private boolean caseObjectAddedToSortedArray(Case current, ArrayList sorted) {
16678: boolean b = false;
16679: for (Iterator iter = sorted.iterator(); iter.hasNext();) {
16680: Case element = (Case) iter.next();
16681: if (element == current) {
16682: b = true;
16683: break;
16684: }
16685:
16686: }
16687: return b;
16688: }
16689:
16690: /**
16691: * This method checks whether more than one case starts at the same code
16692: * index.
16693: *
16694: * @param allcases
16695: * @param start
16696: * @return
16697: */
16698:
16699: private boolean checkForMultipleCases(Switch switchblk, ArrayList allcases,
16700: int start, StringBuffer sb) {
16701: int count = 0;
16702: for (int z = 0; z < allcases.size(); z++) {
16703: Case c = (Case) allcases.get(z);
16704: if (c.getCaseStart() == start) {
16705: count++;
16706: }
16707: }
16708: if (start == switchblk.getDefaultStart())
16709: count++;
16710: sb.append(count);
16711: if (count > 1) {
16712: return true;
16713: } else
16714: return false;
16715: }
16716:
16717: private java.lang.String getMultipleCaseStartAsString(Switch switchblk,
16718: ArrayList allcases, int start, StringBuffer sb) {
16719: int total = Integer.parseInt(sb.toString());
16720: java.lang.String s = "";
16721: int count = 0;
16722: Iterator iter;
16723: boolean brackedOpened = false;
16724: boolean added = false;
16725: for (iter = allcases.iterator(); iter.hasNext();) {
16726: Case element = (Case) iter.next();
16727: if (element.getCaseStart() == start) {
16728: if (element.isUsedinmultipleCaseCase())
16729: return "";
16730: count++;
16731: if (count == total && switchblk.getDefaultStart() != start) {
16732: if (!element.isWasCaseStartedPrinted()) {
16733: s += "case " + element.getCaseLabel() + ":\n{\n";
16734: element.setWasCaseStartedPrinted(true);
16735: brackedOpened = true;
16736: }
16737: casefound = true;
16738: added = true;
16739: } else {
16740: if (!element.isWasCaseStartedPrinted()) {
16741: s += "case " + element.getCaseLabel() + ": \n";
16742: element.setWasCaseStartedPrinted(true);
16743: element.setDoNotClose(true);
16744: }
16745: casefound = true;
16746: added = true;
16747: }
16748: element.setUsedinmultipleCaseCase(true);
16749:
16750: }
16751: }
16752:
16753: if (added) {
16754: if (brackedOpened) {
16755: if (switchblk.getDefaultStart() == start
16756: && !switchblk.isDefaultStarted()) {
16757: s = "default:\n" + s;
16758: switchblk.setDefaultStarted(true);
16759: switchblk.setDoNotCloseDefault(true);
16760: }
16761: } else {
16762: if (switchblk.getDefaultStart() == start
16763: && !switchblk.isDefaultStarted()) {
16764: s = s + "default:\n{\n";
16765: switchblk.setDefaultStarted(true);
16766: }
16767: }
16768: }
16769: return s;
16770: }
16771:
16772: private void addAnyAThorwAtDefaultEnd(int i, OperandStack opStack,
16773: byte[] info, StringBuffer S) {
16774:
16775: ArrayList starts = behaviour.getInstructionStartPositions();
16776: boolean b = isThisInstrStart(starts, i);
16777: if (b) {
16778: if (info[i] == JvmOpCodes.ATHROW) {
16779: if (opStack.size() > 0) {
16780: Operand op = opStack.getTopOfStack();
16781: java.lang.String str = op.getOperandValue();
16782: S.append("throw " + str + ";\n");
16783: GlobalVariableStore.getAthrowmap().put(new Integer(i),
16784: "true");
16785: }
16786:
16787: }
16788: }
16789:
16790: }
16791:
16792: private void addAnyAThorwAtDefaultEnd(int i, OperandStack opStack,
16793: byte[] info) {
16794:
16795: ArrayList starts = behaviour.getInstructionStartPositions();
16796: boolean b = isThisInstrStart(starts, i);
16797: if (b) {
16798: if (info[i] == JvmOpCodes.ATHROW) {
16799: if (opStack.size() > 0) {
16800: Operand op = opStack.getTopOfStack();
16801: java.lang.String str = op.getOperandValue();
16802: behaviour.appendToBuffer(Util
16803: .formatDecompiledStatement("throw " + str + ";\n"));
16804: GlobalVariableStore.getAthrowmap().put(new Integer(i),
16805: "true");
16806: }
16807:
16808: }
16809: }
16810:
16811: }
16812:
16813: private boolean OKToAddReturn(int i) {
16814: boolean oktoadd = true;
16815: Iterator mapIT = GlobalVariableStore.getReturnsAtI().entrySet()
16816: .iterator();
16817: while (mapIT.hasNext()) {
16818: Map.Entry entry = (Map.Entry) mapIT.next();
16819: Object key = entry.getKey();
16820: Object retStatus = entry.getValue().toString();
16821: if (key instanceof Integer) {
16822: Integer pos = (Integer) key;
16823: int temp = pos.intValue();
16824: if (temp == i) {
16825: if (retStatus.equals("true")) {
16826:
16827: oktoadd = false;
16828: break;
16829: }
16830: }
16831: }
16832:
16833: }
16834: return oktoadd;
16835: }
16836:
16837: private int handleDUPX2() {
16838: return execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
16839: JvmOpCodes.DUP_X2);
16840:
16841: }
16842:
16843: private int handleDUP2X1(OperandStack opStack) {
16844: return execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
16845: JvmOpCodes.DUP2_X1);
16846: }
16847:
16848: private int handleDUP2(OperandStack opStack) {
16849: // boolean
16850: // dupStoreForTerIf=isThisDUPSTOREAtEndOFTernaryIF(currentForIndex,info,"dup");
16851: return execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
16852: JvmOpCodes.DUP2);
16853: }
16854:
16855: // Change
16856: private int handleDUP(OperandStack opStack) {
16857: // boolean
16858: // dupStoreForTerIf=isThisDUPSTOREAtEndOFTernaryIF(currentForIndex,info,"dup");
16859: return execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
16860: JvmOpCodes.DUP);
16861: }
16862:
16863: private int handleDUPX1(OperandStack opStack) {
16864: return execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
16865: JvmOpCodes.DUP_X1);
16866: }
16867:
16868: private boolean checkForPostIncrSkip(int arr[], int i) {
16869: if (arr == null)
16870: return false;
16871: for (int j = 0; j < arr.length; j++) {
16872:
16873: int temp = arr[j];
16874: if (temp == i)
16875: return true;
16876: }
16877: return false;
16878:
16879: }
16880:
16881: private int handleComplexLLOAD(OperandStack opStack, byte[] info,
16882: int current) {
16883: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
16884: JvmOpCodes.LLOAD);
16885: }
16886:
16887: private boolean curBrackedClosed = false; // Used in association with
16888:
16889: // checkClosingBracketRuleForShortCutOp
16890:
16891: private HashMap openbracketmap = new HashMap();
16892:
16893: private boolean checkClosingBracketRuleForShortCutOp(int current,
16894: byte[] info, int bytecodeend, int startofif, StringBuffer matchingif) {
16895: boolean close = false; // todo: refactor to true
16896: ArrayList starts = behaviour.getInstructionStartPositions();
16897: int be = bytecodeend;
16898: int j = be - 3;
16899: boolean isstart = isThisInstrStart(starts, j);
16900: if (isstart) {
16901: boolean isif = isInstructionIF(info[j]);
16902: if (isif) {
16903: StringBuffer pos = new StringBuffer();
16904: if ((startofif + 3) > j) {
16905: // matchingif.append(""+startofif);
16906: return !close;
16907: }
16908: boolean ifinrange = checkForIfInRange(info, (startofif + 3), j,
16909: pos, starts);
16910: if (ifinrange) {
16911: try {
16912: int ifpos = Integer.parseInt(pos.toString());
16913: int jump = getJumpAddress(info, ifpos);
16914: if (jump == be) {
16915: matchingif.append("" + ifpos);
16916: return close;
16917: } else {
16918: // if(curBrackedClosed==false)
16919: // {
16920: // curBrackedClosed=true;
16921: return !close;
16922: // }
16923: }
16924:
16925: } catch (Exception ne) {
16926: return close;
16927: }
16928:
16929: } else {
16930: if (isThisInstrStart(starts, j) && isInstructionIF(info[j])) {
16931: try {
16932: // 1int ifpos=Integer.parseInt(pos.toString());
16933: matchingif.append("" + j);
16934: } catch (Exception n) {
16935: }
16936: }
16937: return close;
16938: }
16939:
16940: } else {
16941: StringBuffer pos = new StringBuffer();
16942: boolean ifinrange = checkForIfInRange(info, (startofif + 3), j,
16943: pos, starts);
16944: if (ifinrange) {
16945: try {
16946: int ifpos = Integer.parseInt(pos.toString());
16947: int jump = getJumpAddress(info, ifpos);
16948: if (jump == be) {
16949: int p = startofif + 3;
16950: for (int y = startofif - 1; y >= 0; y--) {
16951: boolean st1 = isThisInstrStart(starts, y);
16952: if (st1) {
16953: boolean if1 = isInstructionIF(info[y]);
16954: if (if1) {
16955: int jmp1 = getJumpAddress(info, y);
16956: if (jmp1 == p) {
16957: return !close;
16958: }
16959:
16960: }
16961: }
16962: }
16963: matchingif.append("" + ifpos);
16964: return close;
16965: } else {
16966: // if(curBrackedClosed==false)
16967: // {
16968: // curBrackedClosed=true;
16969: return !close;
16970: // }
16971: }
16972:
16973: } catch (Exception ne) {
16974: return close;
16975: }
16976: } else {
16977: return !close;
16978: }
16979:
16980: }
16981:
16982: }
16983:
16984: return close;
16985: }
16986:
16987: /**
16988: *
16989: * @param info
16990: * @param from
16991: * --> inclusive
16992: * @param end
16993: * --> exclusive
16994: * @param pos
16995: * --> if pos if any
16996: * @return
16997: */
16998:
16999: private boolean checkForIfInRange(byte[] info, int from, int end,
17000: StringBuffer pos, ArrayList starts) {
17001:
17002: for (int z = from; z < end && z < info.length; z++) {
17003: boolean start = isThisInstrStart(starts, z);
17004: if (start) {
17005: boolean isif = isInstructionIF(info[z]);
17006: if (isif) {
17007: pos.append("" + z);
17008: return true;
17009: }
17010:
17011: }
17012:
17013: }
17014: return false;
17015: }
17016:
17017: private boolean checkForAnyIFWithDifferentIndex(byte[] info, int from,
17018: int end, StringBuffer pos, ArrayList starts) {
17019:
17020: ArrayList temp = new ArrayList();
17021: for (int z = from; z < end && z < info.length; z++) {
17022: boolean start = isThisInstrStart(starts, z);
17023: if (start) {
17024: boolean isif = isInstructionIF(info[z]);
17025: if (isif) {
17026: temp.add("" + z);
17027: // return true;
17028: }
17029:
17030: }
17031:
17032: }
17033: int cj = getJumpAddress(info, currentForIndex);
17034: for (int k = 0; k < temp.size(); k++) {
17035:
17036: int in = Integer.parseInt((java.lang.String) temp.get(k));
17037: int j = getJumpAddress(info, in);
17038: if (j != cj) {
17039: pos.append("" + (java.lang.String) temp.get(k));
17040: return true;
17041: }
17042: }
17043: if (temp.size() > 0) {
17044: pos.append("" + (java.lang.String) temp.get(0));
17045: return true;
17046: }
17047: return false;
17048: }
17049:
17050: private boolean confirmOpenBracket(int mifpos, byte[] info, int be,
17051: int ifstart, IFBlock anIf) {
17052: boolean ok = true;
17053: int x = ifstart + 3;
17054: ArrayList starts = behaviour.getInstructionStartPositions();
17055: StringBuffer matchingIf = new StringBuffer();
17056: int mpos = -1;
17057:
17058: outerWhile: while (x < mifpos) {
17059: boolean instSt = isThisInstrStart(starts, x);
17060: boolean isif = isInstructionIF(info[x]);
17061: if (instSt && isif) {
17062: boolean b = checkClosingBracketRuleForShortCutOp(
17063: currentForIndex, info, anIf.getIfCloseFromByteCode(),
17064: anIf.getIfStart(), matchingIf);
17065: if (b == false) {
17066: while (true) {
17067: try {
17068: mpos = Integer.parseInt(matchingIf.toString());
17069: int jump = getJumpAddress(info, mpos);
17070: if (jump == be) {
17071: ok = false;
17072: break outerWhile;
17073:
17074: }
17075: matchingIf = new StringBuffer();
17076: boolean b1 = checkClosingBracketRuleForShortCutOp(
17077: currentForIndex, info, getJumpAddress(info,
17078: mpos), mpos, matchingIf);
17079: // if(b1==false)
17080:
17081: } catch (NumberFormatException exp) {
17082: ok = true;
17083: break outerWhile;
17084: }
17085: }
17086: } else {
17087: ok = true;
17088: break outerWhile;
17089: }
17090: } else {
17091: x++;
17092: }
17093:
17094: }
17095:
17096: return ok;
17097: }
17098:
17099: private HashMap openCloseBracketMap = new HashMap();
17100:
17101: private boolean addOpenBracket(byte[] info, IFBlock ifst) {
17102: ArrayList starts = behaviour.getInstructionStartPositions();
17103: int prev = ifst.getIfCloseFromByteCode() - 3;
17104: boolean isStart = isThisInstrStart(starts, prev);
17105: if (isStart == false)
17106: return false;
17107: StringBuffer mif = new StringBuffer();
17108: boolean close = checkClosingBracketRuleForShortCutOp(currentForIndex,
17109: info, ifst.getIfCloseFromByteCode(), ifst.getIfStart(), mif);
17110: boolean open = !close;
17111: boolean oktoopen = false;
17112: if (open) {
17113: Object ob = openbracketmap.get("" + ifst.getIfStart());
17114: if (ob == null) {
17115: // confirm before adding
17116: try {
17117: int imif = Integer.parseInt(mif.toString());
17118: boolean z = confirmOpenBracket(imif, info, ifst
17119: .getIfCloseFromByteCode(), ifst.getIfStart(), ifst);
17120: if (z) {
17121: openbracketmap.put("" + ifst.getIfStart(), "true");
17122: int e = getBracketClose(ifst.getIfCloseFromByteCode(),
17123: info, ifst.getIfStart(), imif);
17124: openCloseBracketMap.put("" + e, ""
17125: + ifst.getIfCloseFromByteCode());
17126: oktoopen = true;
17127: }
17128: } catch (Exception ne) {
17129: // openbracketmap.put(""+ifst.getIfCloseFromByteCode(),"true");
17130: // int
17131: // e=getBracketClose(ifst.getIfCloseFromByteCode(),info,ifst.getIfStart());
17132:
17133: // openCloseBracketMap.put(""+e,""+ifst.getIfCloseFromByteCode());
17134: oktoopen = false;
17135: }
17136:
17137: } else {
17138: // nothing to do
17139: }
17140:
17141: }
17142: return oktoopen;
17143: }
17144:
17145: // when close value is known
17146: private boolean addOpenBracket(byte[] info, IFBlock ifst, boolean close,
17147: StringBuffer mif) {
17148: ArrayList starts = behaviour.getInstructionStartPositions();
17149: int prev = ifst.getIfCloseFromByteCode() - 3;
17150: boolean isStart = isThisInstrStart(starts, prev);
17151: if (isStart == false)
17152: return false;
17153:
17154: boolean open = !close;
17155: boolean oktoopen = false;
17156: if (open) {
17157: Object ob = openbracketmap.get("" + ifst.getIfStart());
17158: if (ob == null) {
17159: // confirm before adding
17160: try {
17161: int imif = Integer.parseInt(mif.toString());
17162: boolean z = confirmOpenBracket(imif, info, ifst
17163: .getIfCloseFromByteCode(), ifst.getIfStart(), ifst);
17164: if (z) {
17165: openbracketmap.put("" + ifst.getIfStart(), "true");
17166: int e = getBracketClose(ifst.getIfCloseFromByteCode(),
17167: info, ifst.getIfStart(), imif);
17168: openCloseBracketMap.put("" + e, ""
17169: + ifst.getIfCloseFromByteCode());
17170: oktoopen = true;
17171: }
17172: } catch (Exception ne) {
17173: // openbracketmap.put(""+ifst.getIfCloseFromByteCode(),"true");
17174: // int
17175: // e=getBracketClose(ifst.getIfCloseFromByteCode(),info,ifst.getIfStart());
17176: // openCloseBracketMap.put(""+e,""+ifst.getIfCloseFromByteCode());
17177: oktoopen = false;
17178: }
17179:
17180: } else {
17181: // nothing to do
17182: }
17183:
17184: }
17185: return oktoopen;
17186: }
17187:
17188: private int getBracketClose(int be, byte[] info, int ifs, int imif)
17189: throws Exception {
17190: int x = be - 3;
17191: ArrayList starts = behaviour.getInstructionStartPositions();
17192: boolean st = isThisInstrStart(starts, x);
17193: boolean brClose = false;
17194: int initalStart = imif;
17195: if (st) {
17196: do {
17197: StringBuffer match = new StringBuffer();
17198: int bye = getJumpAddress(info, imif);
17199: brClose = checkClosingBracketRuleForShortCutOp(imif, info, bye,
17200: imif, match);
17201: if (brClose) {
17202: int jump = bye;
17203: return jump;
17204: } else {
17205: try {
17206: imif = Integer.parseInt(match.toString());
17207: } catch (Throwable t) {
17208: throw new Exception();
17209: }
17210: }
17211:
17212: // to prevent any infinite loop
17213: if (imif <= initalStart) {
17214: throw new Exception();
17215: }
17216: } while (brClose == false && imif < be);
17217:
17218: /*
17219: * boolean isif=isInstructionIF(info[x]); if(isif) { int
17220: * jump=getJumpAddress(info,x); return jump; } else { x--; for(;x
17221: * >ifs ;x--) { st=isThisInstrStart(starts,x); if(st) {
17222: * isif=isInstructionIF(info[x]); if(isif) { int
17223: * jump=getJumpAddress(info,x); return jump; } } } }
17224: */
17225: }
17226:
17227: throw new Exception();
17228: // return be; // because we are adding bracket in calling method
17229: // something wrong here.
17230: }
17231:
17232: private void handleISHL(OperandStack opStack) {
17233: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
17234: JvmOpCodes.ISHL);
17235: }
17236:
17237: private void handleISHR(OperandStack opStack) {
17238: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.INT,
17239: JvmOpCodes.ISHR);
17240: }
17241:
17242: private Loop getLoopGivenEnd(int end, ArrayList loops) {
17243: for (int z = 0; z < loops.size(); z++) {
17244: Loop l = (Loop) loops.get(z);
17245: if (l.getEndIndex() == end)
17246: return l;
17247: }
17248: return null;
17249: }
17250:
17251: private void handlePUTSTATIC(byte[] info, int i, OperandStack opStack) {
17252: execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
17253: JvmOpCodes.PUTSTATIC);
17254: }
17255:
17256: private void handlePUTFIELD(byte[] info, int i, OperandStack opStack) {
17257: execute(InstrConstants.UNCLASSIFIED_INSTR_TYPE, null,
17258: JvmOpCodes.PUTFIELD);
17259: }
17260:
17261: private void handleLXOR(byte[] info, OperandStack opStack) {
17262: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
17263: JvmOpCodes.LXOR);
17264: }
17265:
17266: private void handleLUSHR(byte[] info, OperandStack opStack) {
17267: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
17268: JvmOpCodes.LUSHR);
17269: }
17270:
17271: private void handleLSUB(byte[] info, OperandStack opStack) {
17272: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
17273: JvmOpCodes.LSUB);
17274:
17275: }
17276:
17277: private void handleLSHR(byte[] info, OperandStack opStack) {
17278: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
17279: JvmOpCodes.LSHR);
17280: }
17281:
17282: private int handleNEW(byte[] info, OperandStack opStack, int i) {
17283: return execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.OBJECT,
17284: JvmOpCodes.NEW);
17285: }
17286:
17287: private void checkForChangeInBranchLabels(IFBlock ifst) {
17288:
17289: Iterator it = GlobalVariableStore.getBranchLabels().entrySet()
17290: .iterator();
17291: DecompilerHelper.BranchLabel reqd = null;
17292: while (it.hasNext()) {
17293: Map.Entry e = (Map.Entry) it.next();
17294: int end = ((Integer) (e.getValue())).intValue();
17295: DecompilerHelper.BranchLabel b = (DecompilerHelper.BranchLabel) e
17296: .getKey();
17297: IFBlock IF = b.getIF();
17298: if (IF == ifst) {
17299: reqd = b;
17300: break;
17301: }
17302:
17303: }
17304: if (reqd != null) {
17305: GlobalVariableStore.getBranchLabels().remove(reqd);
17306: GlobalVariableStore.getBranchLabels().put(reqd,
17307: new Integer(ifst.getIfCloseLineNumber()));
17308: }
17309: }
17310:
17311: private boolean okToEndIfElseWithContinueOrReturn(int end, IFBlock ifst) {
17312:
17313: ArrayList loops = behaviour.getBehaviourLoops();
17314: ArrayList starts = behaviour.getInstructionStartPositions();
17315: boolean isloopend = false;
17316: Loop someloop = null;
17317: int prevs = getPrevStartCodePos(behaviour.getCode(), end);
17318: for (int z = 0; z < loops.size(); z++) {
17319: Loop l = (Loop) loops.get(z);
17320: int loopend = (l).getEndIndex();
17321: if (loopend == end || loopend == prevs) {
17322: isloopend = true;
17323: someloop = l;
17324: break;
17325: }
17326:
17327: }
17328: if (someloop != null) {
17329: boolean closed = someloop.wasLoopClosedInCode();
17330: if (closed) {
17331: int ifstart = ifst.getIfStart();
17332: Object[] sortedLoops = sortLoops(loops);
17333: Loop parent = getParentLoopForIf(sortedLoops, ifst.getIfStart());
17334: if (parent == someloop) {
17335: return false;
17336: }
17337: }
17338: }
17339: return true;
17340: }
17341:
17342: private Case checkForEnclosingSwitchCase(byte[] info, IFBlock ifst,
17343: int currentForIndex) {
17344:
17345: ArrayList switches = behaviour.getAllSwitchBlks();
17346: if (switches == null || switches.size() == 0)
17347: return null;
17348: int ifstart = ifst.getIfStart();
17349: HashMap caseblk_cends = new HashMap();
17350: for (int z = 0; z < switches.size(); z++) {
17351:
17352: Switch s = (Switch) switches.get(z);
17353: ArrayList cases = s.getAllCases();
17354:
17355: for (int k = 0; k < cases.size(); k++) {
17356:
17357: Case c = (Case) cases.get(k);
17358: int cs = c.getCaseStart();
17359: int ce = c.getCaseEnd();
17360: if (ifstart > cs && ifstart < ce) {
17361: caseblk_cends.put(new Integer(cs), c);
17362: }
17363:
17364: }
17365:
17366: }
17367: if (caseblk_cends.size() > 0) {
17368: Set keys = caseblk_cends.keySet();
17369: Integer sortedkeys[] = (Integer[]) keys.toArray(new Integer[keys
17370: .size()]);
17371: Arrays.sort(sortedkeys);
17372: int len = sortedkeys.length;
17373: Integer in = sortedkeys[len - 1];
17374: return (Case) caseblk_cends.get(in);
17375: }
17376:
17377: return null;
17378: }
17379:
17380: private int checkForIfEndFromEnclosingSetIfs(byte[] info, IFBlock ifst) {
17381:
17382: Iterator it = behaviour.getMethodIfs().iterator();
17383: int ifstart = ifst.getIfStart();
17384: ArrayList list = new ArrayList();
17385: while (it.hasNext()) {
17386: IFBlock temp = (IFBlock) it.next();
17387: int tempc = temp.getIfCloseLineNumber();
17388: if (temp.getIfStart() < ifstart && ifstart < tempc
17389: && !temp.getDonotclose()) {
17390: list.add(new Integer(tempc));
17391: }
17392: }
17393: if (list.size() > 0) {
17394: Integer in[] = (Integer[]) list.toArray(new Integer[list.size()]);
17395: Arrays.sort(in);
17396: Integer first = in[0];
17397: if (first.intValue() < ifst.getIfCloseLineNumber()) {
17398: return first.intValue();
17399: }
17400: }
17401: return -1;
17402: }
17403:
17404: private void checkToAddElseAtIFEnd(int x) {
17405:
17406: Collection cifs = getCurrentIFStructues();
17407: Iterator cifsIt = cifs.iterator();
17408: while (cifsIt.hasNext()) {
17409:
17410: IFBlock curif = (IFBlock) cifsIt.next();
17411: int start = curif.getIfStart();
17412: boolean loopEndalso = isThisLoopEndAlso(behaviour
17413: .getBehaviourLoops(), currentForIndex, start);
17414: int ifbyj = curif.getIfCloseFromByteCode();
17415: Loop loop = getLoopGivenEnd(currentForIndex, behaviour
17416: .getBehaviourLoops());
17417: if (loopEndalso && loop != null) { // Just double check here with
17418: // loopendalso
17419:
17420: if (ifbyj > currentForIndex && !curif.getDonotclose()) {
17421: boolean addElseHere = addElseStart(currentForIndex);
17422: if (addElseHere) {
17423: tempString = "\nelse\n{\nbreak;\n}\n";
17424: GlobalVariableStore.getElsestartadded().add(
17425: new Integer(currentForIndex));
17426: behaviour.appendToBuffer(Util
17427: .formatDecompiledStatement(tempString));
17428: break;
17429: }
17430: }
17431: }
17432: }
17433: }
17434:
17435: private int getNextIfStart(int x, byte[] code) {
17436:
17437: ArrayList starts = behaviour.getInstructionStartPositions();
17438: for (int z = x + 3; z < code.length; z++) {
17439:
17440: boolean b = isThisInstrStart(starts, z);
17441: if (b) {
17442: b = isInstructionIF(code[z]);
17443: if (b) {
17444: return z;
17445: }
17446: }
17447: }
17448: return -1;
17449: }
17450:
17451: private boolean checkForIfCloseInRange(int firstif, int secif) {
17452:
17453: Collection c = getCurrentIFStructues();
17454: Iterator it = c.iterator();
17455: while (it.hasNext()) {
17456: IFBlock curif = (IFBlock) it.next();
17457: int s = curif.getIfStart();
17458: if (!curif.getDonotclose() && s != firstif && s != secif) {
17459: int ifclose = curif.getIfCloseLineNumber();
17460: if (s < firstif && ifclose > firstif && ifclose < secif) {
17461: return true;
17462: }
17463: }
17464: }
17465: return false;
17466:
17467: }
17468:
17469: private int handleIFACMPNE(byte[] info) {
17470: return execute(InstrConstants.BRANCH_INSTR_TYPE, null,
17471: JvmOpCodes.IF_ACMPNE);
17472: }
17473:
17474: private void handleLASTORE(OperandStack opStack) {
17475: execute(InstrConstants.STORE_INSTR_TYPE, InstrConstants.LONG,
17476: JvmOpCodes.LASTORE);
17477:
17478: }
17479:
17480: private java.lang.String addAnyElseBreakForIFChain(int i) {
17481: for (int z = 0; z < GlobalVariableStore.getElsebreaksforifchain()
17482: .size(); z++) {
17483: int j = ((Integer) GlobalVariableStore.getElsebreaksforifchain()
17484: .get(z)).intValue();
17485: if (i == j) {
17486: String marker = "<elsebreak" + i + ">";
17487: String endmarker = "</elsebreak" + i + ">";
17488: java.lang.String s = "\n" + marker + "else\n{\nbreak;\n}\n"
17489: + endmarker + "\n";
17490: s = Util.formatDecompiledStatement(s);
17491: return s;
17492: }
17493: }
17494: return "";
17495: }
17496:
17497: private void handleLDC(OperandStack opStack, byte[] info, int i) {
17498: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
17499: JvmOpCodes.LDC);
17500: }
17501:
17502: private void handleLDCW(OperandStack opStack, byte[] info, int i) {
17503: execute(InstrConstants.LOAD_INSTR_TYPE, InstrConstants.LONG,
17504: JvmOpCodes.LDC_W);
17505: }
17506:
17507: private boolean checkForEmptyCatch(int start, int end) {
17508: ArrayList starts = behaviour.getInstructionStartPositions();
17509: boolean present = false;
17510: int next = -1;
17511: byte[] info = behaviour.getCode();
17512: if (isThisInstrStart(starts, start)) {
17513: switch (info[start]) {
17514: case JvmOpCodes.ASTORE_0:
17515: case JvmOpCodes.ASTORE_1:
17516: case JvmOpCodes.ASTORE_2:
17517: case JvmOpCodes.ASTORE_3:
17518: present = true;
17519: next = start + 1;
17520: break;
17521: case JvmOpCodes.ASTORE:
17522: present = true;
17523: next = start + 2;
17524: break;
17525: default:
17526: present = false;
17527: break;
17528: }
17529: }
17530: if (next != -1 && present) {
17531: if (next == end) {
17532: return true;
17533: }
17534: }
17535: return false;
17536: }
17537:
17538: private boolean checkForEmptyFinally(byte[] info, int i,
17539: ExceptionTable table) {
17540: ArrayList starts = behaviour.getInstructionStartPositions();
17541: int start = table.getStartOfHandlerForGuardRegion();
17542: int end = table.getEndOfHandlerForGuardRegion();
17543: boolean present = false;
17544: if (info[end] == JvmOpCodes.ATHROW && isThisInstrStart(starts, end)) {
17545:
17546: int prev = getPrevStartCodePos(info, end);
17547: switch (info[prev]) {
17548: case JvmOpCodes.ALOAD_0:
17549: case JvmOpCodes.ALOAD_1:
17550: case JvmOpCodes.ALOAD_2:
17551: case JvmOpCodes.ALOAD_3:
17552: case JvmOpCodes.ALOAD:
17553: present = true;
17554: break;
17555: default:
17556: present = false;
17557: break;
17558: }
17559: if (!present)
17560: return false;
17561: prev = getPrevStartCodePos(info, prev);
17562: present = false;
17563: switch (info[prev]) {
17564: case JvmOpCodes.ASTORE_0:
17565: case JvmOpCodes.ASTORE_1:
17566: case JvmOpCodes.ASTORE_2:
17567: case JvmOpCodes.ASTORE_3:
17568: case JvmOpCodes.ASTORE:
17569: present = true;
17570: break;
17571: default:
17572: present = false;
17573: break;
17574: }
17575: if (!present)
17576: return false;
17577: if (prev == start) {
17578: return true;
17579: }
17580: return false;
17581:
17582: }
17583: return false;
17584: }
17585:
17586: private boolean checkForEmptyFinally(int start, int end) {
17587: ArrayList starts = behaviour.getInstructionStartPositions();
17588: boolean present = false;
17589: byte[] info = behaviour.getCode();
17590: if (info[end] == JvmOpCodes.ATHROW && isThisInstrStart(starts, end)) {
17591:
17592: int prev = getPrevStartCodePos(info, end);
17593: switch (info[prev]) {
17594: case JvmOpCodes.ALOAD_0:
17595: case JvmOpCodes.ALOAD_1:
17596: case JvmOpCodes.ALOAD_2:
17597: case JvmOpCodes.ALOAD_3:
17598: case JvmOpCodes.ALOAD:
17599: present = true;
17600: break;
17601: default:
17602: present = false;
17603: break;
17604: }
17605: if (!present)
17606: return false;
17607: prev = getPrevStartCodePos(info, prev);
17608: present = false;
17609: switch (info[prev]) {
17610: case JvmOpCodes.ASTORE_0:
17611: case JvmOpCodes.ASTORE_1:
17612: case JvmOpCodes.ASTORE_2:
17613: case JvmOpCodes.ASTORE_3:
17614: case JvmOpCodes.ASTORE:
17615: present = true;
17616: break;
17617: default:
17618: present = false;
17619: break;
17620: }
17621: if (!present)
17622: return false;
17623: if (prev == start) {
17624: return true;
17625: }
17626: return false;
17627:
17628: }
17629: return false;
17630: }
17631:
17632: private int execute(java.lang.String instrtype, java.lang.String vartype,
17633: int opcode) {
17634: // System.out.println("Executing at"+currentForIndex);
17635: IInstructionCommandHolder instruction = InstructionHelper
17636: .getInstruction(instrtype, vartype, opcode);
17637: AbstractInstructionCommand command = (AbstractInstructionCommand) instruction
17638: .getCommand();
17639: try {
17640: command.execute();
17641: } catch (Exception e) {
17642: AllExceptionHandler handler = new AllExceptionHandler(e);
17643: handler.setBehaviour(behaviour);
17644: handler.setCodePosition(ExecutionState
17645: .getCurrentInstructionPosition());
17646: handler.reportException();
17647: }
17648: return command.getSkipBytes();
17649: }
17650:
17651:}
|