From 663631f0456fcc245dd835889f86541d75161c53 Mon Sep 17 00:00:00 2001
From: Roman Shevchenko <roman.shevchenko@jetbrains.com>
Date: Thu, 28 Aug 2014 20:52:43 +0400
Subject: java-decompiler: post-import cleanup (classes moved)

---
 .../java/decompiler/code/InstructionSequence.java  | 219 +++++++++++++++++++++
 1 file changed, 219 insertions(+)
 create mode 100644 src/org/jetbrains/java/decompiler/code/InstructionSequence.java

(limited to 'src/org/jetbrains/java/decompiler/code/InstructionSequence.java')

diff --git a/src/org/jetbrains/java/decompiler/code/InstructionSequence.java b/src/org/jetbrains/java/decompiler/code/InstructionSequence.java
new file mode 100644
index 0000000..4c29820
--- /dev/null
+++ b/src/org/jetbrains/java/decompiler/code/InstructionSequence.java
@@ -0,0 +1,219 @@
+/*
+ *    Fernflower - The Analytical Java Decompiler
+ *    http://www.reversed-java.com
+ *
+ *    (C) 2008 - 2010, Stiver
+ *
+ *    This software is NEITHER public domain NOR free software 
+ *    as per GNU License. See license.txt for more details.
+ *
+ *    This software is distributed WITHOUT ANY WARRANTY; without 
+ *    even the implied warranty of MERCHANTABILITY or FITNESS FOR 
+ *    A PARTICULAR PURPOSE. 
+ */
+
+package org.jetbrains.java.decompiler.code;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.jetbrains.java.decompiler.code.interpreter.Util;
+import org.jetbrains.java.decompiler.main.DecompilerContext;
+import org.jetbrains.java.decompiler.struct.StructContext;
+import org.jetbrains.java.decompiler.util.InterpreterUtil;
+import org.jetbrains.java.decompiler.util.VBStyleCollection;
+
+
+public abstract class InstructionSequence {
+
+	// *****************************************************************************
+	// private fields
+	// *****************************************************************************
+	
+	protected VBStyleCollection<Instruction, Integer> collinstr = new VBStyleCollection<Instruction, Integer>(); 
+	
+	protected int pointer = 0;
+	
+	protected ExceptionTable exceptionTable = new ExceptionTable(); 
+	
+	// *****************************************************************************
+	// public methods
+	// *****************************************************************************
+
+	// to nbe overwritten
+	public InstructionSequence clone() {return null;}
+	
+	public void clear() {
+		collinstr.clear();
+		pointer = 0;
+		exceptionTable = new ExceptionTable(); 
+	}
+	
+	public void addInstruction(Instruction inst, int offset){
+		collinstr.addWithKey(inst, offset);
+	}
+
+	public void addInstruction(int index, Instruction inst, int offset){
+		collinstr.addWithKeyAndIndex(index, inst, offset);
+	}
+	
+	public void addSequence(InstructionSequence seq){
+		for(int i=0;i<seq.length();i++) {
+			addInstruction(seq.getInstr(i), -1); // TODO: any sensible value possible?
+		}
+	}
+	
+	public void removeInstruction(int index) {
+		collinstr.remove(index);
+	}
+	
+	public Instruction getCurrentInstr() {
+		return (Instruction)collinstr.get(pointer);
+	}
+	
+	public Instruction getInstr(int index) {
+		return (Instruction)collinstr.get(index);
+	}
+
+	public Instruction getLastInstr() {
+		return (Instruction)collinstr.getLast();
+	}
+	
+	public int getCurrentOffset() {
+		return ((Integer)collinstr.getKey(pointer)).intValue(); 
+	}
+
+	public int getOffset(int index) {
+		return ((Integer)collinstr.getKey(index)).intValue(); 
+	}
+	
+	public int getPointerByAbsOffset(int offset) {
+		Integer absoffset = new Integer(offset);
+		if(collinstr.containsKey(absoffset)) {
+			return collinstr.getIndexByKey(absoffset);
+		} else {
+			return -1;
+		}
+	}
+
+	public int getPointerByRelOffset(int offset) {
+		Integer absoffset = new Integer(((Integer)collinstr.getKey(pointer)).intValue()+offset);
+		if(collinstr.containsKey(absoffset)) {
+			return collinstr.getIndexByKey(absoffset);
+		} else {
+			return -1;
+		}
+	}
+	
+	public void setPointerByAbsOffset(int offset) {
+		Integer absoffset = new Integer(((Integer)collinstr.getKey(pointer)).intValue()+offset);
+		if(collinstr.containsKey(absoffset)) {
+			pointer = collinstr.getIndexByKey(absoffset);
+		}
+	}
+	
+	public int length() {
+		return collinstr.size();  
+	}
+	
+	public boolean isEmpty() {
+		return collinstr.isEmpty();
+	}
+	
+	public void addToPointer(int diff) {
+		this.pointer += diff;
+	}
+	
+	public String toString() {
+		return toString(0); 
+	}
+
+	public String toString(int indent) {
+		
+		String new_line_separator = DecompilerContext.getNewLineSeparator();
+		
+		StringBuffer buf = new  StringBuffer();
+		
+		for(int i=0;i<collinstr.size();i++) {
+			buf.append(InterpreterUtil.getIndentString(indent));
+			buf.append(((Integer)collinstr.getKey(i)).intValue());
+			buf.append(": ");
+			buf.append(((Instruction)collinstr.get(i)).toString());
+			buf.append(new_line_separator);
+		}
+		
+		return buf.toString(); 
+	}
+	
+	public void writeCodeToStream(DataOutputStream out) throws IOException {
+
+		for(int i=0;i<collinstr.size();i++) {
+			((Instruction)collinstr.get(i)).writeToStream(out, ((Integer)collinstr.getKey(i)).intValue());
+		}
+	}
+
+	public void writeExceptionsToStream(DataOutputStream out) throws IOException {
+
+		List<ExceptionHandler> handlers = exceptionTable.getHandlers();  
+		
+		out.writeShort(handlers.size());
+		for(int i=0;i<handlers.size();i++) {
+			((ExceptionHandler)handlers.get(i)).writeToStream(out);
+		}
+	}
+	
+	public void sortHandlers(final StructContext context) {
+		
+		Collections.sort(exceptionTable.getHandlers(), new Comparator<ExceptionHandler>() {
+
+			public int compare(ExceptionHandler handler0, ExceptionHandler handler1) {
+				
+				if(handler0.to == handler1.to) {
+					if(handler0.exceptionClass == null) {
+						return 1;
+					} else {
+						if(handler1.exceptionClass == null) {
+							return -1;
+						} else if(handler0.exceptionClass.equals(handler1.exceptionClass)){
+							return (handler0.from > handler1.from)?-1:1; // invalid code
+						} else {
+							if(Util.instanceOf(context, handler0.exceptionClass, handler1.exceptionClass)) {
+								return -1;
+							} else {
+								return 1;
+							}
+						}
+					}
+				} else {
+					return (handler0.to > handler1.to)?1:-1;
+				}
+			}
+		}); 
+		
+	}
+	
+	
+	// *****************************************************************************
+	// getter and setter methods
+	// *****************************************************************************
+
+	public int getPointer() {
+		return pointer;
+	}
+
+	public void setPointer(int pointer) {
+		this.pointer = pointer;
+	}
+	
+	public ExceptionTable getExceptionTable() {
+		return exceptionTable;
+	}
+
+	public void setExceptionTable(ExceptionTable exceptionTable) {
+		this.exceptionTable = exceptionTable;
+	}
+	
+}
-- 
cgit v1.2.3