static int resultSize(ResultType resultType) { switch (resultType.nativeType()) { case SCHAR: case UCHAR: case SSHORT: case USHORT: case SINT: case UINT: case SLONG: case ULONG: case POINTER: return 4; case SLONG_LONG: case ULONG_LONG: return 8; case FLOAT: case DOUBLE: return 16; case VOID: return 0; default: throw new IllegalArgumentException("invalid return type " + resultType); } }
public static ResultType fromID(char id) throws RPCException { for (ResultType t : ResultType.values()) { if (id == t.id) { return t; } } throw new RPCException(JSONRPCError.MISSING_RESULT_TYPE); }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated */ public ResultType createResultTypeFromString(EDataType eDataType, String initialValue) { ResultType result = ResultType.get(initialValue); if (result == null) throw new IllegalArgumentException( "The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); return result; }
private void maxWidthTreeHelper( TreeNode node, int depth, Map<Integer, Integer> map, ResultType rt) { for (TreeNode next : node.nextList) { if (next == null) { continue; } else { if (map.containsKey(depth)) { map.put(depth, map.get(depth) + 1); } else { map.put(depth, 1); } rt.max = Math.max(rt.max, map.get(depth)); maxWidthTreeHelper(next, depth + 1, map, rt); } } }
public static JSONRPCResult fromJSON(JSONObject result) throws RPCException { ResultType type = ResultType.fromID(result.getString("type").charAt(0)); switch (type) { // TODO case ACK: return new AckResponse(); case AT: return TableResult.fromJSON(result); case INDEX: return IndexResult.fromJSON(result); case NAK: return new NakResult(); case PONG: return new PongResult(); case VALUE: return ValueResult.fromJSON(result); default: throw new RPCException(JSONRPCError.MISSING_RESULT_TYPE); } }
public void addResult( final String message, final String type, final String debugInfo, final String failureMsg) { listResult.add(new TestResult(message, ResultType.getType(type), debugInfo, failureMsg)); }
public ContactFilterProvider withResultType(ResultType resultType) { addQueryParameter("type", resultType.name()); return this; }
/** * Is the supplied ResultType the default * * @param resultType * @return */ public static boolean isDefault(ResultType resultType) { return resultType.equals(DEFAULT); }
protected JSONObject shell() { JSONObject response = new JSONObject(); response.put("type", "" + type.getID()); return response; }
@Override void compile( long function, String name, ResultType resultType, ParameterType[] parameterTypes, Class resultClass, Class[] parameterClasses, CallingConvention convention, boolean saveErrno) { int psize = 0; for (ParameterType t : parameterTypes) { psize += parameterSize(t); } int rsize = resultSize(resultType); // // JNI functions all look like: // foo(JNIEnv* env, jobject self, arg...) // We need to align the stack to 16 bytes, then copy all the old args // into the new parameter space. // It already has 4 bytes pushed (the return address) so we need to account for that. // final int stackadj = align(Math.max(psize, rsize) + 4, 16) - 4; Assembler a = new Assembler(X86_32); a.sub(esp, imm(stackadj)); // copy and convert the parameters from the orig stack to the new location for (int i = 0, srcoff = 0, dstoff = 0; i < parameterTypes.length; i++) { int srcParameterSize = parameterSize(parameterClasses[i]); int dstParameterSize = parameterSize(parameterTypes[i]); int disp = stackadj + 4 + 8 + srcoff; switch (parameterTypes[i].nativeType()) { case SCHAR: case SSHORT: a.movsx(eax, ptr(esp, disp, parameterTypes[i].nativeType())); break; case UCHAR: case USHORT: a.movzx(eax, ptr(esp, disp, parameterTypes[i].nativeType())); break; default: a.mov(eax, dword_ptr(esp, disp)); break; } a.mov(dword_ptr(esp, dstoff), eax); if (dstParameterSize > 4) { if (parameterTypes[i].nativeType() == NativeType.SLONG_LONG && long.class != parameterClasses[i]) { // sign extend from int.class -> long long a.sar(eax, imm(31)); } else if (parameterTypes[i].nativeType() == NativeType.ULONG_LONG && long.class != parameterClasses[i]) { // zero extend from int.class -> unsigned long long a.mov(dword_ptr(esp, dstoff + 4), imm(0)); } else { a.mov(eax, dword_ptr(esp, disp + 4)); } a.mov(dword_ptr(esp, dstoff + 4), eax); } dstoff += dstParameterSize; srcoff += srcParameterSize; } // Call to the actual native function a.call(imm(function & 0xffffffffL)); if (saveErrno) { int save = 0; switch (resultType.nativeType()) { case FLOAT: a.fstp(dword_ptr(esp, save)); break; case DOUBLE: a.fstp(qword_ptr(esp, save)); break; case SLONG_LONG: case ULONG_LONG: a.mov(dword_ptr(esp, save), eax); a.mov(dword_ptr(esp, save + 4), edx); break; case VOID: // No need to save for void values break; default: a.mov(dword_ptr(esp, save), eax); } // Save the errno in a thread-local variable a.call(imm(errnoFunctionAddress & 0xffffffffL)); // Retrieve return value and put it back in the appropriate return register switch (resultType.nativeType()) { case FLOAT: a.fld(dword_ptr(esp, save)); break; case DOUBLE: a.fld(qword_ptr(esp, save)); break; case SCHAR: a.movsx(eax, byte_ptr(esp, save)); break; case UCHAR: a.movzx(eax, byte_ptr(esp, save)); break; case SSHORT: a.movsx(eax, word_ptr(esp, save)); break; case USHORT: a.movzx(eax, word_ptr(esp, save)); break; case SLONG_LONG: case ULONG_LONG: a.mov(eax, dword_ptr(esp, save)); a.mov(edx, dword_ptr(esp, save + 4)); break; case VOID: // No need to save for void values break; default: a.mov(eax, dword_ptr(esp, save)); } } else { switch (resultType.nativeType()) { case SCHAR: a.movsx(eax, al); break; case UCHAR: a.movzx(eax, al); break; case SSHORT: a.movsx(eax, ax); break; case USHORT: a.movzx(eax, ax); break; } } if (long.class == resultClass) { // sign or zero extend the result to 64 bits switch (resultType.nativeType()) { case SCHAR: case SSHORT: case SINT: case SLONG: // sign extend eax to edx:eax a.mov(edx, eax); a.sar(edx, imm(31)); break; case UCHAR: case USHORT: case UINT: case ULONG: case POINTER: a.mov(edx, imm(0)); break; } } // Restore esp to the original position and return a.add(esp, imm(stackadj)); a.ret(); stubs.add(new Stub(name, sig(resultClass, parameterClasses), a)); }
boolean canCompile( ResultType returnType, ParameterType[] parameterTypes, CallingConvention convention) { switch (returnType.nativeType()) { case VOID: case SCHAR: case UCHAR: case SSHORT: case USHORT: case SINT: case UINT: case SLONG: case ULONG: case SLONG_LONG: case ULONG_LONG: case FLOAT: case DOUBLE: case POINTER: break; default: return false; } // There is only one calling convention; SYSV, so abort if someone tries to use stdcall if (convention != CallingConvention.DEFAULT) { return false; } int fCount = 0; int iCount = 0; for (ParameterType t : parameterTypes) { switch (t.nativeType()) { case SCHAR: case UCHAR: case SSHORT: case USHORT: case SINT: case UINT: case SLONG: case ULONG: case SLONG_LONG: case ULONG_LONG: case POINTER: ++iCount; break; case FLOAT: case DOUBLE: ++fCount; break; default: // Fail on anything else return false; } } // We can only safely compile methods with up to 6 integer and 8 floating point parameters return true; }