Revize 0286c04b

#7767

Zjednodušení gramatiky, částečné zprovoznění s exportem do konzole.

demo_mh/Deserializer/src/deserialize/Grammar.java

@@ -1 +1 @@
 package deserialize;
 
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 
 /**
  * https://docs.oracle.com/javase/7/docs/platform/serialization/spec/protocol.html
@@ -9 +14 @@
 	
 	private final static short STREAM_MAGIC = (short) 0xACED;
 	private final static short STREAM_VERSION = 5;
-	private final static byte TC_NULL = 0x70;
-	private final static byte TC_REFERENCE = 0x71;
-	private final static byte TC_CLASSDESC = 0x72;
-	private final static byte TC_OBJECT = 0x73;
-	private final static byte TC_STRING = 0x74;
-	private final static byte TC_ARRAY = 0x75;
-	private final static byte TC_CLASS = 0x76;
-	private final static byte TC_BLOCKDATA = 0x77;
-	private final static byte TC_ENDBLOCKDATA = 0x78;
-	private final static byte TC_RESET = 0x79;
-	private final static byte TC_BLOCKDATALONG = 0x7A;
-	private final static byte TC_EXCEPTION = 0x7B;
-	private final static byte TC_LONGSTRING = 0x7C;
-	private final static byte TC_PROXYCLASSDESC = 0x7D;
-	private final static byte TC_ENUM = 0x7E;
-	private final static int baseWireHandle = 0x7E0000;
-	
-	final static byte SC_WRITE_METHOD = 0x01; // if SC_SERIALIZABLE
-	final static byte SC_BLOCK_DATA = 0x08; // if SC_EXTERNALIZABLE
-	final static byte SC_SERIALIZABLE = 0x02;
-	final static byte SC_EXTERNALIZABLE = 0x04;
-	final static byte SC_ENUM = 0x10;
+	private final static byte TC_NULL = (byte) 0x70;
+	private final static byte TC_REFERENCE = (byte) 0x71;
+	private final static byte TC_CLASSDESC = (byte) 0x72;
+	private final static byte TC_OBJECT = (byte) 0x73;
+	private final static byte TC_STRING = (byte) 0x74;
+	private final static byte TC_ARRAY = (byte) 0x75;
+	private final static byte TC_CLASS = (byte) 0x76;
+	private final static byte TC_BLOCKDATA = (byte) 0x77;
+	private final static byte TC_ENDBLOCKDATA = (byte) 0x78;
+	private final static byte TC_RESET = (byte) 0x79;
+	private final static byte TC_BLOCKDATALONG = (byte) 0x7A;
+	private final static byte TC_EXCEPTION = (byte) 0x7B;
+	private final static byte TC_LONGSTRING = (byte) 0x7C;
+	private final static byte TC_PROXYCLASSDESC = (byte) 0x7D;
+	private final static byte TC_ENUM = (byte) 0x7E;
+	private final static int baseWireHandle = (int) 0x7E0000;
+	
+	final static byte SC_WRITE_METHOD = (byte) 0x01; // if SC_SERIALIZABLE
+	final static byte SC_BLOCK_DATA = (byte) 0x08; // if SC_EXTERNALIZABLE
+	final static byte SC_SERIALIZABLE = (byte) 0x02;
+	final static byte SC_EXTERNALIZABLE = (byte) 0x04;
+	final static byte SC_ENUM = (byte) 0x10;
 
 	HashMap<Character, String> primTypeCodes;
 	HashMap<Character, String> objTypeCodes;
@@ -39 +44 @@
 	// Note. (XXX) This token has the XXX type specified
 	
 	
-	public Grammar() {
+	private List<Byte> buffer;
+	public Grammar(List<Byte> buffer) {
+		this.buffer = buffer;
+		
 		primTypeCodes = new HashMap<Character, String>();
 		primTypeCodes.put('B', "byte");
 		primTypeCodes.put('C', "char");
@@ -49 +57 @@
 		primTypeCodes.put('J', "long");
 		primTypeCodes.put('S', "short");
 		primTypeCodes.put('Z', "boolean");
+		
 		objTypeCodes = new HashMap<Character, String>();
 		objTypeCodes.put('[', "array");
 		objTypeCodes.put('L', "object");
 	}
 	
 	
-	
-	
-	public void stream() {
-		short x = STREAM_MAGIC; x = STREAM_VERSION; contents();
+	private byte takeFirst() {
+		return buffer.remove(0);
 	}
 	
-	public void contents() {
-		content();
-		// OR
-		contents(); content();
+	public byte readByte() {
+		return takeFirst();
 	}
 	
-	public void content() {
-		object();
-		// OR
-		byte x = TC_BLOCKDATA; // TODO (unsigned byte)<size> (byte)[size];
-		// OR
-		x = TC_BLOCKDATALONG; // TODO (int)<size> (byte)[size];
+	private long readNumber(int bytes) {
+		long result = 0;
+		for (int i = (bytes - 1) * Byte.SIZE; i >= 0; i -= Byte.SIZE) {
+			result = result | ((takeFirst() & 0xFF) << i);
+		}
+		return result;
 	}
 	
-	public void object() {
-		byte x = TC_OBJECT; classDesc(); newHandle(); classdata()/* TODO []*/;  // data for each class
-		// OR
-		x = TC_CLASS; classDesc(); newHandle();
-		// OR
-		x = TC_ARRAY; classDesc(); newHandle(); /* TODO (int)<size>*/ values()/*[size]*/;
-		// OR
-		x = TC_STRING; newHandle(); // TODO (utf) read 16-bit integer (string length)
-		// OR
-		x = TC_LONGSTRING; newHandle(); // TODO (long-utf) read 64-bit integer (string length)
-		// OR
-		x = TC_ENUM; classDesc(); newHandle(); /* TODO (String)*/ object();
-		// OR
-		newClassDesc();
-		// OR
-		x = TC_REFERENCE; // TODO (int) handle ?!?;
-		// OR
-		x = TC_NULL;
-		// OR
-		x = TC_EXCEPTION; reset(); /* TODO (Throwable)*/object(); reset();
-		// OR
-		x = TC_RESET;
+	public char readUnsignedByte() {
+		return (char) readNumber(Byte.BYTES);
 	}
 	
-	public void classDesc() {
-		newClassDesc();
-		// OR
-		byte x = TC_NULL;
-		// OR
-		/* TODO (ClassDesc)*/ x = TC_REFERENCE; // TODO (int) handle ?!?;
+	public short readShort() {
+		return (short) readNumber(Short.BYTES);
 	}
 	
-	public void newClassDesc() {
-		byte x = TC_CLASSDESC; /* TODO (utf) read 16-bit integer (string length); (long)*/; newHandle(); classDescFlags(); fields(); classAnnotation(); classDesc();
-		// OR
-		x = TC_PROXYCLASSDESC; newHandle(); /* TODO (int)<count> => read int as count /(utf) read 16-bit integer (string length)/ [count]*/; classAnnotation(); classDesc();
+	public int readInt() {
+		return (int) readNumber(Integer.BYTES);
 	}
 	
-	public void classDescFlags() {
-		// TODO (byte)
+	public long readLong() {
+		return readNumber(Long.BYTES);
 	}
 	
-	public void fields() {
-		/* TODO (short)<count> =>  read short as count */ fieldDesc() /*[count]*/;
+	public String readString(long length) {
+		String str = "";
+		for (int i = 0; i < length; i++) {
+			str += (char) readByte();
+		}
+		return str;
 	}
 	
-	public void fieldDesc() {
-		// TODO primTypeCodes.get(key); (utf) read 16-bit integer (string length);
-		// OR
-		/* TODO objTypeCodes.get(key) - array or object; (utf) read 16-bit integer (string length);*/ /*(String)*/object();		// String containing the field's type,
-																															// in field descriptor format
-	}
 	
-	public void classAnnotation() {
-		byte x = TC_ENDBLOCKDATA;
-		// OR
-		contents(); x = TC_ENDBLOCKDATA;      // contents written by annotateClass
-	}
 	
-	public void classdata() {
-		values(); // fields in order of class descriptor    // SC_SERIALIZABLE & classDescFlag &&
-															// !(SC_WRITE_METHOD & classDescFlags)
-		// OR
-		values() /* fields in order of class descriptor*/; objectAnnotation();  // SC_SERIALIZABLE & classDescFlag &&
-																				// SC_WRITE_METHOD & classDescFlags
-		// OR
-		externalContents();          // SC_EXTERNALIZABLE & classDescFlag &&
-								// !(SC_BLOCKDATA  & classDescFlags
-		// OR
-		objectAnnotation();          // SC_EXTERNALIZABLE & classDescFlag&&
-								// SC_BLOCKDATA & classDescFlags
-	}
 	
-	public void objectAnnotation() {
-		byte x = TC_ENDBLOCKDATA;
-		// OR
-		contents(); x = TC_ENDBLOCKDATA;     // contents written by writeObject
-		                            // or writeExternal PROTOCOL_VERSION_2.
-	}
 	
-	public void externalContent() { // Only parseable by readExternal
-		// TODO  ( bytes)                // primitive data
-		// OR 
-		object();
+	public String readUtf() {
+		short length = readShort();
+		return readString(length);
 	}
 	
-	public void externalContents() {// externalContent written by 
-		externalContent();        // writeExternal in PROTOCOL_VERSION_1.
-		// OR
-		externalContents(); externalContent();
+	public String readLongUtf() {
+		long length = readLong();
+		return readString(length);
 	}
 	
-	public void values() {
-		// The size and types are described by the
-        // classDesc for the current object
+	
+	
+	
+	
+	
+	
+	
+	public void start() {
+		System.out.println("Kontrola hlavicky souboru: " + (readShort() == STREAM_MAGIC && readShort() == STREAM_VERSION));
+		while (!buffer.isEmpty()) {
+			object();
+		}
 	}
 	
-	public void newHandle() {
-		// The next number in sequence is assigned
-        // to the object being serialized or deserialized
+	// FOR VALUES : 
+	// The size and types are described by the
+    // classDesc for the current object
+	public Object object() {
+		Object retValue;
+		byte b = readByte();
+		switch (b) {
+			case TC_OBJECT: {
+					System.out.println("X1");
+					
+					// Note. TC_OBJECT; classDesc(); classdata()[]; // data for each class
+					// Note. classDescFlags = (byte)
+					
+					ClassDescription desc = (ClassDescription) object();
+					retValue = desc;
+					
+					/*byte flags = readByte();
+					System.out.println("DEF: " + String.format("%02X", flags));
+					boolean xxx = SC_SERIALIZABLE == desc2.flags && SC_WRITE_METHOD != flags;
+					boolean xxx2 = SC_SERIALIZABLE == desc2.flags && SC_WRITE_METHOD == flags;
+					boolean xxx3 = SC_EXTERNALIZABLE == desc2.flags && SC_BLOCK_DATA != flags;
+					boolean xxx4 = SC_EXTERNALIZABLE == desc2.flags && SC_BLOCK_DATA == flags;
+					System.out.println(xxx);
+					System.out.println(xxx2);
+					System.out.println(xxx3);
+					System.out.println(xxx4);*/
+					
+					/* TODO
+					classDesc(); // && (
+							
+							//values() // fields in order of class descriptor    // SC_SERIALIZABLE & classDescFlag &&
+																				// !(SC_WRITE_METHOD & classDescFlags)
+							// OR
+							//values() fields in order of class descriptor; object();  // SC_SERIALIZABLE & classDescFlag &&
+																	// SC_WRITE_METHOD & classDescFlags
+							// OR
+							//object();          // SC_EXTERNALIZABLE & classDescFlag &&
+														// !(SC_BLOCKDATA  & classDescFlags
+							// OR
+							//object();          // SC_EXTERNALIZABLE & classDescFlag&&
+														// SC_BLOCKDATA & classDescFlags
+							// );*/
+				}
+				break;
+			case TC_CLASS: {
+					System.out.println("X2");
+					ClassDescription desc = (ClassDescription) object();
+					retValue = desc;
+				}
+				break;
+			case TC_ARRAY: {
+					System.out.println("X3");
+					ClassDescription desc = (ClassDescription) object();
+					int size = readInt();
+					retValue = desc.className + "[" + size + "]";
+				}
+				break;
+			case TC_STRING: {
+					String str = readUtf();
+					System.out.println("X4 " + str);
+					retValue = str;
+				}
+				break;
+			case TC_LONGSTRING: {
+					System.out.println("X5");
+					String str = readLongUtf();
+					retValue = str;
+				}
+				break;
+			case TC_ENUM: {
+					System.out.println("X6");
+					ClassDescription desc = (ClassDescription) object();
+					desc.isClass = false;
+					retValue = desc;
+					System.out.println("enumConstName: " + (String) object());
+				}
+				break;
+				
+				
+			case TC_CLASSDESC: {
+					System.out.println("X7");
+					ClassDescription desc = new ClassDescription();
+					desc.className = readUtf();
+					desc.serialVersionUID = readLong();
+					desc.flags = readByte();
+					desc.isClass = true;
+					desc.variables = fields();
+					// TODO object(null); classDesc();
+					System.out.println(desc.toString());
+					retValue = desc;
+				}
+				break;
+			case TC_PROXYCLASSDESC: {
+					System.out.println("X8");
+					int count = readInt();
+					String name = readUtf();
+					retValue = name + "[" + +count + "]";
+					// TODO object(null); classDesc();
+					
+				}
+				break;
+			case TC_NULL: {
+					// TODO
+					System.out.println("---NULL---");
+					retValue = null;
+				}
+				break;
+			case TC_REFERENCE: {
+					System.out.println("---REFERENCE---");
+					// TODO (ClassDesc) TC_REFERENCE (int)handle ?!?
+					retValue = null;
+				}
+				break;
+				
+				
+			case TC_EXCEPTION: {
+					// TODO (Throwable)object(null);
+					retValue = "(Throwable)";
+				}
+				break;
+			case TC_RESET: {
+					// TODO
+					System.out.println("---RESET---");
+					retValue = null;
+				}
+				break;
+			case TC_BLOCKDATA: {
+					System.out.println("X13");
+					char size = readUnsignedByte();
+					// (unsigned byte)<size> (byte)[size];
+					retValue = "byte [" + (int) size + "]";
+				}
+				break;
+			case TC_BLOCKDATALONG: {
+					System.out.println("X14");
+					int size = readInt();
+					// (int)<size> (byte)[size];
+					retValue = "byte [" + size + "]";
+				}
+				break;
+			case TC_ENDBLOCKDATA: {
+					// TODO
+					System.out.println("---ENDBLOCKDATA---");
+					retValue = null;
+				}
+				break;
+			default:
+				System.out.println("DEF: " + String.format("%02X", b) + " " + (char) b);
+				retValue = null;
+		}
+		
+		return retValue;
 	}
 	
-	public void reset() {
-		// The set of known objects is discarded
-        // so the objects of the exception do not
-        // overlap with the previously sent objects 
-        // or with objects that may be sent after 
-        // the exception
+	public List<String> fields() {
+		List<String> rows = new ArrayList<String>();
+		
+		short count = readShort();
+		for (int i = 0; i < count; i++) {
+			char type = (char) readByte();
+			
+			String row;
+			if (primTypeCodes.containsKey(type)) {
+				row = primTypeCodes.get(type) + " " + readUtf();
+			} else {
+				String variable = readUtf();
+				String dataType = (String) object();
+				dataType = dataType.substring(1);
+				
+				if (primTypeCodes.containsKey(dataType.charAt(0)))
+					dataType = primTypeCodes.get(dataType.charAt(0)); // remove type
+				
+				row = dataType + " " + variable;
+				if (objTypeCodes.get(type) == "array")
+					row += "[]";
+			}
+			
+			rows.add(row);
+		}
+		
+		return rows;
 	}
+	
 }