if (!arrayObject.getClass().isArray()) {	throw new Exception(invalidArrayFormat(dataStruct, dStart));      } else {	arrayTransferToBuffer(arrayObject, buffer, 2, 			      formatFormatArrayMax(formatArray)-1,			      isSimpleType(nextFormat),			      formatArray, nextFormat, null);      }      break;    }    case VarArrayFMT: {      int formatArray = formatFormatArray(format);      int nextFormat = formatFormatArrayItem(formatArray, 1);      Object arrayObject = (isTopLevelStruct ? dataStruct :			    primFmttrs.getObjectField(dataStruct, dStart));      /* For the size of the array */      primFmttrs.formatPutInt(buffer, varArrayNumElements(formatArray,							  dataStruct));            if (!arrayObject.getClass().isArray()) {	throw new Exception(invalidArrayFormat(dataStruct, dStart));      } else {	arrayTransferToBuffer(arrayObject, buffer, 2, 			      formatFormatArrayMax(formatArray)-1,			      isSimpleType(nextFormat),			      formatArray, nextFormat, dataStruct);      }      break;    }    case NamedFMT:      transferToBuffer(findNamedFormat(format), dataStruct, dStart, buffer,		       parentFormat, isTopLevelStruct);      break;    case EnumFMT:      primFmttrs.Encode(primFmttrs.INT_FMT, dataStruct, dStart, buffer);      break;    }  }  private static void transferToDataStructure (int format, Object dataStruct, 					       int dStart, int buffer,					       int parentFormat, 					       boolean isTopLevelStruct)     throws Exception {    Object struct;    switch (formatType(format)) {    case LengthFMT:      throw new Exception("JAVA version of IPC can only use explicit formats");    case PrimitiveFMT:      primFmttrs.Decode(formatPrimitiveProc(format), dataStruct, dStart,			buffer);      break;    case PointerFMT: {      char c = primFmttrs.formatGetChar(buffer);      if (c == '\0') {	primFmttrs.setObjectField(dataStruct, dStart, null);      } else {	transferToDataStructure(formatChoosePtrFormat(format, parentFormat),				dataStruct, dStart, buffer, 0,				isTopLevelStruct);      }      break;    }    case StructFMT: {      int formatArray = formatFormatArray(format);      int i, structStart = 0, n = formatFormatArrayMax(formatArray);      if (isTopLevelStruct) {	struct = dataStruct;      } else {	Object struct1 = primFmttrs.getObjectField(dataStruct, dStart);	struct = validateObject(struct1, dataStruct, dStart);	if (struct != struct1)	  primFmttrs.setObjectField(dataStruct, dStart, struct);      }      if (struct.getClass().getFields().length < n-1) {	throw new Exception(invalidStructFormat(struct, n));      }      for (i=1; i<n; i++) {	transferToDataStructure(formatFormatArrayItem(formatArray, i),				struct, structStart, buffer, format, false);	structStart++;      }      break;    }    case FixedArrayFMT: {      int formatArray = formatFormatArray(format);      int nextFormat = formatFormatArrayItem(formatArray, 1);      int size = formatFormatArrayItem(formatArray, 2);      Object arrayObject;      if (isTopLevelStruct) {	arrayObject = dataStruct;      } else {	arrayObject = primFmttrs.getObjectField(dataStruct, dStart);	arrayObject = validateArrayObject(arrayObject, size,					  dataStruct, dStart);	primFmttrs.setObjectField(dataStruct, dStart, arrayObject);      }      if (!arrayObject.getClass().isArray()) {	throw new Exception(invalidArrayFormat(dataStruct, dStart));      } else {	arrayTransferToDataStructure(arrayObject, buffer, 2, 				     formatFormatArrayMax(formatArray)-1,				     size, isSimpleType(nextFormat),				     formatArray, nextFormat, null);      }      break;    }    case VarArrayFMT: {      int formatArray = formatFormatArray(format);      int nextFormat = formatFormatArrayItem(formatArray, 1);      /* The total size of the array is the stored first */      int size = primFmttrs.formatGetInt(buffer);      int numDims = formatFormatArrayMax(formatArray)-2;      Object arrayObject;      if (numDims > 1) size = varArrayDimSize(2, formatArray, dataStruct);      if (!feasibleToDecodeVarArray(size, formatArray, dStart)) {	throw new Exception("JAVA version of IPC cannot decode "+			    "multi-dimensional variable length arrays unless "+			    "the size variables appear BEFORE the array "+			    "in the enclosing structure");      } else if (isTopLevelStruct) {	  arrayObject = dataStruct;      } else {	arrayObject = primFmttrs.getObjectField(dataStruct, dStart);	arrayObject = validateArrayObject(arrayObject, size,					  dataStruct, dStart);	primFmttrs.setObjectField(dataStruct, dStart, arrayObject);      }      if (!arrayObject.getClass().isArray()) {	throw new Exception(invalidArrayFormat(dataStruct, dStart));      } else {	arrayTransferToDataStructure(arrayObject, buffer, 2,				     numDims+1, size, isSimpleType(nextFormat),				     formatArray, nextFormat, dataStruct);      }      break;    }    case NamedFMT:      transferToDataStructure(findNamedFormat(format), dataStruct, dStart,			      buffer, parentFormat, isTopLevelStruct);      break;    case EnumFMT:      primFmttrs.Decode(primFmttrs.INT_FMT, dataStruct, dStart, buffer);      break;    }  }  private static void encodeData (int formatter, Object object, int buffer)      throws Exception {    transferToBuffer(formatter, object, 0, buffer, 0, true);  }  private static void decodeData (int formatter, int buffer, Object object)     throws Exception {    transferToDataStructure(formatter, object, 0, buffer, 0, true);  }  public static void checkDataClass (int format, Class oclass)      throws Exception {   switch (formatType(format)) {    case LengthFMT:      throw new Exception("JAVA version of IPC can only use explicit formats");    case PrimitiveFMT:      boolean matches = true;      String neededType = null;      switch (formatPrimitiveProc(format)) {      case primFmttrs.INT_FMT:      case primFmttrs.UINT_FMT:	neededType = "int";	matches = (oclass == int.class || oclass == Integer.class); break;      case primFmttrs.BOOLEAN_FMT:	neededType = "boolean";	matches = (oclass == boolean.class || oclass == Boolean.class); break;      case primFmttrs.FLOAT_FMT:	neededType = "float";	matches = (oclass == float.class || oclass == Float.class); break;      case primFmttrs.DOUBLE_FMT:	neededType = "double";	matches = (oclass == double.class || oclass == Double.class); break;      case primFmttrs.BYTE_FMT:      case primFmttrs.UBYTE_FMT:	neededType = "byte";	matches = (oclass == byte.class || oclass == Byte.class); break;      case primFmttrs.STR_FMT:	neededType = "String";	matches = (oclass == String.class); break;      case primFmttrs.CHAR_FMT:	neededType = "char";	matches = (oclass == char.class); break;      case primFmttrs.SHORT_FMT:      case primFmttrs.USHORT_FMT:	neededType = "short";	matches = (oclass == short.class || oclass == Short.class); break;      case primFmttrs.LONG_FMT:      case primFmttrs.ULONG_FMT:	neededType = "long";	matches = (oclass == long.class || oclass == Long.class); break;      }      if (!matches) {	throw new Exception("\""+ oclass.getName()			    +"\" does not match format -- needs to be "+			    neededType);      }      break;    case PointerFMT: {      checkDataClass(formatChoosePtrFormat(format, 0), oclass);      break;    }    case StructFMT: {      int n = formatFormatArrayMax(formatFormatArray(format));      if (oclass.getFields().length < n-1) {	throw new Exception(invalidStructFormat(oclass, n));      }      break;    }    case VarArrayFMT:    case FixedArrayFMT: {      if (!oclass.isArray()) {	throw new Exception("Data structure \""+ oclass.getName()			    +"\" does not match format -- needs to be array");      }      break;    }    case NamedFMT:      checkDataClass(findNamedFormat(format), oclass);      break;    case EnumFMT:      if (!(oclass == int.class || oclass == Integer.class)) {	throw new Exception("\""+ oclass.getName() +"\" does not match format"			    +" -- needs to be int (enum)");      }      break;    }  }  /* Marshalls the object into a byte array.     Fills in the VARCONTENT structure with the length and byteArray.     "formatter" is a C pointer. Returns any error conditions. */  public static int marshall (int formatter, Object object, 			      VARCONTENT varcontent) throws Exception {    if (!checkMarshallStatus(formatter)) {      return IPC.IPC_Error;    } else {      varcontent.length = bufferSize(formatter, object, true);      varcontent.byteArray = 0;      if (varcontent.length > 0) {	varcontent.byteArray = createByteArray(varcontent.length);	int buffer = createBuffer(varcontent.byteArray);	encodeData(formatter, object, buffer);	if (bufferLength(buffer) != varcontent.length)	  throw new Exception("Mismatch between buffer size ("+			      varcontent.length+") and encoded data ("+			      bufferLength(buffer)+")");	freeBuffer(buffer);      }      return IPC.IPC_OK;    }  }  /* Fills in the slots of the object according to the formatter.     "byteArray" and "formatter" are both C pointers.     Returns any error conditions. */  public static int unmarshall (int formatter, int byteArray, Object object)       throws Exception {    if (!checkMarshallStatus(formatter)) {      return IPC.IPC_Error;    } else {      if (formatter != 0) {	int buffer = createBuffer(byteArray);	decodeData(formatter, buffer, object);	freeBuffer(buffer);      }      return IPC.IPC_OK;    }  }  public static Object createFixedArray(Class arrayClass, int formatter) {    int size = formatFormatArrayItem(formatFormatArray(formatter), 2);    return Array.newInstance(arrayClass, size);  }  public static class IPCPrim {    public Object coerce () { return null; }    public String toString() { return "IPCPrim"; }  }  public static class IPCChar extends IPCPrim {    public IPCChar () {}    public IPCChar (char theChar) { value = theChar; }    public Object coerce () { return this; }    public String toString() { return new String() + value; }    public char value;  }  public static class IPCBoolean extends IPCPrim {    public IPCBoolean () {}    public IPCBoolean (boolean theBoolean) { value = theBoolean; }    public Object coerce () { return new Boolean(value); }    public String toString() { return (value ? "true" : "false"); }    public boolean value;  }  public static class IPCByte extends IPCPrim {    public IPCByte () {}    public IPCByte (byte theByte) { value = theByte; }    public Object coerce () { return new Byte(value); }    public String toString() { return Byte.toString(value); }    public byte value;  }  public static class IPCShort extends IPCPrim {    public IPCShort () {}    public IPCShort (short theShort) { value = theShort; }    public Object coerce () { return new Short(value); }    public String toString() { return Short.toString(value); }    public short value;  }  public static class IPCInteger extends IPCPrim {    public IPCInteger () {}    public IPCInteger (int theInt) { value = theInt; }    public Object coerce () { return new Integer(value); }    public String toString() { return Integer.toString(value); }    public int value;  }  public static class IPCLong extends IPCPrim {    public IPCLong () {}    public IPCLong (long theLong) { value = theLong; }    public Object coerce () { return new Long(value); }    public String toString() { return Long.toString(value); }    public long value;  }  public static class IPCFloat extends IPCPrim {    public IPCFloat () {}    public IPCFloat (float theFloat) { value = theFloat; }    public Object coerce () { return new Float(value); }    public String toString() { return Float.toString(value); }    public float value;  }  public static class IPCDouble extends IPCPrim {    public IPCDouble () {}    public IPCDouble (double theDouble) { value = theDouble; }    public Object coerce () { return new Double(value); }    public String toString() { return Double.toString(value); }    public double value;  }  public static class IPCString extends IPCPrim {    public IPCString () {}    public IPCString (String theString) { value = theString; }    public Object coerce () { return value; }    public String toString() { return value; }    public String value;  }}