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