001: package net.sf.jdec.jvminstructions.commands;
002:
003: import java.util.ArrayList;
004: import java.util.List;
005: import java.util.Stack;
006:
007: import net.sf.jdec.core.DecompilerHelper;
008: import net.sf.jdec.core.GlobalVariableStore;
009: import net.sf.jdec.core.JvmOpCodes;
010: import net.sf.jdec.core.Operand;
011: import net.sf.jdec.core.OperandStack;
012: import net.sf.jdec.reflection.Behaviour;
013: import net.sf.jdec.util.Util;
014:
015: public class LastoreCommand extends AbstractInstructionCommand {
016:
017: public LastoreCommand(Behaviour context) {
018: super (context);
019:
020: }
021:
022: public int getSkipBytes() {
023: return 0;
024: }
025:
026: public void execute() {
027: byte[] info = getCode();
028: Operand op = null;
029: Operand op1 = null;
030: Operand op2 = null;
031: StringBuffer addtype = new StringBuffer();
032: int currentForIndex = getCurrentInstPosInCode();
033: OperandStack opStack = getStack();
034: Behaviour behavior = getContext();
035: boolean primitiveastore = GlobalVariableStore
036: .isPrimitiveastore();
037: int arraytimespush = GlobalVariableStore.getArraytimespush();
038: boolean specialIASTORE = GlobalVariableStore.isSpecialIASTORE();
039: List skipaastores = GlobalVariableStore.getSkipaastores();
040: ArrayList skipPrimitiveArrayStores = GlobalVariableStore
041: .getSkipPrimitiveArrayStores();
042: Stack arraytimesstack = GlobalVariableStore
043: .getArraytimesstack();
044: boolean b = DecompilerHelper.checkForArrayPostIncrement(
045: currentForIndex, opStack, getCode(), "category1",
046: addtype);
047: boolean bl2 = DecompilerHelper
048: .checkForArrayMultiAssignablePostIncrement(
049: currentForIndex, opStack, getCode(),
050: "category1");
051: if (b && opStack.size() > 0 && arraytimesstack.size() == 0) {
052: op = (Operand) opStack.pop();
053: op1 = (Operand) opStack.pop();
054: op2 = (Operand) opStack.pop();
055: java.lang.String temp = "";
056: if (addtype.toString().equals("add"))
057: temp += op2.getOperandValue() + "["
058: + op1.getOperandValue() + "]" + "++";
059: else
060: temp += op2.getOperandValue() + "["
061: + op1.getOperandValue() + "]" + "--";
062: Operand o = opStack.peekTopOfStack();
063: o.setOperandValue(temp);
064:
065: } else if (bl2 && opStack.size() > 0
066: && arraytimesstack.size() == 0) {
067: op = (Operand) opStack.pop();
068: op1 = (Operand) opStack.pop();
069: op2 = (Operand) opStack.pop();
070: java.lang.String temp = "";
071: temp += op2.getOperandValue() + "[" + op1.getOperandValue()
072: + "]" + "=";
073: Operand o = opStack.peekTopOfStack();
074: temp = temp + o.getOperandValue();
075: o.setOperandValue(temp);
076: } else {
077: if (skipPrimitiveArrayStores.contains(new Integer(
078: currentForIndex)) == false) {
079: java.lang.String tempString = "";
080: op = (Operand) opStack.pop();
081: op1 = (Operand) opStack.pop();
082: if (opStack.size() > 0) {
083: op2 = (Operand) opStack.pop();
084: tempString = op2.getOperandValue() + "["
085: + op1.getOperandValue() + "]="
086: + op.getOperandValue() + ";\n";
087: }
088: if (arraytimesstack.size() == 0) {
089:
090: int curpos = currentForIndex;
091: if (curpos - 2 > 0
092: && (info[curpos - 1] == JvmOpCodes.DUP_X2
093: || info[curpos - 1] == JvmOpCodes.DUP
094: || info[curpos - 1] == JvmOpCodes.DUP2
095: || info[curpos - 1] == JvmOpCodes.DUP_X1
096: || info[curpos - 1] == JvmOpCodes.DUP2_X1 || info[curpos - 1] == JvmOpCodes.DUP2_X2)
097: && info[curpos - 2] == JvmOpCodes.LADD) {
098: tempString = "++" + op2.getOperandValue() + "["
099: + op1.getOperandValue() + "]";
100: java.lang.String v1 = op2.getOperandValue()
101: + "[" + op1.getOperandValue() + "]";
102: java.lang.String v2 = opStack.peekTopOfStack()
103: .getOperandValue();
104: if (v2.equals(v1)) {
105: opStack.pop();
106: }
107: opStack.push(createOperand(tempString));
108: specialIASTORE = true;
109: } else if (curpos - 2 > 0
110: && (info[curpos - 1] == JvmOpCodes.DUP_X2
111: || info[curpos - 1] == JvmOpCodes.DUP
112: || info[curpos - 1] == JvmOpCodes.DUP2
113: || info[curpos - 1] == JvmOpCodes.DUP_X1
114: || info[curpos - 1] == JvmOpCodes.DUP2_X1 || info[curpos - 1] == JvmOpCodes.DUP2_X2)
115: && info[curpos - 2] == JvmOpCodes.LSUB) {
116: tempString = "--" + op2.getOperandValue() + "["
117: + op1.getOperandValue() + "]";
118: java.lang.String v1 = op2.getOperandValue()
119: + "[" + op1.getOperandValue() + "]";
120: java.lang.String v2 = opStack.peekTopOfStack()
121: .getOperandValue();
122: if (v2.equals(v1)) {
123: opStack.pop();
124: }
125: opStack.push(createOperand(tempString));
126: specialIASTORE = true;
127: } else if (curpos - 3 > 0
128: && info[curpos - 1] == JvmOpCodes.LADD
129: && info[curpos - 2] == JvmOpCodes.LCONST_1
130: && (info[curpos - 3] == JvmOpCodes.DUP_X2
131: || info[curpos - 3] == JvmOpCodes.DUP
132: || info[curpos - 3] == JvmOpCodes.DUP2
133: || info[curpos - 3] == JvmOpCodes.DUP_X1
134: || info[curpos - 3] == JvmOpCodes.DUP2_X1 || info[curpos - 3] == JvmOpCodes.DUP2_X2)) {
135: tempString = op2.getOperandValue() + "["
136: + op1.getOperandValue() + "]++";
137: java.lang.String v1 = op2.getOperandValue()
138: + "[" + op1.getOperandValue() + "]";
139: java.lang.String v2 = opStack.peekTopOfStack()
140: .getOperandValue();
141: if (v2.equals(v1)) {
142: opStack.pop();
143: }
144: opStack.push(createOperand(tempString));
145: specialIASTORE = true;
146: } else if (curpos - 3 > 0
147: && info[curpos - 1] == JvmOpCodes.LSUB
148: && info[curpos - 2] == JvmOpCodes.LCONST_1
149: && (info[curpos - 3] == JvmOpCodes.DUP_X2
150: || info[curpos - 3] == JvmOpCodes.DUP
151: || info[curpos - 3] == JvmOpCodes.DUP2
152: || info[curpos - 3] == JvmOpCodes.DUP_X1
153: || info[curpos - 3] == JvmOpCodes.DUP2_X1 || info[curpos - 3] == JvmOpCodes.DUP2_X2)) {
154: tempString = op2.getOperandValue() + "["
155: + op1.getOperandValue() + "]--";
156: java.lang.String v1 = op2.getOperandValue()
157: + "[" + op1.getOperandValue() + "]";
158: java.lang.String v2 = opStack.peekTopOfStack()
159: .getOperandValue();
160: if (v2.equals(v1)) {
161: opStack.pop();
162: }
163: opStack.push(createOperand(tempString));
164: specialIASTORE = true;
165: } else {
166: if (skipPrimitiveArrayStores
167: .contains(new Integer(currentForIndex)) == false) {
168: behavior
169: .appendToBuffer(Util
170: .formatDecompiledStatement(tempString));
171: }
172: }
173: } else {
174: primitiveastore = true;
175: java.lang.String newvalue = "";
176: arraytimespush = Integer.parseInt(arraytimesstack
177: .peek().toString());
178: if (arraytimespush > 0) {
179:
180: int curpos = currentForIndex;
181:
182: if (curpos - 2 > 0
183: && DecompilerHelper
184: .isArrayElement(curpos + 1)
185: && (info[curpos - 1] == JvmOpCodes.DUP_X2
186: || info[curpos - 1] == JvmOpCodes.DUP
187: || info[curpos - 1] == JvmOpCodes.DUP2
188: || info[curpos - 1] == JvmOpCodes.DUP_X1
189: || info[curpos - 1] == JvmOpCodes.DUP2_X1 || info[curpos - 1] == JvmOpCodes.DUP2_X2)
190: && info[curpos - 2] == JvmOpCodes.LADD) {
191: if (!newfound())
192: newvalue = "++" + op2.getOperandValue()
193: + "[" + op1.getOperandValue()
194: + "]";
195: else {
196: if (opStack.size() > 0) {
197: java.lang.String topv = opStack
198: .getTopOfStack()
199: .getOperandValue();
200: if (topv.trim().startsWith("++")) {
201: newvalue = op2
202: .getOperandValue()
203: + topv;
204: } else
205: newvalue = "++"
206: + op2.getOperandValue()
207: + topv;
208: if (topv.equals(opStack
209: .peekTopOfStack()
210: .getOperandValue())) {
211: opStack.pop();
212: }
213: }
214: }
215:
216: } else if (curpos - 2 > 0
217: && DecompilerHelper
218: .isArrayElement(curpos + 1)
219: && (info[curpos - 1] == JvmOpCodes.DUP_X2
220: || info[curpos - 1] == JvmOpCodes.DUP
221: || info[curpos - 1] == JvmOpCodes.DUP2
222: || info[curpos - 1] == JvmOpCodes.DUP_X1
223: || info[curpos - 1] == JvmOpCodes.DUP2_X1 || info[curpos - 1] == JvmOpCodes.DUP2_X2)
224: && info[curpos - 2] == JvmOpCodes.LSUB) {
225: if (!newfound())
226: newvalue = "--" + op2.getOperandValue()
227: + "[" + op1.getOperandValue()
228: + "]";
229: else {
230: if (opStack.size() > 0) {
231:
232: java.lang.String topv = opStack
233: .getTopOfStack()
234: .getOperandValue();
235: if (topv.trim().startsWith("--")) {
236: newvalue = op2
237: .getOperandValue()
238: + topv;
239: } else
240: newvalue = "--"
241: + op2.getOperandValue()
242: + topv;//
243: if (topv.equals(opStack
244: .peekTopOfStack()
245: .getOperandValue())) {
246: opStack.pop();
247: }
248:
249: }
250: }
251:
252: } else if (curpos - 3 > 0
253: && DecompilerHelper
254: .isArrayElement(curpos + 1)
255: && info[curpos - 1] == JvmOpCodes.LADD
256: && info[curpos - 2] == JvmOpCodes.LCONST_1
257: && (info[curpos - 3] == JvmOpCodes.DUP_X2
258: || info[curpos - 3] == JvmOpCodes.DUP
259: || info[curpos - 3] == JvmOpCodes.DUP2
260: || info[curpos - 3] == JvmOpCodes.DUP_X1
261: || info[curpos - 3] == JvmOpCodes.DUP2_X1 || info[curpos - 3] == JvmOpCodes.DUP2_X2)) {
262: if (!newfound())
263: newvalue = op2.getOperandValue() + "["
264: + op1.getOperandValue() + "]++";
265: else {
266: if (opStack.size() > 0) {
267:
268: java.lang.String topv = opStack
269: .getTopOfStack()
270: .getOperandValue();
271: newvalue = op2.getOperandValue()
272: + topv + "++";
273: if (topv.equals(opStack
274: .peekTopOfStack()
275: .getOperandValue())) {
276: opStack.pop();
277: }
278:
279: }
280: }
281:
282: } else if (curpos - 3 > 0
283: && DecompilerHelper
284: .isArrayElement(curpos + 1)
285: && info[curpos - 1] == JvmOpCodes.LSUB
286: && info[curpos - 2] == JvmOpCodes.LCONST_1
287: && (info[curpos - 3] == JvmOpCodes.DUP_X2
288: || info[curpos - 3] == JvmOpCodes.DUP
289: || info[curpos - 3] == JvmOpCodes.DUP2
290: || info[curpos - 3] == JvmOpCodes.DUP_X1
291: || info[curpos - 3] == JvmOpCodes.DUP2_X1 || info[curpos - 3] == JvmOpCodes.DUP2_X2)) {
292:
293: if (!newfound())
294: newvalue = op2.getOperandValue() + "["
295: + op1.getOperandValue() + "]--";
296: else {
297: if (opStack.size() > 0) {
298:
299: java.lang.String topv = opStack
300: .getTopOfStack()
301: .getOperandValue();
302: newvalue = op2.getOperandValue()
303: + topv + "--";
304: if (topv.equals(opStack
305: .peekTopOfStack()
306: .getOperandValue())) {
307: opStack.pop();
308: }
309: }
310: }
311:
312: } else
313: newvalue = "";
314: if (newvalue.length() > 0) {
315: StringBuffer v = new StringBuffer("");
316: int c = getGenericFinder()
317: .isNextInstructionConversionInst(
318: currentForIndex + 1, v);
319: if (c != -1
320: && newvalue.indexOf(v.toString()) == -1) {
321: newvalue = "(" + v.toString() + ")"
322: + newvalue;
323: }
324: }
325:
326: // ///////////////
327: if (skipPrimitiveArrayStores
328: .contains(new Integer(currentForIndex)) == false) {
329:
330: if (newfound()) {
331: // z=createOperand(op.getOperandValue());
332: // Operand y=opStack.getTopOfStack();
333: java.lang.String newv = op2
334: .getOperandValue()
335: + op.getOperandValue();
336: if (newvalue.length() > 0) {
337: newv = newvalue;
338: specialIASTORE = true;
339: }
340: arraytimespush = Integer
341: .parseInt(arraytimesstack.pop()
342: .toString());
343: arraytimespush--;
344: if (arraytimespush == 0) {
345: newv += "}";
346: } else {
347: arraytimesstack.push(""
348: + arraytimespush);
349: newv += ",";
350: }
351: opStack.push(createOperand(newv));
352: } else {
353: arraytimespush = Integer
354: .parseInt(arraytimesstack.pop()
355: .toString());
356: arraytimespush--;
357: if (arraytimespush == 0) {
358:
359: boolean closeImmediate = false; // for the
360: // parent
361: // actually
362: if (arraytimesstack.size() > 0) {
363: int oldstacksize = Integer
364: .parseInt(arraytimesstack
365: .pop()
366: .toString());
367: int newstacksize = oldstacksize - 1;
368: if (newstacksize != 0)
369: arraytimesstack.push(""
370: + newstacksize);
371: else
372: closeImmediate = true;
373: // codeStatements+="}";
374: }
375:
376: if (arraytimesstack.isEmpty()) {
377: if (newvalue.length() > 0) {
378: behavior
379: .appendToBuffer(newvalue
380: + "}");
381: int count = arrayClosingBracketCount(currentForIndex);
382: java.lang.String temp = "";
383: for (int z = 1; z <= count; z++) {
384: temp += "\n}";
385: if (z < count)
386: temp += "\n";
387:
388: }
389: // Util.forceNewLine=false;
390: Util.forceTrimLines = false;
391: behavior
392: .appendToBuffer(Util
393: .formatDecompiledStatement(temp)
394: + ";\n");
395: Util.forceNewLine = true;
396: Util.forceTrimLines = true;
397: specialIASTORE = true;
398: } else {
399: behavior.appendToBuffer(op
400: .getOperandValue()
401: + "}");
402: int count = arrayClosingBracketCount(currentForIndex);
403: java.lang.String temp = "";
404: for (int z = 1; z <= count; z++) {
405: temp += "\n}";
406: if (z < count)
407: temp += "\n";
408: }
409: Util.forceStartSpace = false;
410: Util.forceNewLine = false;
411: Util.forceTrimLines = false;
412: behavior
413: .appendToBuffer(Util
414: .formatDecompiledStatement(temp)
415: + ";\n");
416: Util.forceStartSpace = true;
417: Util.forceTrimLines = false;
418: Util.forceNewLine = true;
419: }
420: } else {
421: if (newvalue.length() > 0) {
422: behavior
423: .appendToBuffer(newvalue
424: + "},");
425: specialIASTORE = true;
426: } else {
427: behavior.appendToBuffer(op
428: .getOperandValue()
429: + "},");
430: }
431: if (closeImmediate) {
432: do {
433: Util.forceStartSpace = false;
434: Util.forceNewLine = false;
435: Util.forceTrimLines = false;
436: if (arraytimesstack
437: .size() > 0)
438: behavior
439: .appendToBuffer(Util
440: .formatDecompiledStatement("\n},\n"));
441: else {
442: behavior
443: .appendToBuffer(Util
444: .formatDecompiledStatement("\n};\n"));
445: }
446: Util.forceStartSpace = true;
447: Util.forceNewLine = true;
448: Util.forceTrimLines = true;
449:
450: if (arraytimesstack
451: .size() > 0) {
452: int oldstacksize = Integer
453: .parseInt(arraytimesstack
454: .pop()
455: .toString());
456: int newstacksize = oldstacksize - 1;
457: if (newstacksize != 0) {
458: arraytimesstack
459: .push(""
460: + newstacksize);
461: closeImmediate = false;
462: } else {
463: closeImmediate = true;
464: }
465: } else {
466: closeImmediate = false;
467: }
468:
469: } while (closeImmediate);
470:
471: }
472:
473: }
474: } else {
475: arraytimesstack.push(""
476: + arraytimespush);
477: /*
478: * if(isThisInstrStart(starts,(currentForIndex-1)) &&
479: * isInstructionAnyDUP(info[currentForIndex-1]) &&
480: * newvalue!=null &&
481: * newvalue.trim().length() > 0){
482: * if(newvalue!=null &&
483: * (newvalue.trim().startsWith("++") ||
484: * newvalue.trim().startsWith("--")) &&
485: * opStack.size() > 0) { java.lang.String
486: * tpv=opStack.peekTopOfStack().getOperandValue().trim();
487: * if("++".concat(tpv).equals(newvalue) ||
488: * "--".concat(tpv).equals(newvalue)){
489: * opStack.pop(); } }
490: *
491: * opStack.push(createOperand(newvalue)); }
492: */
493: // else{
494: if (newvalue.length() > 0) {
495: behavior
496: .appendToBuffer(newvalue
497: + ",");
498: specialIASTORE = true;
499: } else {
500:
501: if (getStoreFinder()
502: .isInstPrimitiveArrayStore(
503: info[(currentForIndex + 1)])
504: && tempString != null
505: && tempString.length() > 0)
506: behavior
507: .appendToBuffer(tempString);
508: else
509: behavior.appendToBuffer(op
510: .getOperandValue()
511: + ",");
512: }
513: // }
514: }
515: }
516: }
517: }
518: }
519: } else {
520:
521: if (opStack.size() > 2 && !newfound()) {
522: opStack.pop();
523: opStack.pop();
524: }
525:
526: }
527:
528: int nextinst = info[currentForIndex + 1];
529: if (getGenericFinder()
530: .isThisInstrStart(currentForIndex + 1)
531: && nextinst == JvmOpCodes.AASTORE) {
532: skipaastores.add(new Integer(currentForIndex + 1));
533: }
534: }
535: GlobalVariableStore.setPrimitiveastore(primitiveastore);
536: GlobalVariableStore.setArraytimespush(arraytimespush);
537: GlobalVariableStore.setSpecialIASTORE(specialIASTORE);
538:
539: }
540:
541: }
|