bundles/org.eclipse.swt.win32.win32.x86_64/library/com_structs.c

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2019 IBM Corporation and others.
   3  *
   4  * This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License 2.0
   6  * which accompanies this distribution, and is available at
   7  * https://www.eclipse.org/legal/epl-2.0/
   8  *
   9  * SPDX-License-Identifier: EPL-2.0
  10  *
  11  * Contributors:
  12  *    IBM Corporation - initial API and implementation
  13  *******************************************************************************/
  14
  15 /* Note: This file was auto-generated by org.eclipse.swt.tools.internal.JNIGenerator */
  16 /* DO NOT EDIT - your changes will be lost. */
  17
  18 #include "swt.h"
  19 #include "com_structs.h"
  20
  21 #ifndef NO_CAUUID
  22 typedef struct CAUUID_FID_CACHE {
  23         int cached;
  24         jclass clazz;
  25         jfieldID cElems, pElems;
  26 } CAUUID_FID_CACHE;
  27
  28 CAUUID_FID_CACHE CAUUIDFc;
  29
  30 void cacheCAUUIDFields(JNIEnv *env, jobject lpObject)
  31 {
  32         if (CAUUIDFc.cached) return;
  33         CAUUIDFc.clazz = (*env)->GetObjectClass(env, lpObject);
  34         CAUUIDFc.cElems = (*env)->GetFieldID(env, CAUUIDFc.clazz, "cElems", "I");
  35         CAUUIDFc.pElems = (*env)->GetFieldID(env, CAUUIDFc.clazz, "pElems", "J");
  36         CAUUIDFc.cached = 1;
  37 }
  38
  39 CAUUID *getCAUUIDFields(JNIEnv *env, jobject lpObject, CAUUID *lpStruct)
  40 {
  41         if (!CAUUIDFc.cached) cacheCAUUIDFields(env, lpObject);
  42         lpStruct->cElems = (*env)->GetIntField(env, lpObject, CAUUIDFc.cElems);
  43         lpStruct->pElems = (GUID FAR *)(*env)->GetLongField(env, lpObject, CAUUIDFc.pElems);
  44         return lpStruct;
  45 }
  46
  47 void setCAUUIDFields(JNIEnv *env, jobject lpObject, CAUUID *lpStruct)
  48 {
  49         if (!CAUUIDFc.cached) cacheCAUUIDFields(env, lpObject);
  50         (*env)->SetIntField(env, lpObject, CAUUIDFc.cElems, (jint)lpStruct->cElems);
  51         (*env)->SetLongField(env, lpObject, CAUUIDFc.pElems, (jlong)lpStruct->pElems);
  52 }
  53 #endif
  54
  55 #ifndef NO_CONTROLINFO
  56 typedef struct CONTROLINFO_FID_CACHE {
  57         int cached;
  58         jclass clazz;
  59         jfieldID cb, hAccel, cAccel, dwFlags;
  60 } CONTROLINFO_FID_CACHE;
  61
  62 CONTROLINFO_FID_CACHE CONTROLINFOFc;
  63
  64 void cacheCONTROLINFOFields(JNIEnv *env, jobject lpObject)
  65 {
  66         if (CONTROLINFOFc.cached) return;
  67         CONTROLINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
  68         CONTROLINFOFc.cb = (*env)->GetFieldID(env, CONTROLINFOFc.clazz, "cb", "I");
  69         CONTROLINFOFc.hAccel = (*env)->GetFieldID(env, CONTROLINFOFc.clazz, "hAccel", "J");
  70         CONTROLINFOFc.cAccel = (*env)->GetFieldID(env, CONTROLINFOFc.clazz, "cAccel", "S");
  71         CONTROLINFOFc.dwFlags = (*env)->GetFieldID(env, CONTROLINFOFc.clazz, "dwFlags", "I");
  72         CONTROLINFOFc.cached = 1;
  73 }
  74
  75 CONTROLINFO *getCONTROLINFOFields(JNIEnv *env, jobject lpObject, CONTROLINFO *lpStruct)
  76 {
  77         if (!CONTROLINFOFc.cached) cacheCONTROLINFOFields(env, lpObject);
  78         lpStruct->cb = (*env)->GetIntField(env, lpObject, CONTROLINFOFc.cb);
  79         lpStruct->hAccel = (HACCEL)(*env)->GetLongField(env, lpObject, CONTROLINFOFc.hAccel);
  80         lpStruct->cAccel = (*env)->GetShortField(env, lpObject, CONTROLINFOFc.cAccel);
  81         lpStruct->dwFlags = (*env)->GetIntField(env, lpObject, CONTROLINFOFc.dwFlags);
  82         return lpStruct;
  83 }
  84
  85 void setCONTROLINFOFields(JNIEnv *env, jobject lpObject, CONTROLINFO *lpStruct)
  86 {
  87         if (!CONTROLINFOFc.cached) cacheCONTROLINFOFields(env, lpObject);
  88         (*env)->SetIntField(env, lpObject, CONTROLINFOFc.cb, (jint)lpStruct->cb);
  89         (*env)->SetLongField(env, lpObject, CONTROLINFOFc.hAccel, (jlong)lpStruct->hAccel);
  90         (*env)->SetShortField(env, lpObject, CONTROLINFOFc.cAccel, (jshort)lpStruct->cAccel);
  91         (*env)->SetIntField(env, lpObject, CONTROLINFOFc.dwFlags, (jint)lpStruct->dwFlags);
  92 }
  93 #endif
  94
  95 #ifndef NO_DISPPARAMS
  96 typedef struct DISPPARAMS_FID_CACHE {
  97         int cached;
  98         jclass clazz;
  99         jfieldID rgvarg, rgdispidNamedArgs, cArgs, cNamedArgs;
 100 } DISPPARAMS_FID_CACHE;
 101
 102 DISPPARAMS_FID_CACHE DISPPARAMSFc;
 103
 104 void cacheDISPPARAMSFields(JNIEnv *env, jobject lpObject)
 105 {
 106         if (DISPPARAMSFc.cached) return;
 107         DISPPARAMSFc.clazz = (*env)->GetObjectClass(env, lpObject);
 108         DISPPARAMSFc.rgvarg = (*env)->GetFieldID(env, DISPPARAMSFc.clazz, "rgvarg", "J");
 109         DISPPARAMSFc.rgdispidNamedArgs = (*env)->GetFieldID(env, DISPPARAMSFc.clazz, "rgdispidNamedArgs", "J");
 110         DISPPARAMSFc.cArgs = (*env)->GetFieldID(env, DISPPARAMSFc.clazz, "cArgs", "I");
 111         DISPPARAMSFc.cNamedArgs = (*env)->GetFieldID(env, DISPPARAMSFc.clazz, "cNamedArgs", "I");
 112         DISPPARAMSFc.cached = 1;
 113 }
 114
 115 DISPPARAMS *getDISPPARAMSFields(JNIEnv *env, jobject lpObject, DISPPARAMS *lpStruct)
 116 {
 117         if (!DISPPARAMSFc.cached) cacheDISPPARAMSFields(env, lpObject);
 118         lpStruct->rgvarg = (VARIANTARG FAR *)(*env)->GetLongField(env, lpObject, DISPPARAMSFc.rgvarg);
 119         lpStruct->rgdispidNamedArgs = (DISPID FAR *)(*env)->GetLongField(env, lpObject, DISPPARAMSFc.rgdispidNamedArgs);
 120         lpStruct->cArgs = (*env)->GetIntField(env, lpObject, DISPPARAMSFc.cArgs);
 121         lpStruct->cNamedArgs = (*env)->GetIntField(env, lpObject, DISPPARAMSFc.cNamedArgs);
 122         return lpStruct;
 123 }
 124
 125 void setDISPPARAMSFields(JNIEnv *env, jobject lpObject, DISPPARAMS *lpStruct)
 126 {
 127         if (!DISPPARAMSFc.cached) cacheDISPPARAMSFields(env, lpObject);
 128         (*env)->SetLongField(env, lpObject, DISPPARAMSFc.rgvarg, (jlong)lpStruct->rgvarg);
 129         (*env)->SetLongField(env, lpObject, DISPPARAMSFc.rgdispidNamedArgs, (jlong)lpStruct->rgdispidNamedArgs);
 130         (*env)->SetIntField(env, lpObject, DISPPARAMSFc.cArgs, (jint)lpStruct->cArgs);
 131         (*env)->SetIntField(env, lpObject, DISPPARAMSFc.cNamedArgs, (jint)lpStruct->cNamedArgs);
 132 }
 133 #endif
 134
 135 #ifndef NO_EXCEPINFO
 136 typedef struct EXCEPINFO_FID_CACHE {
 137         int cached;
 138         jclass clazz;
 139         jfieldID wCode, wReserved, bstrSource, bstrDescription, bstrHelpFile, dwHelpContext, pvReserved, pfnDeferredFillIn, scode;
 140 } EXCEPINFO_FID_CACHE;
 141
 142 EXCEPINFO_FID_CACHE EXCEPINFOFc;
 143
 144 void cacheEXCEPINFOFields(JNIEnv *env, jobject lpObject)
 145 {
 146         if (EXCEPINFOFc.cached) return;
 147         EXCEPINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
 148         EXCEPINFOFc.wCode = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "wCode", "S");
 149         EXCEPINFOFc.wReserved = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "wReserved", "S");
 150         EXCEPINFOFc.bstrSource = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "bstrSource", "J");
 151         EXCEPINFOFc.bstrDescription = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "bstrDescription", "J");
 152         EXCEPINFOFc.bstrHelpFile = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "bstrHelpFile", "J");
 153         EXCEPINFOFc.dwHelpContext = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "dwHelpContext", "I");
 154         EXCEPINFOFc.pvReserved = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "pvReserved", "J");
 155         EXCEPINFOFc.pfnDeferredFillIn = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "pfnDeferredFillIn", "J");
 156         EXCEPINFOFc.scode = (*env)->GetFieldID(env, EXCEPINFOFc.clazz, "scode", "I");
 157         EXCEPINFOFc.cached = 1;
 158 }
 159
 160 EXCEPINFO *getEXCEPINFOFields(JNIEnv *env, jobject lpObject, EXCEPINFO *lpStruct)
 161 {
 162         if (!EXCEPINFOFc.cached) cacheEXCEPINFOFields(env, lpObject);
 163         lpStruct->wCode = (*env)->GetShortField(env, lpObject, EXCEPINFOFc.wCode);
 164         lpStruct->wReserved = (*env)->GetShortField(env, lpObject, EXCEPINFOFc.wReserved);
 165         lpStruct->bstrSource = (BSTR)(*env)->GetLongField(env, lpObject, EXCEPINFOFc.bstrSource);
 166         lpStruct->bstrDescription = (BSTR)(*env)->GetLongField(env, lpObject, EXCEPINFOFc.bstrDescription);
 167         lpStruct->bstrHelpFile = (BSTR)(*env)->GetLongField(env, lpObject, EXCEPINFOFc.bstrHelpFile);
 168         lpStruct->dwHelpContext = (*env)->GetIntField(env, lpObject, EXCEPINFOFc.dwHelpContext);
 169         lpStruct->pvReserved = (void FAR *)(*env)->GetLongField(env, lpObject, EXCEPINFOFc.pvReserved);
 170         lpStruct->pfnDeferredFillIn = (HRESULT (STDAPICALLTYPE FAR* )(struct tagEXCEPINFO FAR*))(*env)->GetLongField(env, lpObject, EXCEPINFOFc.pfnDeferredFillIn);
 171         lpStruct->scode = (*env)->GetIntField(env, lpObject, EXCEPINFOFc.scode);
 172         return lpStruct;
 173 }
 174
 175 void setEXCEPINFOFields(JNIEnv *env, jobject lpObject, EXCEPINFO *lpStruct)
 176 {
 177         if (!EXCEPINFOFc.cached) cacheEXCEPINFOFields(env, lpObject);
 178         (*env)->SetShortField(env, lpObject, EXCEPINFOFc.wCode, (jshort)lpStruct->wCode);
 179         (*env)->SetShortField(env, lpObject, EXCEPINFOFc.wReserved, (jshort)lpStruct->wReserved);
 180         (*env)->SetLongField(env, lpObject, EXCEPINFOFc.bstrSource, (jlong)lpStruct->bstrSource);
 181         (*env)->SetLongField(env, lpObject, EXCEPINFOFc.bstrDescription, (jlong)lpStruct->bstrDescription);
 182         (*env)->SetLongField(env, lpObject, EXCEPINFOFc.bstrHelpFile, (jlong)lpStruct->bstrHelpFile);
 183         (*env)->SetIntField(env, lpObject, EXCEPINFOFc.dwHelpContext, (jint)lpStruct->dwHelpContext);
 184         (*env)->SetLongField(env, lpObject, EXCEPINFOFc.pvReserved, (jlong)lpStruct->pvReserved);
 185         (*env)->SetLongField(env, lpObject, EXCEPINFOFc.pfnDeferredFillIn, (jlong)lpStruct->pfnDeferredFillIn);
 186         (*env)->SetIntField(env, lpObject, EXCEPINFOFc.scode, (jint)lpStruct->scode);
 187 }
 188 #endif
 189
 190 #ifndef NO_FORMATETC
 191 typedef struct FORMATETC_FID_CACHE {
 192         int cached;
 193         jclass clazz;
 194         jfieldID cfFormat, ptd, dwAspect, lindex, tymed;
 195 } FORMATETC_FID_CACHE;
 196
 197 FORMATETC_FID_CACHE FORMATETCFc;
 198
 199 void cacheFORMATETCFields(JNIEnv *env, jobject lpObject)
 200 {
 201         if (FORMATETCFc.cached) return;
 202         FORMATETCFc.clazz = (*env)->GetObjectClass(env, lpObject);
 203         FORMATETCFc.cfFormat = (*env)->GetFieldID(env, FORMATETCFc.clazz, "cfFormat", "I");
 204         FORMATETCFc.ptd = (*env)->GetFieldID(env, FORMATETCFc.clazz, "ptd", "J");
 205         FORMATETCFc.dwAspect = (*env)->GetFieldID(env, FORMATETCFc.clazz, "dwAspect", "I");
 206         FORMATETCFc.lindex = (*env)->GetFieldID(env, FORMATETCFc.clazz, "lindex", "I");
 207         FORMATETCFc.tymed = (*env)->GetFieldID(env, FORMATETCFc.clazz, "tymed", "I");
 208         FORMATETCFc.cached = 1;
 209 }
 210
 211 FORMATETC *getFORMATETCFields(JNIEnv *env, jobject lpObject, FORMATETC *lpStruct)
 212 {
 213         if (!FORMATETCFc.cached) cacheFORMATETCFields(env, lpObject);
 214         lpStruct->cfFormat = (CLIPFORMAT)(*env)->GetIntField(env, lpObject, FORMATETCFc.cfFormat);
 215         lpStruct->ptd = (DVTARGETDEVICE *)(*env)->GetLongField(env, lpObject, FORMATETCFc.ptd);
 216         lpStruct->dwAspect = (*env)->GetIntField(env, lpObject, FORMATETCFc.dwAspect);
 217         lpStruct->lindex = (*env)->GetIntField(env, lpObject, FORMATETCFc.lindex);
 218         lpStruct->tymed = (*env)->GetIntField(env, lpObject, FORMATETCFc.tymed);
 219         return lpStruct;
 220 }
 221
 222 void setFORMATETCFields(JNIEnv *env, jobject lpObject, FORMATETC *lpStruct)
 223 {
 224         if (!FORMATETCFc.cached) cacheFORMATETCFields(env, lpObject);
 225         (*env)->SetIntField(env, lpObject, FORMATETCFc.cfFormat, (jint)lpStruct->cfFormat);
 226         (*env)->SetLongField(env, lpObject, FORMATETCFc.ptd, (jlong)lpStruct->ptd);
 227         (*env)->SetIntField(env, lpObject, FORMATETCFc.dwAspect, (jint)lpStruct->dwAspect);
 228         (*env)->SetIntField(env, lpObject, FORMATETCFc.lindex, (jint)lpStruct->lindex);
 229         (*env)->SetIntField(env, lpObject, FORMATETCFc.tymed, (jint)lpStruct->tymed);
 230 }
 231 #endif
 232
 233 #ifndef NO_FUNCDESC
 234 typedef struct FUNCDESC_FID_CACHE {
 235         int cached;
 236         jclass clazz;
 237         jfieldID memid, lprgscode, lprgelemdescParam, funckind, invkind, callconv, cParams, cParamsOpt, oVft, cScodes, elemdescFunc_tdesc_union, elemdescFunc_tdesc_vt, elemdescFunc_paramdesc_pparamdescex, elemdescFunc_paramdesc_wParamFlags, wFuncFlags;
 238 } FUNCDESC_FID_CACHE;
 239
 240 FUNCDESC_FID_CACHE FUNCDESCFc;
 241
 242 void cacheFUNCDESCFields(JNIEnv *env, jobject lpObject)
 243 {
 244         if (FUNCDESCFc.cached) return;
 245         FUNCDESCFc.clazz = (*env)->GetObjectClass(env, lpObject);
 246         FUNCDESCFc.memid = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "memid", "I");
 247         FUNCDESCFc.lprgscode = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "lprgscode", "J");
 248         FUNCDESCFc.lprgelemdescParam = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "lprgelemdescParam", "J");
 249         FUNCDESCFc.funckind = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "funckind", "I");
 250         FUNCDESCFc.invkind = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "invkind", "I");
 251         FUNCDESCFc.callconv = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "callconv", "I");
 252         FUNCDESCFc.cParams = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "cParams", "S");
 253         FUNCDESCFc.cParamsOpt = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "cParamsOpt", "S");
 254         FUNCDESCFc.oVft = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "oVft", "S");
 255         FUNCDESCFc.cScodes = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "cScodes", "S");
 256         FUNCDESCFc.elemdescFunc_tdesc_union = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "elemdescFunc_tdesc_union", "J");
 257         FUNCDESCFc.elemdescFunc_tdesc_vt = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "elemdescFunc_tdesc_vt", "S");
 258         FUNCDESCFc.elemdescFunc_paramdesc_pparamdescex = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "elemdescFunc_paramdesc_pparamdescex", "J");
 259         FUNCDESCFc.elemdescFunc_paramdesc_wParamFlags = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "elemdescFunc_paramdesc_wParamFlags", "S");
 260         FUNCDESCFc.wFuncFlags = (*env)->GetFieldID(env, FUNCDESCFc.clazz, "wFuncFlags", "S");
 261         FUNCDESCFc.cached = 1;
 262 }
 263
 264 FUNCDESC *getFUNCDESCFields(JNIEnv *env, jobject lpObject, FUNCDESC *lpStruct)
 265 {
 266         if (!FUNCDESCFc.cached) cacheFUNCDESCFields(env, lpObject);
 267         lpStruct->memid = (MEMBERID)(*env)->GetIntField(env, lpObject, FUNCDESCFc.memid);
 268         lpStruct->lprgscode = (SCODE FAR *)(*env)->GetLongField(env, lpObject, FUNCDESCFc.lprgscode);
 269         lpStruct->lprgelemdescParam = (ELEMDESC FAR *)(*env)->GetLongField(env, lpObject, FUNCDESCFc.lprgelemdescParam);
 270         lpStruct->funckind = (FUNCKIND)(*env)->GetIntField(env, lpObject, FUNCDESCFc.funckind);
 271         lpStruct->invkind = (INVOKEKIND)(*env)->GetIntField(env, lpObject, FUNCDESCFc.invkind);
 272         lpStruct->callconv = (CALLCONV)(*env)->GetIntField(env, lpObject, FUNCDESCFc.callconv);
 273         lpStruct->cParams = (*env)->GetShortField(env, lpObject, FUNCDESCFc.cParams);
 274         lpStruct->cParamsOpt = (*env)->GetShortField(env, lpObject, FUNCDESCFc.cParamsOpt);
 275         lpStruct->oVft = (*env)->GetShortField(env, lpObject, FUNCDESCFc.oVft);
 276         lpStruct->cScodes = (*env)->GetShortField(env, lpObject, FUNCDESCFc.cScodes);
 277         lpStruct->elemdescFunc.tdesc.lptdesc = (struct FARSTRUCT tagTYPEDESC FAR* )(*env)->GetLongField(env, lpObject, FUNCDESCFc.elemdescFunc_tdesc_union);
 278         lpStruct->elemdescFunc.tdesc.vt = (*env)->GetShortField(env, lpObject, FUNCDESCFc.elemdescFunc_tdesc_vt);
 279         lpStruct->elemdescFunc.paramdesc.pparamdescex = (LPPARAMDESCEX)(*env)->GetLongField(env, lpObject, FUNCDESCFc.elemdescFunc_paramdesc_pparamdescex);
 280         lpStruct->elemdescFunc.paramdesc.wParamFlags = (*env)->GetShortField(env, lpObject, FUNCDESCFc.elemdescFunc_paramdesc_wParamFlags);
 281         lpStruct->wFuncFlags = (*env)->GetShortField(env, lpObject, FUNCDESCFc.wFuncFlags);
 282         return lpStruct;
 283 }
 284
 285 void setFUNCDESCFields(JNIEnv *env, jobject lpObject, FUNCDESC *lpStruct)
 286 {
 287         if (!FUNCDESCFc.cached) cacheFUNCDESCFields(env, lpObject);
 288         (*env)->SetIntField(env, lpObject, FUNCDESCFc.memid, (jint)lpStruct->memid);
 289         (*env)->SetLongField(env, lpObject, FUNCDESCFc.lprgscode, (jlong)lpStruct->lprgscode);
 290         (*env)->SetLongField(env, lpObject, FUNCDESCFc.lprgelemdescParam, (jlong)lpStruct->lprgelemdescParam);
 291         (*env)->SetIntField(env, lpObject, FUNCDESCFc.funckind, (jint)lpStruct->funckind);
 292         (*env)->SetIntField(env, lpObject, FUNCDESCFc.invkind, (jint)lpStruct->invkind);
 293         (*env)->SetIntField(env, lpObject, FUNCDESCFc.callconv, (jint)lpStruct->callconv);
 294         (*env)->SetShortField(env, lpObject, FUNCDESCFc.cParams, (jshort)lpStruct->cParams);
 295         (*env)->SetShortField(env, lpObject, FUNCDESCFc.cParamsOpt, (jshort)lpStruct->cParamsOpt);
 296         (*env)->SetShortField(env, lpObject, FUNCDESCFc.oVft, (jshort)lpStruct->oVft);
 297         (*env)->SetShortField(env, lpObject, FUNCDESCFc.cScodes, (jshort)lpStruct->cScodes);
 298         (*env)->SetLongField(env, lpObject, FUNCDESCFc.elemdescFunc_tdesc_union, (jlong)lpStruct->elemdescFunc.tdesc.lptdesc);
 299         (*env)->SetShortField(env, lpObject, FUNCDESCFc.elemdescFunc_tdesc_vt, (jshort)lpStruct->elemdescFunc.tdesc.vt);
 300         (*env)->SetLongField(env, lpObject, FUNCDESCFc.elemdescFunc_paramdesc_pparamdescex, (jlong)lpStruct->elemdescFunc.paramdesc.pparamdescex);
 301         (*env)->SetShortField(env, lpObject, FUNCDESCFc.elemdescFunc_paramdesc_wParamFlags, (jshort)lpStruct->elemdescFunc.paramdesc.wParamFlags);
 302         (*env)->SetShortField(env, lpObject, FUNCDESCFc.wFuncFlags, (jshort)lpStruct->wFuncFlags);
 303 }
 304 #endif
 305
 306 #ifndef NO_GUID
 307 typedef struct GUID_FID_CACHE {
 308         int cached;
 309         jclass clazz;
 310         jfieldID Data1, Data2, Data3, Data4;
 311 } GUID_FID_CACHE;
 312
 313 GUID_FID_CACHE GUIDFc;
 314
 315 void cacheGUIDFields(JNIEnv *env, jobject lpObject)
 316 {
 317         if (GUIDFc.cached) return;
 318         GUIDFc.clazz = (*env)->GetObjectClass(env, lpObject);
 319         GUIDFc.Data1 = (*env)->GetFieldID(env, GUIDFc.clazz, "Data1", "I");
 320         GUIDFc.Data2 = (*env)->GetFieldID(env, GUIDFc.clazz, "Data2", "S");
 321         GUIDFc.Data3 = (*env)->GetFieldID(env, GUIDFc.clazz, "Data3", "S");
 322         GUIDFc.Data4 = (*env)->GetFieldID(env, GUIDFc.clazz, "Data4", "[B");
 323         GUIDFc.cached = 1;
 324 }
 325
 326 GUID *getGUIDFields(JNIEnv *env, jobject lpObject, GUID *lpStruct)
 327 {
 328         if (!GUIDFc.cached) cacheGUIDFields(env, lpObject);
 329         lpStruct->Data1 = (*env)->GetIntField(env, lpObject, GUIDFc.Data1);
 330         lpStruct->Data2 = (*env)->GetShortField(env, lpObject, GUIDFc.Data2);
 331         lpStruct->Data3 = (*env)->GetShortField(env, lpObject, GUIDFc.Data3);
 332         {
 333         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, GUIDFc.Data4);
 334         (*env)->GetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->Data4), (jbyte *)lpStruct->Data4);
 335         }
 336         return lpStruct;
 337 }
 338
 339 void setGUIDFields(JNIEnv *env, jobject lpObject, GUID *lpStruct)
 340 {
 341         if (!GUIDFc.cached) cacheGUIDFields(env, lpObject);
 342         (*env)->SetIntField(env, lpObject, GUIDFc.Data1, (jint)lpStruct->Data1);
 343         (*env)->SetShortField(env, lpObject, GUIDFc.Data2, (jshort)lpStruct->Data2);
 344         (*env)->SetShortField(env, lpObject, GUIDFc.Data3, (jshort)lpStruct->Data3);
 345         {
 346         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, GUIDFc.Data4);
 347         (*env)->SetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->Data4), (jbyte *)lpStruct->Data4);
 348         }
 349 }
 350 #endif
 351
 352 #ifndef NO_LICINFO
 353 typedef struct LICINFO_FID_CACHE {
 354         int cached;
 355         jclass clazz;
 356         jfieldID cbLicInfo, fRuntimeKeyAvail, fLicVerified;
 357 } LICINFO_FID_CACHE;
 358
 359 LICINFO_FID_CACHE LICINFOFc;
 360
 361 void cacheLICINFOFields(JNIEnv *env, jobject lpObject)
 362 {
 363         if (LICINFOFc.cached) return;
 364         LICINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
 365         LICINFOFc.cbLicInfo = (*env)->GetFieldID(env, LICINFOFc.clazz, "cbLicInfo", "I");
 366         LICINFOFc.fRuntimeKeyAvail = (*env)->GetFieldID(env, LICINFOFc.clazz, "fRuntimeKeyAvail", "Z");
 367         LICINFOFc.fLicVerified = (*env)->GetFieldID(env, LICINFOFc.clazz, "fLicVerified", "Z");
 368         LICINFOFc.cached = 1;
 369 }
 370
 371 LICINFO *getLICINFOFields(JNIEnv *env, jobject lpObject, LICINFO *lpStruct)
 372 {
 373         if (!LICINFOFc.cached) cacheLICINFOFields(env, lpObject);
 374         lpStruct->cbLicInfo = (*env)->GetIntField(env, lpObject, LICINFOFc.cbLicInfo);
 375         lpStruct->fRuntimeKeyAvail = (*env)->GetBooleanField(env, lpObject, LICINFOFc.fRuntimeKeyAvail);
 376         lpStruct->fLicVerified = (*env)->GetBooleanField(env, lpObject, LICINFOFc.fLicVerified);
 377         return lpStruct;
 378 }
 379
 380 void setLICINFOFields(JNIEnv *env, jobject lpObject, LICINFO *lpStruct)
 381 {
 382         if (!LICINFOFc.cached) cacheLICINFOFields(env, lpObject);
 383         (*env)->SetIntField(env, lpObject, LICINFOFc.cbLicInfo, (jint)lpStruct->cbLicInfo);
 384         (*env)->SetBooleanField(env, lpObject, LICINFOFc.fRuntimeKeyAvail, (jboolean)lpStruct->fRuntimeKeyAvail);
 385         (*env)->SetBooleanField(env, lpObject, LICINFOFc.fLicVerified, (jboolean)lpStruct->fLicVerified);
 386 }
 387 #endif
 388
 389 #ifndef NO_OLECMD
 390 typedef struct OLECMD_FID_CACHE {
 391         int cached;
 392         jclass clazz;
 393         jfieldID cmdID, cmdf;
 394 } OLECMD_FID_CACHE;
 395
 396 OLECMD_FID_CACHE OLECMDFc;
 397
 398 void cacheOLECMDFields(JNIEnv *env, jobject lpObject)
 399 {
 400         if (OLECMDFc.cached) return;
 401         OLECMDFc.clazz = (*env)->GetObjectClass(env, lpObject);
 402         OLECMDFc.cmdID = (*env)->GetFieldID(env, OLECMDFc.clazz, "cmdID", "I");
 403         OLECMDFc.cmdf = (*env)->GetFieldID(env, OLECMDFc.clazz, "cmdf", "I");
 404         OLECMDFc.cached = 1;
 405 }
 406
 407 OLECMD *getOLECMDFields(JNIEnv *env, jobject lpObject, OLECMD *lpStruct)
 408 {
 409         if (!OLECMDFc.cached) cacheOLECMDFields(env, lpObject);
 410         lpStruct->cmdID = (*env)->GetIntField(env, lpObject, OLECMDFc.cmdID);
 411         lpStruct->cmdf = (*env)->GetIntField(env, lpObject, OLECMDFc.cmdf);
 412         return lpStruct;
 413 }
 414
 415 void setOLECMDFields(JNIEnv *env, jobject lpObject, OLECMD *lpStruct)
 416 {
 417         if (!OLECMDFc.cached) cacheOLECMDFields(env, lpObject);
 418         (*env)->SetIntField(env, lpObject, OLECMDFc.cmdID, (jint)lpStruct->cmdID);
 419         (*env)->SetIntField(env, lpObject, OLECMDFc.cmdf, (jint)lpStruct->cmdf);
 420 }
 421 #endif
 422
 423 #ifndef NO_OLEINPLACEFRAMEINFO
 424 typedef struct OLEINPLACEFRAMEINFO_FID_CACHE {
 425         int cached;
 426         jclass clazz;
 427         jfieldID cb, fMDIApp, hwndFrame, haccel, cAccelEntries;
 428 } OLEINPLACEFRAMEINFO_FID_CACHE;
 429
 430 OLEINPLACEFRAMEINFO_FID_CACHE OLEINPLACEFRAMEINFOFc;
 431
 432 void cacheOLEINPLACEFRAMEINFOFields(JNIEnv *env, jobject lpObject)
 433 {
 434         if (OLEINPLACEFRAMEINFOFc.cached) return;
 435         OLEINPLACEFRAMEINFOFc.clazz = (*env)->GetObjectClass(env, lpObject);
 436         OLEINPLACEFRAMEINFOFc.cb = (*env)->GetFieldID(env, OLEINPLACEFRAMEINFOFc.clazz, "cb", "I");
 437         OLEINPLACEFRAMEINFOFc.fMDIApp = (*env)->GetFieldID(env, OLEINPLACEFRAMEINFOFc.clazz, "fMDIApp", "I");
 438         OLEINPLACEFRAMEINFOFc.hwndFrame = (*env)->GetFieldID(env, OLEINPLACEFRAMEINFOFc.clazz, "hwndFrame", "J");
 439         OLEINPLACEFRAMEINFOFc.haccel = (*env)->GetFieldID(env, OLEINPLACEFRAMEINFOFc.clazz, "haccel", "J");
 440         OLEINPLACEFRAMEINFOFc.cAccelEntries = (*env)->GetFieldID(env, OLEINPLACEFRAMEINFOFc.clazz, "cAccelEntries", "I");
 441         OLEINPLACEFRAMEINFOFc.cached = 1;
 442 }
 443
 444 OLEINPLACEFRAMEINFO *getOLEINPLACEFRAMEINFOFields(JNIEnv *env, jobject lpObject, OLEINPLACEFRAMEINFO *lpStruct)
 445 {
 446         if (!OLEINPLACEFRAMEINFOFc.cached) cacheOLEINPLACEFRAMEINFOFields(env, lpObject);
 447         lpStruct->cb = (*env)->GetIntField(env, lpObject, OLEINPLACEFRAMEINFOFc.cb);
 448         lpStruct->fMDIApp = (*env)->GetIntField(env, lpObject, OLEINPLACEFRAMEINFOFc.fMDIApp);
 449         lpStruct->hwndFrame = (HWND)(*env)->GetLongField(env, lpObject, OLEINPLACEFRAMEINFOFc.hwndFrame);
 450         lpStruct->haccel = (HACCEL)(*env)->GetLongField(env, lpObject, OLEINPLACEFRAMEINFOFc.haccel);
 451         lpStruct->cAccelEntries = (*env)->GetIntField(env, lpObject, OLEINPLACEFRAMEINFOFc.cAccelEntries);
 452         return lpStruct;
 453 }
 454
 455 void setOLEINPLACEFRAMEINFOFields(JNIEnv *env, jobject lpObject, OLEINPLACEFRAMEINFO *lpStruct)
 456 {
 457         if (!OLEINPLACEFRAMEINFOFc.cached) cacheOLEINPLACEFRAMEINFOFields(env, lpObject);
 458         (*env)->SetIntField(env, lpObject, OLEINPLACEFRAMEINFOFc.cb, (jint)lpStruct->cb);
 459         (*env)->SetIntField(env, lpObject, OLEINPLACEFRAMEINFOFc.fMDIApp, (jint)lpStruct->fMDIApp);
 460         (*env)->SetLongField(env, lpObject, OLEINPLACEFRAMEINFOFc.hwndFrame, (jlong)lpStruct->hwndFrame);
 461         (*env)->SetLongField(env, lpObject, OLEINPLACEFRAMEINFOFc.haccel, (jlong)lpStruct->haccel);
 462         (*env)->SetIntField(env, lpObject, OLEINPLACEFRAMEINFOFc.cAccelEntries, (jint)lpStruct->cAccelEntries);
 463 }
 464 #endif
 465
 466 #ifndef NO_STGMEDIUM
 467 typedef struct STGMEDIUM_FID_CACHE {
 468         int cached;
 469         jclass clazz;
 470         jfieldID tymed, unionField, pUnkForRelease;
 471 } STGMEDIUM_FID_CACHE;
 472
 473 STGMEDIUM_FID_CACHE STGMEDIUMFc;
 474
 475 void cacheSTGMEDIUMFields(JNIEnv *env, jobject lpObject)
 476 {
 477         if (STGMEDIUMFc.cached) return;
 478         STGMEDIUMFc.clazz = (*env)->GetObjectClass(env, lpObject);
 479         STGMEDIUMFc.tymed = (*env)->GetFieldID(env, STGMEDIUMFc.clazz, "tymed", "I");
 480         STGMEDIUMFc.unionField = (*env)->GetFieldID(env, STGMEDIUMFc.clazz, "unionField", "J");
 481         STGMEDIUMFc.pUnkForRelease = (*env)->GetFieldID(env, STGMEDIUMFc.clazz, "pUnkForRelease", "J");
 482         STGMEDIUMFc.cached = 1;
 483 }
 484
 485 STGMEDIUM *getSTGMEDIUMFields(JNIEnv *env, jobject lpObject, STGMEDIUM *lpStruct)
 486 {
 487         if (!STGMEDIUMFc.cached) cacheSTGMEDIUMFields(env, lpObject);
 488         lpStruct->tymed = (*env)->GetIntField(env, lpObject, STGMEDIUMFc.tymed);
 489         lpStruct->hGlobal = (HGLOBAL)(*env)->GetLongField(env, lpObject, STGMEDIUMFc.unionField);
 490         lpStruct->pUnkForRelease = (IUnknown *)(*env)->GetLongField(env, lpObject, STGMEDIUMFc.pUnkForRelease);
 491         return lpStruct;
 492 }
 493
 494 void setSTGMEDIUMFields(JNIEnv *env, jobject lpObject, STGMEDIUM *lpStruct)
 495 {
 496         if (!STGMEDIUMFc.cached) cacheSTGMEDIUMFields(env, lpObject);
 497         (*env)->SetIntField(env, lpObject, STGMEDIUMFc.tymed, (jint)lpStruct->tymed);
 498         (*env)->SetLongField(env, lpObject, STGMEDIUMFc.unionField, (jlong)lpStruct->hGlobal);
 499         (*env)->SetLongField(env, lpObject, STGMEDIUMFc.pUnkForRelease, (jlong)lpStruct->pUnkForRelease);
 500 }
 501 #endif
 502
 503 #ifndef NO_TYPEATTR
 504 typedef struct TYPEATTR_FID_CACHE {
 505         int cached;
 506         jclass clazz;
 507         jfieldID guid_Data1, guid_Data2, guid_Data3, guid_Data4, lcid, dwReserved, memidConstructor, memidDestructor, lpstrSchema, cbSizeInstance, typekind, cFuncs, cVars, cImplTypes, cbSizeVft, cbAlignment, wTypeFlags, wMajorVerNum, wMinorVerNum, tdescAlias_unionField, tdescAlias_vt, idldescType_dwReserved, idldescType_wIDLFlags;
 508 } TYPEATTR_FID_CACHE;
 509
 510 TYPEATTR_FID_CACHE TYPEATTRFc;
 511
 512 void cacheTYPEATTRFields(JNIEnv *env, jobject lpObject)
 513 {
 514         if (TYPEATTRFc.cached) return;
 515         TYPEATTRFc.clazz = (*env)->GetObjectClass(env, lpObject);
 516         TYPEATTRFc.guid_Data1 = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "guid_Data1", "I");
 517         TYPEATTRFc.guid_Data2 = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "guid_Data2", "S");
 518         TYPEATTRFc.guid_Data3 = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "guid_Data3", "S");
 519         TYPEATTRFc.guid_Data4 = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "guid_Data4", "[B");
 520         TYPEATTRFc.lcid = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "lcid", "I");
 521         TYPEATTRFc.dwReserved = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "dwReserved", "I");
 522         TYPEATTRFc.memidConstructor = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "memidConstructor", "I");
 523         TYPEATTRFc.memidDestructor = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "memidDestructor", "I");
 524         TYPEATTRFc.lpstrSchema = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "lpstrSchema", "J");
 525         TYPEATTRFc.cbSizeInstance = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "cbSizeInstance", "I");
 526         TYPEATTRFc.typekind = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "typekind", "I");
 527         TYPEATTRFc.cFuncs = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "cFuncs", "S");
 528         TYPEATTRFc.cVars = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "cVars", "S");
 529         TYPEATTRFc.cImplTypes = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "cImplTypes", "S");
 530         TYPEATTRFc.cbSizeVft = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "cbSizeVft", "S");
 531         TYPEATTRFc.cbAlignment = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "cbAlignment", "S");
 532         TYPEATTRFc.wTypeFlags = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "wTypeFlags", "S");
 533         TYPEATTRFc.wMajorVerNum = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "wMajorVerNum", "S");
 534         TYPEATTRFc.wMinorVerNum = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "wMinorVerNum", "S");
 535         TYPEATTRFc.tdescAlias_unionField = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "tdescAlias_unionField", "J");
 536         TYPEATTRFc.tdescAlias_vt = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "tdescAlias_vt", "S");
 537         TYPEATTRFc.idldescType_dwReserved = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "idldescType_dwReserved", "I");
 538         TYPEATTRFc.idldescType_wIDLFlags = (*env)->GetFieldID(env, TYPEATTRFc.clazz, "idldescType_wIDLFlags", "S");
 539         TYPEATTRFc.cached = 1;
 540 }
 541
 542 TYPEATTR *getTYPEATTRFields(JNIEnv *env, jobject lpObject, TYPEATTR *lpStruct)
 543 {
 544         if (!TYPEATTRFc.cached) cacheTYPEATTRFields(env, lpObject);
 545         lpStruct->guid.Data1 = (*env)->GetIntField(env, lpObject, TYPEATTRFc.guid_Data1);
 546         lpStruct->guid.Data2 = (*env)->GetShortField(env, lpObject, TYPEATTRFc.guid_Data2);
 547         lpStruct->guid.Data3 = (*env)->GetShortField(env, lpObject, TYPEATTRFc.guid_Data3);
 548         {
 549         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, TYPEATTRFc.guid_Data4);
 550         (*env)->GetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->guid.Data4), (jbyte *)lpStruct->guid.Data4);
 551         }
 552         lpStruct->lcid = (*env)->GetIntField(env, lpObject, TYPEATTRFc.lcid);
 553         lpStruct->dwReserved = (*env)->GetIntField(env, lpObject, TYPEATTRFc.dwReserved);
 554         lpStruct->memidConstructor = (*env)->GetIntField(env, lpObject, TYPEATTRFc.memidConstructor);
 555         lpStruct->memidDestructor = (*env)->GetIntField(env, lpObject, TYPEATTRFc.memidDestructor);
 556         lpStruct->lpstrSchema = (OLECHAR FAR *)(*env)->GetLongField(env, lpObject, TYPEATTRFc.lpstrSchema);
 557         lpStruct->cbSizeInstance = (*env)->GetIntField(env, lpObject, TYPEATTRFc.cbSizeInstance);
 558         lpStruct->typekind = (*env)->GetIntField(env, lpObject, TYPEATTRFc.typekind);
 559         lpStruct->cFuncs = (*env)->GetShortField(env, lpObject, TYPEATTRFc.cFuncs);
 560         lpStruct->cVars = (*env)->GetShortField(env, lpObject, TYPEATTRFc.cVars);
 561         lpStruct->cImplTypes = (*env)->GetShortField(env, lpObject, TYPEATTRFc.cImplTypes);
 562         lpStruct->cbSizeVft = (*env)->GetShortField(env, lpObject, TYPEATTRFc.cbSizeVft);
 563         lpStruct->cbAlignment = (*env)->GetShortField(env, lpObject, TYPEATTRFc.cbAlignment);
 564         lpStruct->wTypeFlags = (*env)->GetShortField(env, lpObject, TYPEATTRFc.wTypeFlags);
 565         lpStruct->wMajorVerNum = (*env)->GetShortField(env, lpObject, TYPEATTRFc.wMajorVerNum);
 566         lpStruct->wMinorVerNum = (*env)->GetShortField(env, lpObject, TYPEATTRFc.wMinorVerNum);
 567         lpStruct->tdescAlias.lptdesc = (struct FARSTRUCT tagTYPEDESC FAR *)(*env)->GetLongField(env, lpObject, TYPEATTRFc.tdescAlias_unionField);
 568         lpStruct->tdescAlias.vt = (*env)->GetShortField(env, lpObject, TYPEATTRFc.tdescAlias_vt);
 569         lpStruct->idldescType.dwReserved = (*env)->GetIntField(env, lpObject, TYPEATTRFc.idldescType_dwReserved);
 570         lpStruct->idldescType.wIDLFlags = (*env)->GetShortField(env, lpObject, TYPEATTRFc.idldescType_wIDLFlags);
 571         return lpStruct;
 572 }
 573
 574 void setTYPEATTRFields(JNIEnv *env, jobject lpObject, TYPEATTR *lpStruct)
 575 {
 576         if (!TYPEATTRFc.cached) cacheTYPEATTRFields(env, lpObject);
 577         (*env)->SetIntField(env, lpObject, TYPEATTRFc.guid_Data1, (jint)lpStruct->guid.Data1);
 578         (*env)->SetShortField(env, lpObject, TYPEATTRFc.guid_Data2, (jshort)lpStruct->guid.Data2);
 579         (*env)->SetShortField(env, lpObject, TYPEATTRFc.guid_Data3, (jshort)lpStruct->guid.Data3);
 580         {
 581         jbyteArray lpObject1 = (jbyteArray)(*env)->GetObjectField(env, lpObject, TYPEATTRFc.guid_Data4);
 582         (*env)->SetByteArrayRegion(env, lpObject1, 0, sizeof(lpStruct->guid.Data4), (jbyte *)lpStruct->guid.Data4);
 583         }
 584         (*env)->SetIntField(env, lpObject, TYPEATTRFc.lcid, (jint)lpStruct->lcid);
 585         (*env)->SetIntField(env, lpObject, TYPEATTRFc.dwReserved, (jint)lpStruct->dwReserved);
 586         (*env)->SetIntField(env, lpObject, TYPEATTRFc.memidConstructor, (jint)lpStruct->memidConstructor);
 587         (*env)->SetIntField(env, lpObject, TYPEATTRFc.memidDestructor, (jint)lpStruct->memidDestructor);
 588         (*env)->SetLongField(env, lpObject, TYPEATTRFc.lpstrSchema, (jlong)lpStruct->lpstrSchema);
 589         (*env)->SetIntField(env, lpObject, TYPEATTRFc.cbSizeInstance, (jint)lpStruct->cbSizeInstance);
 590         (*env)->SetIntField(env, lpObject, TYPEATTRFc.typekind, (jint)lpStruct->typekind);
 591         (*env)->SetShortField(env, lpObject, TYPEATTRFc.cFuncs, (jshort)lpStruct->cFuncs);
 592         (*env)->SetShortField(env, lpObject, TYPEATTRFc.cVars, (jshort)lpStruct->cVars);
 593         (*env)->SetShortField(env, lpObject, TYPEATTRFc.cImplTypes, (jshort)lpStruct->cImplTypes);
 594         (*env)->SetShortField(env, lpObject, TYPEATTRFc.cbSizeVft, (jshort)lpStruct->cbSizeVft);
 595         (*env)->SetShortField(env, lpObject, TYPEATTRFc.cbAlignment, (jshort)lpStruct->cbAlignment);
 596         (*env)->SetShortField(env, lpObject, TYPEATTRFc.wTypeFlags, (jshort)lpStruct->wTypeFlags);
 597         (*env)->SetShortField(env, lpObject, TYPEATTRFc.wMajorVerNum, (jshort)lpStruct->wMajorVerNum);
 598         (*env)->SetShortField(env, lpObject, TYPEATTRFc.wMinorVerNum, (jshort)lpStruct->wMinorVerNum);
 599         (*env)->SetLongField(env, lpObject, TYPEATTRFc.tdescAlias_unionField, (jlong)lpStruct->tdescAlias.lptdesc);
 600         (*env)->SetShortField(env, lpObject, TYPEATTRFc.tdescAlias_vt, (jshort)lpStruct->tdescAlias.vt);
 601         (*env)->SetIntField(env, lpObject, TYPEATTRFc.idldescType_dwReserved, (jint)lpStruct->idldescType.dwReserved);
 602         (*env)->SetShortField(env, lpObject, TYPEATTRFc.idldescType_wIDLFlags, (jshort)lpStruct->idldescType.wIDLFlags);
 603 }
 604 #endif
 605
 606 #ifndef NO_VARDESC
 607 typedef struct VARDESC_FID_CACHE {
 608         int cached;
 609         jclass clazz;
 610         jfieldID memid, lpstrSchema, oInst, elemdescVar_tdesc_union, elemdescVar_tdesc_vt, elemdescVar_paramdesc_pparamdescex, elemdescVar_paramdesc_wParamFlags, wVarFlags, varkind;
 611 } VARDESC_FID_CACHE;
 612
 613 VARDESC_FID_CACHE VARDESCFc;
 614
 615 void cacheVARDESCFields(JNIEnv *env, jobject lpObject)
 616 {
 617         if (VARDESCFc.cached) return;
 618         VARDESCFc.clazz = (*env)->GetObjectClass(env, lpObject);
 619         VARDESCFc.memid = (*env)->GetFieldID(env, VARDESCFc.clazz, "memid", "I");
 620         VARDESCFc.lpstrSchema = (*env)->GetFieldID(env, VARDESCFc.clazz, "lpstrSchema", "J");
 621         VARDESCFc.oInst = (*env)->GetFieldID(env, VARDESCFc.clazz, "oInst", "I");
 622         VARDESCFc.elemdescVar_tdesc_union = (*env)->GetFieldID(env, VARDESCFc.clazz, "elemdescVar_tdesc_union", "J");
 623         VARDESCFc.elemdescVar_tdesc_vt = (*env)->GetFieldID(env, VARDESCFc.clazz, "elemdescVar_tdesc_vt", "S");
 624         VARDESCFc.elemdescVar_paramdesc_pparamdescex = (*env)->GetFieldID(env, VARDESCFc.clazz, "elemdescVar_paramdesc_pparamdescex", "J");
 625         VARDESCFc.elemdescVar_paramdesc_wParamFlags = (*env)->GetFieldID(env, VARDESCFc.clazz, "elemdescVar_paramdesc_wParamFlags", "S");
 626         VARDESCFc.wVarFlags = (*env)->GetFieldID(env, VARDESCFc.clazz, "wVarFlags", "S");
 627         VARDESCFc.varkind = (*env)->GetFieldID(env, VARDESCFc.clazz, "varkind", "I");
 628         VARDESCFc.cached = 1;
 629 }
 630
 631 VARDESC *getVARDESCFields(JNIEnv *env, jobject lpObject, VARDESC *lpStruct)
 632 {
 633         if (!VARDESCFc.cached) cacheVARDESCFields(env, lpObject);
 634         lpStruct->memid = (*env)->GetIntField(env, lpObject, VARDESCFc.memid);
 635         lpStruct->lpstrSchema = (OLECHAR FAR *)(*env)->GetLongField(env, lpObject, VARDESCFc.lpstrSchema);
 636         lpStruct->oInst = (*env)->GetIntField(env, lpObject, VARDESCFc.oInst);
 637         lpStruct->elemdescVar.tdesc.lptdesc = (struct FARSTRUCT tagTYPEDESC FAR *)(*env)->GetLongField(env, lpObject, VARDESCFc.elemdescVar_tdesc_union);
 638         lpStruct->elemdescVar.tdesc.vt = (*env)->GetShortField(env, lpObject, VARDESCFc.elemdescVar_tdesc_vt);
 639         lpStruct->elemdescVar.paramdesc.pparamdescex = (LPPARAMDESCEX)(*env)->GetLongField(env, lpObject, VARDESCFc.elemdescVar_paramdesc_pparamdescex);
 640         lpStruct->elemdescVar.paramdesc.wParamFlags = (*env)->GetShortField(env, lpObject, VARDESCFc.elemdescVar_paramdesc_wParamFlags);
 641         lpStruct->wVarFlags = (*env)->GetShortField(env, lpObject, VARDESCFc.wVarFlags);
 642         lpStruct->varkind = (*env)->GetIntField(env, lpObject, VARDESCFc.varkind);
 643         return lpStruct;
 644 }
 645
 646 void setVARDESCFields(JNIEnv *env, jobject lpObject, VARDESC *lpStruct)
 647 {
 648         if (!VARDESCFc.cached) cacheVARDESCFields(env, lpObject);
 649         (*env)->SetIntField(env, lpObject, VARDESCFc.memid, (jint)lpStruct->memid);
 650         (*env)->SetLongField(env, lpObject, VARDESCFc.lpstrSchema, (jlong)lpStruct->lpstrSchema);
 651         (*env)->SetIntField(env, lpObject, VARDESCFc.oInst, (jint)lpStruct->oInst);
 652         (*env)->SetLongField(env, lpObject, VARDESCFc.elemdescVar_tdesc_union, (jlong)lpStruct->elemdescVar.tdesc.lptdesc);
 653         (*env)->SetShortField(env, lpObject, VARDESCFc.elemdescVar_tdesc_vt, (jshort)lpStruct->elemdescVar.tdesc.vt);
 654         (*env)->SetLongField(env, lpObject, VARDESCFc.elemdescVar_paramdesc_pparamdescex, (jlong)lpStruct->elemdescVar.paramdesc.pparamdescex);
 655         (*env)->SetShortField(env, lpObject, VARDESCFc.elemdescVar_paramdesc_wParamFlags, (jshort)lpStruct->elemdescVar.paramdesc.wParamFlags);
 656         (*env)->SetShortField(env, lpObject, VARDESCFc.wVarFlags, (jshort)lpStruct->wVarFlags);
 657         (*env)->SetIntField(env, lpObject, VARDESCFc.varkind, (jint)lpStruct->varkind);
 658 }
 659 #endif
 660
 661 #ifndef NO_VARIANT
 662 typedef struct VARIANT_FID_CACHE {
 663         int cached;
 664         jclass clazz;
 665         jfieldID vt, wReserved1, wReserved2, wReserved3, lVal;
 666 } VARIANT_FID_CACHE;
 667
 668 VARIANT_FID_CACHE VARIANTFc;
 669
 670 void cacheVARIANTFields(JNIEnv *env, jobject lpObject)
 671 {
 672         if (VARIANTFc.cached) return;
 673         VARIANTFc.clazz = (*env)->GetObjectClass(env, lpObject);
 674         VARIANTFc.vt = (*env)->GetFieldID(env, VARIANTFc.clazz, "vt", "S");
 675         VARIANTFc.wReserved1 = (*env)->GetFieldID(env, VARIANTFc.clazz, "wReserved1", "S");
 676         VARIANTFc.wReserved2 = (*env)->GetFieldID(env, VARIANTFc.clazz, "wReserved2", "S");
 677         VARIANTFc.wReserved3 = (*env)->GetFieldID(env, VARIANTFc.clazz, "wReserved3", "S");
 678         VARIANTFc.lVal = (*env)->GetFieldID(env, VARIANTFc.clazz, "lVal", "I");
 679         VARIANTFc.cached = 1;
 680 }
 681
 682 VARIANT *getVARIANTFields(JNIEnv *env, jobject lpObject, VARIANT *lpStruct)
 683 {
 684         if (!VARIANTFc.cached) cacheVARIANTFields(env, lpObject);
 685         lpStruct->vt = (*env)->GetShortField(env, lpObject, VARIANTFc.vt);
 686         lpStruct->wReserved1 = (*env)->GetShortField(env, lpObject, VARIANTFc.wReserved1);
 687         lpStruct->wReserved2 = (*env)->GetShortField(env, lpObject, VARIANTFc.wReserved2);
 688         lpStruct->wReserved3 = (*env)->GetShortField(env, lpObject, VARIANTFc.wReserved3);
 689         lpStruct->lVal = (*env)->GetIntField(env, lpObject, VARIANTFc.lVal);
 690         return lpStruct;
 691 }
 692
 693 void setVARIANTFields(JNIEnv *env, jobject lpObject, VARIANT *lpStruct)
 694 {
 695         if (!VARIANTFc.cached) cacheVARIANTFields(env, lpObject);
 696         (*env)->SetShortField(env, lpObject, VARIANTFc.vt, (jshort)lpStruct->vt);
 697         (*env)->SetShortField(env, lpObject, VARIANTFc.wReserved1, (jshort)lpStruct->wReserved1);
 698         (*env)->SetShortField(env, lpObject, VARIANTFc.wReserved2, (jshort)lpStruct->wReserved2);
 699         (*env)->SetShortField(env, lpObject, VARIANTFc.wReserved3, (jshort)lpStruct->wReserved3);
 700         (*env)->SetIntField(env, lpObject, VARIANTFc.lVal, (jint)lpStruct->lVal);
 701 }
 702 #endif
 703