////////////////////////////////////////////////////////////////////////
// IClassFactory
//
////////////////////////////////////////////////////////////////////////
// CreateInstance
//
STDMETHODIMP CRatDVDClassFactory::CreateInstance(LPUNKNOWN punk, REFIID riid, void** ppv)
{
HRESULT hr;
ODS(_T("CFileClassFactory::CreateInstance\n"));
CHECK_NULL_RETURN(ppv, E_POINTER); *ppv = NULL;
// This version does not support Aggregation...
if (punk) return CLASS_E_NOAGGREGATION;
if ( IID_ILibraryBuilderPlugin == riid || IID_IImageServicePlugin == riid )
{
CComObject<CRatDVDPlugin>*pRatDVDPlugin = new CComObject<CRatDVDPlugin>;
CHECK_NULL_RETURN(pRatDVDPlugin, E_OUTOFMEMORY);
hr = pRatDVDPlugin->QueryInterface( IID_IUnknown, ppv );
if ( SUCCEEDED(hr) )
{
if ( IID_ILibraryBuilderPlugin == riid )
*ppv = dynamic_cast<ILibraryBuilderPlugin*>(pRatDVDPlugin);
else
*ppv = dynamic_cast<IImageServicePlugin*>(pRatDVDPlugin);
}
else return hr;
}
else return E_NOINTERFACE;
LockServer(TRUE); // on success, bump up lock count
return hr;
}
// 建立一个connector
int create_tcp_socket_connector(const char* host, const char* port)
{
CHECK_NULL_RETURN(host, -1);
CHECK_NULL_RETURN(port, -1);
int fd = socket(AF_INET, SOCK_STREAM, 0);
check_result(fd, errno, "socket");
struct addrinfo* res = NULL;
struct addrinfo hits;
memset(&hits, 0, sizeof(hits));
hits.ai_socktype = SOCK_STREAM;
int ret = getaddrinfo(host, port, &hits, &res);
if (0 != ret) {
fprintf(stderr, "[getaddrinfo]: %s\n", gai_strerror(ret));
freeaddrinfo(res);
exit(1);
}
struct addrinfo* phead = res;
for (; NULL != phead; phead = phead->ai_next) {
ret = connect(fd, phead->ai_addr, phead->ai_addrlen);
check_result(ret, errno, "bind");
break;
}
freeaddrinfo(res);
return fd;
}
////////////////////////////////////////////////////////////////////////
// CDsoFramerClassFactory::CreateInstance
//
// Creates an instance of our control.
//
STDMETHODIMP CDsoFramerClassFactory::CreateInstance(LPUNKNOWN punk, REFIID riid, void** ppv)
{
HRESULT hr;
CDsoFramerControl* pocx;
IUnknown* pnkInternal;
ODS("CDsoFramerClassFactory::CreateInstance\n");
CHECK_NULL_RETURN(ppv, E_POINTER); *ppv = NULL;
// Aggregation requires you ask for (internal) IUnknown
if ((punk) && (riid != IID_IUnknown))
return E_INVALIDARG;
// Create a new instance of the control...
pocx = new CDsoFramerControl(punk);
CHECK_NULL_RETURN(pocx, E_OUTOFMEMORY);
// Grab the internal IUnknown to use for the QI (you don't agg in CF:CreateInstance)...
pnkInternal = (IUnknown*)&(pocx->m_xInternalUnknown);
// Initialize the control (windows, etc.) and QI for requested interface...
if (SUCCEEDED(hr = pocx->InitializeNewInstance()) &&
SUCCEEDED(hr = pnkInternal->QueryInterface(riid, ppv)))
{
InterlockedIncrement((LPLONG)&v_cLocks); // on success, bump up the lock count...
}
else {
delete pocx;
*ppv = NULL;
} // else cleanup the object
return hr;
}
HRESULT CRatDVDReaderModule::DllGetClassObject(REFCLSID rclsid, REFIID /*riid*/, LPVOID* ppv)
{
ODS(_T("CRatDVDReaderModule::DllGetClassObject\n"));
HRESULT hr;
CRatDVDClassFactory* pcf;
CHECK_NULL_RETURN(ppv, E_POINTER);
*ppv = NULL;
// The only components we can create
if ( rclsid != CLSID_RatDVDReader )
return CLASS_E_CLASSNOTAVAILABLE;
// Create the needed class factory...
pcf = new CRatDVDClassFactory();
CHECK_NULL_RETURN( pcf, E_OUTOFMEMORY );
// Get requested interface.
if ( SUCCEEDED(hr = pcf->QueryInterface(rclsid, ppv)) )
{ pcf->LockServer(TRUE); }
else
{ *ppv = NULL; delete pcf; }
return hr;
}
////////////////////////////////////////////////////////////////////////
// DllGetClassObject
//
// Returns IClassFactory instance for FramerControl. We only support
// this one object for creation.
//
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void** ppv)
{
HRESULT hr;
CDsoFramerClassFactory* pcf;
CHECK_NULL_RETURN(ppv, E_POINTER);
*ppv = NULL;
// The only component we can create is the BinderControl...
if (rclsid != CLSID_FramerControl)
return CLASS_E_CLASSNOTAVAILABLE;
// Create the needed class factory...
pcf = new CDsoFramerClassFactory();
CHECK_NULL_RETURN(pcf, E_OUTOFMEMORY);
// Get requested interface.
if (FAILED(hr = pcf->QueryInterface(riid, ppv)))
{
*ppv = NULL; delete pcf;
}
else InterlockedIncrement((LPLONG)&v_cLocks);
return hr;
}
/*
* Returns True if display is local, False of it's remote.
*/
jboolean isDisplayLocal(JNIEnv *env) {
static jboolean isLocal = False;
static jboolean isLocalSet = False;
jboolean ret;
if (! isLocalSet) {
jclass geCls = (*env)->FindClass(env, "java/awt/GraphicsEnvironment");
CHECK_NULL_RETURN(geCls, JNI_FALSE);
jmethodID getLocalGE = (*env)->GetStaticMethodID(env, geCls,
"getLocalGraphicsEnvironment",
"()Ljava/awt/GraphicsEnvironment;");
CHECK_NULL_RETURN(getLocalGE, JNI_FALSE);
jobject ge = (*env)->CallStaticObjectMethod(env, geCls, getLocalGE);
JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE);
jclass sgeCls = (*env)->FindClass(env,
"sun/java2d/SunGraphicsEnvironment");
CHECK_NULL_RETURN(sgeCls, JNI_FALSE);
if ((*env)->IsInstanceOf(env, ge, sgeCls)) {
jmethodID isDisplayLocal = (*env)->GetMethodID(env, sgeCls,
"isDisplayLocal",
"()Z");
JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE);
isLocal = (*env)->CallBooleanMethod(env, ge, isDisplayLocal);
} else {
isLocal = True;
}
isLocalSet = True;
}
return isLocal;
}
// Create a new AwtChoice object and window.
AwtChoice*
AwtChoice::Create( jobject peer, jobject hParent )
{
JNIEnv *env;
if ( JVM->AttachCurrentThread( (void **)&env, 0 ) != 0 ) {
return 0;
}
CHECK_NULL_RETURN( hParent, "null hParent" );
AwtCanvas *parent = PDATA( AwtCanvas, hParent );
CHECK_NULL_RETURN( parent, "null parent" );
jobject target = env->GetObjectField( peer,
WCachedIDs.PPCObjectPeer_targetFID );
CHECK_NULL_RETURN( target, "null target" );
AwtChoice *c = new AwtChoice();
CHECK_NULL_RETURN( c, "AwtChoice() failed" );
#ifndef WINCE
DWORD style = WS_CHILD | WS_CLIPSIBLINGS | WS_VSCROLL |
CBS_DROPDOWNLIST | CBS_OWNERDRAWFIXED;
#else
// WINCE does not support OWNERDRAW combo boxes.
DWORD style = WS_CHILD | WS_CLIPSIBLINGS | WS_VSCROLL |
CBS_DROPDOWNLIST;
#endif // !WINCE
// In OWNER_DRAW, the size of the edit control part of the choice
// must be determinded in its creation, when the parent cannot get
// the choice's instance from its handle. So record the pair of
// the ID and the instance of the choice.
UINT myId = parent->CreateControlID();
ASSERT( myId > 0 );
c->m_myControlID = myId;
parent->PushChild( myId, c );
c->CreateHWnd( TEXT(""), style, 0,
env->CallIntMethod( target,
WCachedIDs.java_awt_Component_getXMID ),
env->CallIntMethod( target,
WCachedIDs.java_awt_Component_getYMID ),
env->CallIntMethod( target,
WCachedIDs.java_awt_Component_getWidthMID ),
env->CallIntMethod( target,
WCachedIDs.java_awt_Component_getHeightMID ),
parent->GetHWnd(),
(HMENU)myId,
::GetSysColor( COLOR_WINDOWTEXT ),
::GetSysColor( COLOR_WINDOW ),
peer
);
c->m_backgroundColorSet = TRUE; // suppress inheriting parent's color.
return c;
}
static jobject getEnumField(JNIEnv *env, char *name) {
jobject f;
jfieldID fID = (*env)->GetStaticFieldID(env, sf_status_class, name,
"Ljdk/net/SocketFlow$Status;");
CHECK_NULL_RETURN(fID, NULL);
f = (*env)->GetStaticObjectField(env, sf_status_class, fID);
CHECK_NULL_RETURN(f, NULL);
f = (*env)->NewGlobalRef(env, f);
CHECK_NULL_RETURN(f, NULL);
return f;
}
// Create a new AwtCheckbox object and window.
AwtCheckbox* AwtCheckbox::Create(jobject self,
jobject hParent)
{
JNIEnv* env;
/* associate JNIEnv with the current thread */
if (JVM -> AttachCurrentThread((void**) &env, 0) != 0) {
return NULL;
}
CHECK_NULL_RETURN(hParent, "null hParent");
AwtCanvas* parent = (AwtCanvas*) env->GetIntField(hParent,
WCachedIDs.PPCObjectPeer_pDataFID);
CHECK_NULL_RETURN(parent, "null parent");
jobject target =
env -> GetObjectField(self, WCachedIDs.PPCObjectPeer_targetFID);
CHECK_NULL_RETURN(target, "null target");
AwtCheckbox* checkbox = new AwtCheckbox();
CHECK_NULL_RETURN(checkbox, "AwtCheckbox() failed");
DWORD style = WS_CHILD | WS_CLIPSIBLINGS | BS_OWNERDRAW;
jstring label = (jstring)env->CallObjectMethod(target,
WCachedIDs.java_awt_Checkbox_getLabelMID);
TCHAR *sb;
if (label == NULL) {
sb = TEXT("");
} else {
JavaStringBuffer sb(env, label);
}
checkbox->CreateHWnd(sb, style, 0,
(int)env->CallIntMethod(target,
WCachedIDs.java_awt_Component_getXMID),
(int)env->CallIntMethod(target,
WCachedIDs.java_awt_Component_getYMID),
(int)env->CallIntMethod(target,
WCachedIDs.java_awt_Component_getWidthMID),
(int)env->CallIntMethod(target,
WCachedIDs.java_awt_Component_getHeightMID),
parent->GetHWnd(),
(HMENU)parent->CreateControlID(),
::GetSysColor(COLOR_WINDOWTEXT),
::GetSysColor(COLOR_BTNFACE),
self
);
return checkbox;
}
JNIEXPORT jobject JNICALL Java_com_sun_media_sound_DirectAudioDeviceProvider_nNewDirectAudioDeviceInfo
(JNIEnv *env, jclass cls, jint mixerIndex) {
jclass directAudioDeviceInfoClass;
jmethodID directAudioDeviceInfoConstructor;
DirectAudioDeviceDescription desc;
jobject info = NULL;
jstring name;
jstring vendor;
jstring description;
jstring version;
TRACE1("Java_com_sun_media_sound_DirectAudioDeviceProvider_nNewDirectAudioDeviceInfo(%d).\n", mixerIndex);
// retrieve class and constructor of DirectAudioDeviceProvider.DirectAudioDeviceInfo
directAudioDeviceInfoClass = (*env)->FindClass(env, IMPLEMENTATION_PACKAGE_NAME"/DirectAudioDeviceProvider$DirectAudioDeviceInfo");
if (directAudioDeviceInfoClass == NULL) {
ERROR0("Java_com_sun_media_sound_DirectAudioDeviceProvider_nNewDirectAudioDeviceInfo: directAudioDeviceInfoClass is NULL\n");
return NULL;
}
directAudioDeviceInfoConstructor = (*env)->GetMethodID(env, directAudioDeviceInfoClass, "<init>",
"(IIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
if (directAudioDeviceInfoConstructor == NULL) {
ERROR0("Java_com_sun_media_sound_DirectAudioDeviceProvider_nNewDirectAudioDeviceInfo: directAudioDeviceInfoConstructor is NULL\n");
return NULL;
}
TRACE1("Get description for device %d\n", mixerIndex);
if (getDirectAudioDeviceDescription(mixerIndex, &desc)) {
// create a new DirectAudioDeviceInfo object and return it
name = (*env)->NewStringUTF(env, desc.name);
CHECK_NULL_RETURN(name, info);
vendor = (*env)->NewStringUTF(env, desc.vendor);
CHECK_NULL_RETURN(vendor, info);
description = (*env)->NewStringUTF(env, desc.description);
CHECK_NULL_RETURN(description, info);
version = (*env)->NewStringUTF(env, desc.version);
CHECK_NULL_RETURN(version, info);
info = (*env)->NewObject(env, directAudioDeviceInfoClass,
directAudioDeviceInfoConstructor, mixerIndex,
desc.deviceID, desc.maxSimulLines,
name, vendor, description, version);
} else {
ERROR1("ERROR: getDirectAudioDeviceDescription(%d, desc) returned FALSE!\n", mixerIndex);
}
TRACE0("Java_com_sun_media_sound_DirectAudioDeviceProvider_nNewDirectAudioDeviceInfo succeeded.\n");
return info;
}
/*
* Returns list of page sizes and imageable area.
*/
JNIEXPORT jfloatArray JNICALL
Java_sun_print_CUPSPrinter_getPageSizes(JNIEnv *env,
jobject printObj,
jstring printer)
{
ppd_file_t *ppd;
ppd_option_t *option;
ppd_choice_t *choice;
ppd_size_t *size;
const char *name = (*env)->GetStringUTFChars(env, printer, NULL);
if (name == NULL) {
(*env)->ExceptionClear(env);
JNU_ThrowOutOfMemoryError(env, "Could not create printer name");
return NULL;
}
const char *filename;
int i;
jobjectArray sizeArray = NULL;
jfloat *dims;
// NOTE: cupsGetPPD returns a pointer to a filename of a temporary file.
// unlink() must be called to remove the file after using it.
filename = j2d_cupsGetPPD(name);
(*env)->ReleaseStringUTFChars(env, printer, name);
CHECK_NULL_RETURN(filename, NULL);
if ((ppd = j2d_ppdOpenFile(filename)) == NULL) {
unlink(filename);
DPRINTF("unable to open PPD %s\n", filename)
return NULL;
}
////////////////////////////////////////////////////////////////////////
// put_Value
//
HRESULT CDocProperty::put_Value(VARIANT *pvValue)
{
VARIANT vtTmp; vtTmp.vt = VT_EMPTY;
ODS(_T("CDocProperty::put_Value\n"));
CHECK_NULL_RETURN(pvValue, E_POINTER);
CHECK_FLAG_RETURN((m_fDeadObj || m_fRemovedItem), E_INVALIDOBJECT);
// We don't support arrays (in this sample at least)...
if ((pvValue->vt) & VT_ARRAY)
return E_INVALIDARG;
// Sanity check of VARTYPE (if it is not one we can save, don't bother)...
switch (((pvValue->vt) & VT_TYPEMASK))
{
case VT_I2:
case VT_I4:
case VT_R4:
case VT_R8:
case VT_DATE:
case VT_BSTR:
case VT_BOOL:
break;
default:
return E_INVALIDARG;
}
// Swap out the variant value and set the dirty flag. We make independent
// copy of the VARIANT (performs indirection as needed)...
m_fModified = TRUE;
VariantClear(&m_vValue);
return VariantCopyInd(&m_vValue, pvValue);
}
jfieldID
NET_GetFileDescriptorID(JNIEnv *env)
{
jclass cls = (*env)->FindClass(env, "java/io/FileDescriptor");
CHECK_NULL_RETURN(cls, NULL);
return (*env)->GetFieldID(env, cls, "fd", "I");
}
static jboolean initializeInetClasses(JNIEnv *env)
{
static int initialized = 0;
if (!initialized) {
ni_iacls = (*env)->FindClass(env, "java/net/InetAddress");
CHECK_NULL_RETURN(ni_iacls, JNI_FALSE);
ni_iacls = (*env)->NewGlobalRef(env, ni_iacls);
CHECK_NULL_RETURN(ni_iacls, JNI_FALSE);
ni_ia4cls = (*env)->FindClass(env, "java/net/Inet4Address");
CHECK_NULL_RETURN(ni_ia4cls, JNI_FALSE);
ni_ia4cls = (*env)->NewGlobalRef(env, ni_ia4cls);
CHECK_NULL_RETURN(ni_ia4cls, JNI_FALSE);
ni_ia4ctrID = (*env)->GetMethodID(env, ni_ia4cls, "<init>", "()V");
CHECK_NULL_RETURN(ni_ia4ctrID, JNI_FALSE);
initialized = 1;
}
return JNI_TRUE;
}
static int init_JNI_IDs(JNIEnv *env) {
if (jniInited) {
return jniInited;
}
CHECK_NULL_RETURN(gvdClass = (*env)->FindClass(env, gvdClassName), 0);
CHECK_NULL_RETURN(gvdClass = (jclass)(*env)->NewGlobalRef(env, gvdClass), 0);
CHECK_NULL_RETURN(gvdCountFID = (*env)->GetFieldID(env, gvdClass, "_count", "I"), 0);
CHECK_NULL_RETURN(gvdFlagsFID = (*env)->GetFieldID(env, gvdClass, "_flags", "I"), 0);
CHECK_NULL_RETURN(gvdGlyphsFID = (*env)->GetFieldID(env, gvdClass, "_glyphs", "[I"), 0);
CHECK_NULL_RETURN(gvdPositionsFID = (*env)->GetFieldID(env, gvdClass, "_positions", "[F"), 0);
CHECK_NULL_RETURN(gvdIndicesFID = (*env)->GetFieldID(env, gvdClass, "_indices", "[I"), 0);
CHECK_NULL_RETURN(gvdGrowMID = (*env)->GetMethodID(env, gvdClass, "grow", "()V"), 0);
jniInited = 1;
return jniInited;
}
////////////////////////////////////////////////////////////////////////
// CDsoFramerClassFactory::QueryInterface
//
STDMETHODIMP CDsoFramerClassFactory::QueryInterface(REFIID riid, void** ppv)
{
ODS("CDsoFramerClassFactory::QueryInterface\n");
CHECK_NULL_RETURN(ppv, E_POINTER);
if ((IID_IUnknown == riid) || (IID_IClassFactory == riid))
{
SAFE_SET_INTERFACE(*ppv, (IClassFactory*)this);
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
/*
* Class: sun_awt_X11_XTaskbarPeer
* Method: init
* Signature: (Ljava/lang/String;)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_X11_XTaskbarPeer_init
(JNIEnv *env, jclass cls, jstring jname, jint version, jboolean verbose) {
jclass clazz;
jTaskbarCls = (*env)->NewGlobalRef(env, cls);
CHECK_NULL_RETURN(jTaskbarCallback =
(*env)->GetStaticMethodID(env, cls, "menuItemCallback", "(Ljava/awt/MenuItem;)V"), JNI_FALSE);
CHECK_NULL_RETURN(
clazz = (*env)->FindClass(env, "java/awt/MenuItem"), JNI_FALSE);
CHECK_NULL_RETURN(
jMenuItemGetLabel = (*env)->GetMethodID(env, clazz, "getLabel", "()Ljava/lang/String;"), JNI_FALSE);
if (gtk_load(env, version, verbose) && unity_load()) {
const gchar* name = (*env)->GetStringUTFChars(env, jname, NULL);
if (name) {
entry = fp_unity_launcher_entry_get_for_desktop_file(name);
(*env)->ReleaseStringUTFChars(env, jname, name);
return JNI_TRUE;
}
}
return JNI_FALSE;
}
static jstring
environmentBlock9x(JNIEnv *env)
{
int i;
jmethodID String_init_ID;
jbyteArray bytes;
jbyte *blockA;
jclass string_class;
string_class= JNU_ClassString(env);
CHECK_NULL_RETURN(string_class, NULL);
String_init_ID =
(*env)->GetMethodID(env, string_class, "<init>", "([B)V");
CHECK_NULL_RETURN(String_init_ID, NULL);
blockA = (jbyte *) GetEnvironmentStringsA();
if (blockA == NULL) {
/* Both GetEnvironmentStringsW and GetEnvironmentStringsA
* failed. Out of memory is our best guess. */
JNU_ThrowOutOfMemoryError(env, "GetEnvironmentStrings failed");
return NULL;
}
/* Don't search for "\0\0", since an empty environment block may
legitimately consist of a single "\0". */
for (i = 0; blockA[i];)
while (blockA[i++])
;
if ((bytes = (*env)->NewByteArray(env, i)) == NULL) {
FreeEnvironmentStringsA(blockA);
return NULL;
}
(*env)->SetByteArrayRegion(env, bytes, 0, i, blockA);
FreeEnvironmentStringsA(blockA);
return (*env)->NewObject(env, string_class,
String_init_ID, bytes);
}
// Create a new AwtTextField object and window.
AwtTextField* AwtTextField::Create(jobject peer, jobject hParent)
{
JNIEnv *env;
if (JVM->AttachCurrentThread((void **) &env, 0) != 0) {
return NULL;
}
CHECK_NULL_RETURN(hParent, "null hParent");
AwtCanvas* parent = (AwtCanvas*) env->GetIntField(hParent,
WCachedIDs.PPCObjectPeer_pDataFID);
CHECK_NULL_RETURN(parent, "null parent");
jobject target = env->GetObjectField(peer,
WCachedIDs.PPCObjectPeer_targetFID);
CHECK_NULL_RETURN(target, "null target");
AwtTextField* c = new AwtTextField();
CHECK_NULL_RETURN(c, "AwtTextField() failed");
DWORD style = WS_CHILD | WS_CLIPSIBLINGS |
ES_LEFT | ES_AUTOHSCROLL | ES_NOHIDESEL |
(IS_WIN4X ? 0 : WS_BORDER);
DWORD exStyle = IS_WIN4X ? WS_EX_CLIENTEDGE : 0;
c->CreateHWnd(TEXT(""), style, exStyle,
(int)env->CallIntMethod(target, WCachedIDs.java_awt_Component_getXMID),
(int)env->CallIntMethod(target, WCachedIDs.java_awt_Component_getYMID),
(int)env->CallIntMethod(target,WCachedIDs.java_awt_Component_getWidthMID),
(int)env->CallIntMethod(target,WCachedIDs.java_awt_Component_getHeightMID),
parent->GetHWnd(),
(HMENU)parent->CreateControlID(),
::GetSysColor(COLOR_WINDOWTEXT),
::GetSysColor(COLOR_WINDOW),
peer
);
c->m_backgroundColorSet = TRUE; // suppress inheriting parent's color.
return c;
}
STDMETHODIMP CRatDVDClassFactory::QueryInterface(REFIID riid, void** ppv)
{
ODS(_T("CRatDVDClassFactory::QueryInterface\n"));
CHECK_NULL_RETURN(ppv, E_POINTER);
if ( CLSID_RatDVDReader == riid )
{
*ppv = this;
this->AddRef();
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
jobject SockAddrToInetSocketAddress
(JNIEnv *env, struct sockaddr* sap) {
int port = 0;
jobject ia = NET_SockaddrToInetAddress(env, sap, &port);
if (ia == NULL)
return NULL;
if (isaCls == 0) {
initializeISA(env);
CHECK_NULL_RETURN(isaCls, NULL);
}
return (*env)->NewObject(env, isaCls, isaCtrID, ia, port);
}
int DenseMatrix_mm_read_strassen(DenseMatrix *m, char *file_name, int *nr_rows, int *nr_cols) {
int res;
MM_typecode matcode;
FILE *file;
file = fopen(file_name, "r");
CHECK_NULL_RETURN(file);
res = mm_read_banner(file, &matcode);
CHECK_ZERO_ERROR_RETURN(res, "Failed to read matrix code");
CHECK_ERROR_RETURN(!mm_is_matrix(matcode), "File is not a matrix", 1);
if (mm_is_sparse(matcode)) {
int nr_sparse_elements;
res = mm_read_mtx_crd_size(file, nr_rows, nr_cols, &nr_sparse_elements);
CHECK_ZERO_ERROR_RETURN(res, "Failed to read sparse mm dimensions");
int dim = pow2dim(*nr_rows, *nr_cols);
// Initialzie matrix to zero to fill in with sparse elements
res = DenseMatrix_init_zero(m, dim, dim);
CHECK_ZERO_ERROR_RETURN(res, "Failed to allocate memory for mm matrix");
res = DenseMatrix_parse_mm_sparse(m, file, nr_sparse_elements);
} else if (mm_is_dense(matcode)) {
res = mm_read_mtx_array_size(file, nr_rows, nr_cols);
CHECK_ZERO_ERROR_RETURN(res, "Failed to read dense mm dimensions");
int dim = pow2dim(*nr_rows, *nr_cols);
res = DenseMatrix_init_zero(m, dim, dim);
CHECK_ZERO_ERROR_RETURN(res, "Failed to allocate memory for mm matrix");
res = DenseMatrix_parse_mm_dense(m, file);
} else {
ERROR("mm matrix code is not supported. Only supports dense and sparse matrices");
}
CHECK_ZERO_ERROR_RETURN(res, "Failed to parse mm file");
return 0;
}
HRESULT WSAccessor::AutoDispInvoke(LPDISPATCH pdisp, LPOLESTR pwszname, DISPID dspid,
WORD wflags, DWORD cargs, VARIANT* rgargs, VARIANT* pvtret)
{
HRESULT hr;
DISPID dspidPut = DISPID_PROPERTYPUT;
DISPPARAMS dspparm = {NULL, NULL, 0, 0};
CHECK_NULL_RETURN(pdisp, E_POINTER);
dspparm.rgvarg = rgargs;
dspparm.cArgs = cargs;
if ((wflags & DISPATCH_PROPERTYPUT) || (wflags & DISPATCH_PROPERTYPUTREF))
{
dspparm.rgdispidNamedArgs = &dspidPut;
dspparm.cNamedArgs = 1;
}
try
{
if (pwszname)
{
hr = pdisp->GetIDsOfNames(IID_NULL, &pwszname, 1, LOCALE_USER_DEFAULT, &dspid);
//RETURN_ON_FAILURE(hr);
if( FAILED(hr))
{
*(_variant_t*)pvtret = L"方法名获取失败，可能拼写错误!";
return hr;
}
}
hr = pdisp->Invoke(dspid, IID_NULL, LOCALE_USER_DEFAULT,
(WORD)(DISPATCH_METHOD | wflags), &dspparm, pvtret, NULL, NULL);
}
catch(...)
{
hr = S_FALSE;
}
return hr;
}
jboolean
awtJNI_ThreadYield(JNIEnv *env) {
static jclass threadClass = NULL;
static jmethodID yieldMethodID = NULL;
/* Initialize our java identifiers once. Checking before locking
* is a huge performance win.
*/
if (threadClass == NULL) {
// should enter a monitor here...
Boolean err = FALSE;
if (threadClass == NULL) {
jclass tc = (*env)->FindClass(env, "java/lang/Thread");
CHECK_NULL_RETURN(tc, JNI_FALSE);
threadClass = (*env)->NewGlobalRef(env, tc);
(*env)->DeleteLocalRef(env, tc);
if (threadClass != NULL) {
yieldMethodID = (*env)->GetStaticMethodID(env,
threadClass,
"yield",
"()V"
);
}
}
if (yieldMethodID == NULL) {
threadClass = NULL;
err = TRUE;
}
if (err) {
return JNI_FALSE;
}
} /* threadClass == NULL*/
(*env)->CallStaticVoidMethod(env, threadClass, yieldMethodID);
DASSERT(!((*env)->ExceptionOccurred(env)));
if ((*env)->ExceptionCheck(env)) {
return JNI_FALSE;
}
return JNI_TRUE;
} /* awtJNI_ThreadYield() */
jobject
AwtChoice::PreferredItemSize(JNIEnv* env)
{
jobject peer = GetPeer();
jobject target = env->GetObjectField( peer,
WCachedIDs.PPCObjectPeer_targetFID);
CHECK_NULL_RETURN( target, "null target" );
jobject dimension = env->CallObjectMethod( target,
WCachedIDs.java_awt_Component_getPreferredSizeMID
);
ASSERT( !env->ExceptionCheck() );
// This size is window size of choice and it's too big for
// each drop down item height.
// Rather than invoking the setSize() method, just
// set the height field directly.
env->SetIntField( dimension,
WCachedIDs.java_awt_Dimension_heightFID,
GetFontHeight() );
return dimension;
}
/*
* Returns list of media: pages + trays
*/
JNIEXPORT jobjectArray JNICALL
Java_sun_print_CUPSPrinter_getMedia(JNIEnv *env,
jobject printObj,
jstring printer)
{
ppd_file_t *ppd;
ppd_option_t *optionTray, *optionPage;
ppd_choice_t *choice;
const char *name;
const char *filename;
int i, nTrays=0, nPages=0, nTotal=0;
jstring utf_str;
jclass cls;
jobjectArray nameArray = NULL;
name = (*env)->GetStringUTFChars(env, printer, NULL);
if (name == NULL) {
(*env)->ExceptionClear(env);
JNU_ThrowOutOfMemoryError(env, "Could not create printer name");
return NULL;
}
// NOTE: cupsGetPPD returns a pointer to a filename of a temporary file.
// unlink() must be caled to remove the file when finished using it.
filename = j2d_cupsGetPPD(name);
(*env)->ReleaseStringUTFChars(env, printer, name);
CHECK_NULL_RETURN(filename, NULL);
cls = (*env)->FindClass(env, "java/lang/String");
CHECK_NULL_RETURN(cls, NULL);
if ((ppd = j2d_ppdOpenFile(filename)) == NULL) {
unlink(filename);
DPRINTF("CUPSfuncs::unable to open PPD %s\n", filename);
return NULL;
}
optionPage = j2d_ppdFindOption(ppd, "PageSize");
if (optionPage != NULL) {
nPages = optionPage->num_choices;
}
optionTray = j2d_ppdFindOption(ppd, "InputSlot");
if (optionTray != NULL) {
nTrays = optionTray->num_choices;
}
if ((nTotal = (nPages+nTrays) *2) > 0) {
nameArray = (*env)->NewObjectArray(env, nTotal, cls, NULL);
if (nameArray == NULL) {
unlink(filename);
j2d_ppdClose(ppd);
DPRINTF("CUPSfuncs::bad alloc new array\n", "")
(*env)->ExceptionClear(env);
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
return NULL;
}
for (i = 0; optionPage!=NULL && i<nPages; i++) {
choice = (optionPage->choices)+i;
utf_str = JNU_NewStringPlatform(env, choice->text);
if (utf_str == NULL) {
unlink(filename);
j2d_ppdClose(ppd);
DPRINTF("CUPSfuncs::bad alloc new string ->text\n", "")
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
return NULL;
}
(*env)->SetObjectArrayElement(env, nameArray, i*2, utf_str);
(*env)->DeleteLocalRef(env, utf_str);
utf_str = JNU_NewStringPlatform(env, choice->choice);
if (utf_str == NULL) {
unlink(filename);
j2d_ppdClose(ppd);
DPRINTF("CUPSfuncs::bad alloc new string ->choice\n", "")
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
return NULL;
}
(*env)->SetObjectArrayElement(env, nameArray, i*2+1, utf_str);
(*env)->DeleteLocalRef(env, utf_str);
}
for (i = 0; optionTray!=NULL && i<nTrays; i++) {
choice = (optionTray->choices)+i;
utf_str = JNU_NewStringPlatform(env, choice->text);
if (utf_str == NULL) {
unlink(filename);
j2d_ppdClose(ppd);
DPRINTF("CUPSfuncs::bad alloc new string text\n", "")
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
return NULL;
}
(*env)->SetObjectArrayElement(env, nameArray,
(nPages+i)*2, utf_str);
(*env)->DeleteLocalRef(env, utf_str);
utf_str = JNU_NewStringPlatform(env, choice->choice);
if (utf_str == NULL) {
unlink(filename);
j2d_ppdClose(ppd);
DPRINTF("CUPSfuncs::bad alloc new string choice\n", "")
JNU_ThrowOutOfMemoryError(env, "OutOfMemoryError");
return NULL;
}
(*env)->SetObjectArrayElement(env, nameArray,
(nPages+i)*2+1, utf_str);
(*env)->DeleteLocalRef(env, utf_str);
}
}
j2d_ppdClose(ppd);
unlink(filename);
return nameArray;
}
////////////////////////////////////////////////////////////////////////
// get_Value
//
HRESULT CDocProperty::get_Value(VARIANT *pvValue)
{
ODS(_T("CDocProperty::get_Value\n"));
CHECK_NULL_RETURN(pvValue, E_POINTER);
return VariantCopy(pvValue, &m_vValue);
}
/*
* Class: sun_nio_ch_sctp_SctpNet
* Method: getLocalAddresses0
* Signature: (I)[Ljava/net/SocketAddress;
*/
JNIEXPORT jobjectArray JNICALL Java_sun_nio_ch_sctp_SctpNet_getLocalAddresses0
(JNIEnv *env, jclass klass, jint fd) {
void *addr_buf, *laddr;
struct sockaddr* sap;
int i, addrCount;
jobjectArray isaa;
#ifdef __solaris__
if ((addrCount = nio_sctp_getladdrs(fd, 0, (void **)&addr_buf)) == -1) {
#else /* __linux__ */
if ((addrCount = nio_sctp_getladdrs(fd, 0, (struct sockaddr **)&addr_buf)) == -1) {
#endif
handleSocketError(env, errno);
return NULL;
}
if (addrCount < 1)
return NULL;
if (isaCls == 0) {
initializeISA(env);
CHECK_NULL_RETURN(isaCls, NULL);
}
isaa = (*env)->NewObjectArray(env, addrCount, isaCls, NULL);
if (isaa == NULL) {
nio_sctp_freeladdrs(addr_buf);
return NULL;
}
laddr = addr_buf;
for (i=0; i<addrCount; i++) {
int port = 0;
jobject isa = NULL, ia;
sap = (struct sockaddr*)addr_buf;
ia = NET_SockaddrToInetAddress(env, sap, &port);
if (ia != NULL)
isa = (*env)->NewObject(env, isaCls, isaCtrID, ia, port);
if (isa == NULL)
break;
(*env)->SetObjectArrayElement(env, isaa, i, isa);
if (sap->sa_family == AF_INET)
addr_buf = ((struct sockaddr_in*)addr_buf) + 1;
else
addr_buf = ((struct sockaddr_in6*)addr_buf) + 1;
}
nio_sctp_freeladdrs(laddr);
return isaa;
}
jobjectArray getRemoteAddresses
(JNIEnv *env, jint fd, sctp_assoc_t id) {
void *addr_buf, *paddr;
struct sockaddr* sap;
int i, addrCount;
jobjectArray isaa;
#if __solaris__
if ((addrCount = nio_sctp_getpaddrs(fd, id, (void **)&addr_buf)) == -1) {
#else /* __linux__ */
if ((addrCount = nio_sctp_getpaddrs(fd, id, (struct sockaddr**)&addr_buf)) == -1) {
#endif
handleSocketError(env, errno);
return NULL;
}
if (addrCount < 1)
return NULL;
if (isaCls == 0) {
initializeISA(env);
CHECK_NULL_RETURN(isaCls, NULL);
}
isaa = (*env)->NewObjectArray(env, addrCount, isaCls, NULL);
if (isaa == NULL) {
nio_sctp_freepaddrs(addr_buf);
return NULL;
}
paddr = addr_buf;
for (i=0; i<addrCount; i++) {
jobject ia, isa = NULL;
int port = 0;
sap = (struct sockaddr*)addr_buf;
ia = NET_SockaddrToInetAddress(env, sap, &port);
if (ia != NULL)
isa = (*env)->NewObject(env, isaCls, isaCtrID, ia, port);
if (isa == NULL)
break;
(*env)->SetObjectArrayElement(env, isaa, i, isa);
if (sap->sa_family == AF_INET)
addr_buf = ((struct sockaddr_in*)addr_buf) + 1;
else
addr_buf = ((struct sockaddr_in6*)addr_buf) + 1;
}
nio_sctp_freepaddrs(paddr);
return isaa;
}
/*
* Class: sun_nio_ch_sctp_SctpNet
* Method: getRemoteAddresses0
* Signature: (II)[Ljava/net/SocketAddress;
*/
JNIEXPORT jobjectArray JNICALL Java_sun_nio_ch_sctp_SctpNet_getRemoteAddresses0
(JNIEnv *env, jclass klass, jint fd, jint assocId) {
return getRemoteAddresses(env, fd, assocId);
}
/* Map the Java level option to the native level */
int mapSocketOption
(jint cmd, int *level, int *optname) {
static struct {
jint cmd;
int level;
int optname;
} const opts[] = {
{ sun_nio_ch_sctp_SctpStdSocketOption_SCTP_DISABLE_FRAGMENTS, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS },
{ sun_nio_ch_sctp_SctpStdSocketOption_SCTP_EXPLICIT_COMPLETE, IPPROTO_SCTP, SCTP_EXPLICIT_EOR },
{ sun_nio_ch_sctp_SctpStdSocketOption_SCTP_FRAGMENT_INTERLEAVE, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE },
{ sun_nio_ch_sctp_SctpStdSocketOption_SCTP_NODELAY, IPPROTO_SCTP, SCTP_NODELAY },
{ sun_nio_ch_sctp_SctpStdSocketOption_SO_SNDBUF, SOL_SOCKET, SO_SNDBUF },
{ sun_nio_ch_sctp_SctpStdSocketOption_SO_RCVBUF, SOL_SOCKET, SO_RCVBUF },
{ sun_nio_ch_sctp_SctpStdSocketOption_SO_LINGER, SOL_SOCKET, SO_LINGER } };
int i;
for (i=0; i<(int)(sizeof(opts) / sizeof(opts[0])); i++) {
if (cmd == opts[i].cmd) {
*level = opts[i].level;
*optname = opts[i].optname;
return 0;
}
}
/* not found */
return -1;
}
/*
* Class: sun_nio_ch_sctp_SctpNet
* Method: setIntOption0
* Signature: (III)V
*/
JNIEXPORT void JNICALL Java_sun_nio_ch_sctp_SctpNet_setIntOption0
(JNIEnv *env, jclass klass, jint fd, jint opt, int arg) {
int klevel, kopt;
int result;
struct linger linger;
void *parg;
int arglen;
if (mapSocketOption(opt, &klevel, &kopt) < 0) {
JNU_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
"Unsupported socket option");
return;
}
if (opt == sun_nio_ch_sctp_SctpStdSocketOption_SO_LINGER) {
parg = (void *)&linger;
arglen = sizeof(linger);
if (arg >= 0) {
linger.l_onoff = 1;
linger.l_linger = arg;
} else {
linger.l_onoff = 0;
linger.l_linger = 0;
}
} else {
parg = (void *)&arg;
arglen = sizeof(arg);
}
if (NET_SetSockOpt(fd, klevel, kopt, parg, arglen) < 0) {
JNU_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
"sun_nio_ch_sctp_SctpNet.setIntOption0");
}
}
STDAPI_(LPVOID) DsoMemAlloc(DWORD cbSize)
{
CHECK_NULL_RETURN(v_hPrivateHeap, NULL);
return HeapAlloc(v_hPrivateHeap, HEAP_ZERO_MEMORY, cbSize);
}
/*
* Create a NetworkInterface object, populate the name and index, and
* populate the InetAddress array based on the IP addresses for this
* interface.
*/
jobject createNetworkInterface
(JNIEnv *env, netif *ifs, int netaddrCount, netaddr *netaddrP)
{
jobject netifObj;
jobject name, displayName;
jobjectArray addrArr, bindsArr, childArr;
netaddr *addrs;
jint addr_index;
jint bind_index;
/*
* Create a NetworkInterface object and populate it
*/
netifObj = (*env)->NewObject(env, ni_class, ni_ctor);
CHECK_NULL_RETURN(netifObj, NULL);
name = (*env)->NewStringUTF(env, ifs->name);
CHECK_NULL_RETURN(name, NULL);
if (ifs->dNameIsUnicode) {
displayName = (*env)->NewString(env, (PWCHAR)ifs->displayName,
(jsize)wcslen ((PWCHAR)ifs->displayName));
} else {
displayName = (*env)->NewStringUTF(env, ifs->displayName);
}
CHECK_NULL_RETURN(displayName, NULL);
(*env)->SetObjectField(env, netifObj, ni_nameID, name);
(*env)->SetObjectField(env, netifObj, ni_displayNameID, displayName);
(*env)->SetIntField(env, netifObj, ni_indexID, ifs->index);
/*
* Get the IP addresses for this interface if necessary
* Note that 0 is a valid number of addresses.
*/
if (netaddrCount < 0) {
netaddrCount = enumAddresses_win(env, ifs, &netaddrP);
if (netaddrCount == -1) {
return NULL;
}
}
addrArr = (*env)->NewObjectArray(env, netaddrCount, ni_iacls, NULL);
if (addrArr == NULL) {
free_netaddr(netaddrP);
return NULL;
}
bindsArr = (*env)->NewObjectArray(env, netaddrCount, ni_ibcls, NULL);
if (bindsArr == NULL) {
free_netaddr(netaddrP);
return NULL;
}
addrs = netaddrP;
addr_index = 0;
bind_index = 0;
while (addrs != NULL) {
jobject iaObj, ia2Obj;
jobject ibObj = NULL;
if (addrs->addr.him.sa_family == AF_INET) {
iaObj = (*env)->NewObject(env, ni_ia4cls, ni_ia4Ctor);
if (iaObj == NULL) {
free_netaddr(netaddrP);
return NULL;
}
/* default ctor will set family to AF_INET */
setInetAddress_addr(env, iaObj, ntohl(addrs->addr.him4.sin_addr.s_addr));
if (addrs->mask != -1) {
ibObj = (*env)->NewObject(env, ni_ibcls, ni_ibctrID);
if (ibObj == NULL) {
free_netaddr(netaddrP);
return NULL;
}
(*env)->SetObjectField(env, ibObj, ni_ibaddressID, iaObj);
ia2Obj = (*env)->NewObject(env, ni_ia4cls, ni_ia4Ctor);
if (ia2Obj == NULL) {
free_netaddr(netaddrP);
return NULL;
}
setInetAddress_addr(env, ia2Obj, ntohl(addrs->brdcast.him4.sin_addr.s_addr));
(*env)->SetObjectField(env, ibObj, ni_ibbroadcastID, ia2Obj);
(*env)->SetShortField(env, ibObj, ni_ibmaskID, addrs->mask);
(*env)->SetObjectArrayElement(env, bindsArr, bind_index++, ibObj);
}
} else { /* AF_INET6 */
int scope;
iaObj = (*env)->NewObject(env, ni_ia6cls, ni_ia6ctrID);
if (iaObj) {
int ret = setInet6Address_ipaddress(env, iaObj, (jbyte *)&(addrs->addr.him6.sin6_addr.s6_addr));
if (ret == JNI_FALSE) {
return NULL;
}
scope = addrs->addr.him6.sin6_scope_id;
if (scope != 0) { /* zero is default value, no need to set */
setInet6Address_scopeid(env, iaObj, scope);
setInet6Address_scopeifname(env, iaObj, netifObj);
}
ibObj = (*env)->NewObject(env, ni_ibcls, ni_ibctrID);
if (ibObj == NULL) {
free_netaddr(netaddrP);
return NULL;
}
(*env)->SetObjectField(env, ibObj, ni_ibaddressID, iaObj);
(*env)->SetShortField(env, ibObj, ni_ibmaskID, addrs->mask);
(*env)->SetObjectArrayElement(env, bindsArr, bind_index++, ibObj);
}
}
(*env)->SetObjectArrayElement(env, addrArr, addr_index, iaObj);
addrs = addrs->next;
addr_index++;
}
(*env)->SetObjectField(env, netifObj, ni_addrsID, addrArr);
(*env)->SetObjectField(env, netifObj, ni_bindsID, bindsArr);
free_netaddr(netaddrP);
/*
* Windows doesn't have virtual interfaces, so child array
* is always empty.
*/
childArr = (*env)->NewObjectArray(env, 0, ni_class, NULL);
if (childArr == NULL) {
return NULL;
}
(*env)->SetObjectField(env, netifObj, ni_childsID, childArr);
/* return the NetworkInterface */
return netifObj;
}
