typeparser.java

java 调用windows的api

	private void buildUserDefinedDescription(
		ITypeInfo iTypeInfo,
		PropertyNode node,
		TYPEDESC typeDesc,
		TypeConversionConfig config) 
	{
		ITypeInfo[] userDefinedType = new ITypeInfo[1];
		int err = iTypeInfo.getRefTypeInfo(typeDesc.hreftype, userDefinedType);
		if (HRESULT.FAILED(err)) {
			throw new RuntimeException("Unable to retrieve reference type information for '" + getDocName(iTypeInfo) + new COMException(err).toString());
		}
		
		TYPEATTR[] type_attr = new TYPEATTR[1];
		err = userDefinedType[0].getTypeAttr(type_attr);
		if (HRESULT.FAILED(err)) {
			throw new RuntimeException(new COMException(err).toString());
		}
		switch (type_attr[0].typekind) {
			case TYPEKIND.TKIND_ENUM:
			node.setTypeConfig(
				TypeConversionManager.getInstance().getConfig(VarTypes.VT_INT));
			break;
			
			case TYPEKIND.TKIND_RECORD:
			case TYPEKIND.TKIND_DISPATCH:
			case TYPEKIND.TKIND_INTERFACE:
			case TYPEKIND.TKIND_COCLASS:
				// hack to set the typeName on the PropertyNode in the case with a VT_PTR with a VT_POINTER in it.
				if ((node instanceof PointerNode) && (node.getParent() instanceof PropertyNode)) {
					((PropertyNode)node.getParent()).setTypeName(getDocName(userDefinedType[0]));
				} else {
					node.setTypeName(getDocName(userDefinedType[0]));
				}
			break;
			
			case TYPEKIND.TKIND_ALIAS:
			// recurse
			buildTypeDescription(
				userDefinedType[0],
				node,
				type_attr[0].tdescAlias,
				config,
				true);
			break;
			
			default:
			System.out.println(
				"Unhandled userdefined type: "
					+ getDocName(userDefinedType[0]));
			break;
		}
	}
	private String getDocName(ITypeInfo type_info) {
		String[] out_name = new String[1];
		String[] out_doc_string = new String[1];
		String[] out_help_file = new String[1];
		int[] out_help_context = new int[1];
		int err =
			type_info.getDocumentation(
				-1,
				out_name,
				out_doc_string,
				out_help_context,
				out_help_file);
		if (HRESULT.FAILED(err)) {
			throw new RuntimeException(new COMException(err).toString());
		}
		return out_name[0];
	}

	private void buildIDLDesc(ITypeInfo iTypeInfo, PropertyNode node, IDLDESC idlDesc, TypeConversionConfig config)
	{
		IDLNode idlNode = new IDLNode();

		switch (idlDesc.wIDLFlags)
		{
			case IDLDESC.IDLFLAG_NONE:   // Whether the parameter passes or receives information is unspecified.
				idlNode.setName("NONE");
				break;
			case IDLDESC.IDLFLAG_FIN:    // Parameter passes information from the caller to the callee.
				idlNode.setName("IN");
				break;
			case IDLDESC.IDLFLAG_FOUT:   // Parameter returns information from the callee to the caller.
				idlNode.setName("OUT");
				break;
			case IDLDESC.IDLFLAG_FLCID:  // Parameter is the local identifier of a client application.
				idlNode.setName("LCID");
				break;
			case IDLDESC.IDLFLAG_FRETVAL:
				idlNode.setName("RETVAL");
				break;
		}

		node.addChild(idlNode);
	}

	/**
	 * Build a description of the function parameter
	 * @param iTypeInfo
	 * @param node
	 * @param paramDesc
	 * @param config
	 */
	private void buildPARAMDesc(ITypeInfo iTypeInfo, PropertyNode node, PARAMDESC paramDesc,
			TypeConversionConfig config)
	{
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_NONE) == PARAMDESC.PARAMFLAG_NONE)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("NONE");
			node.addChild(modifer);
		}
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_FIN)==PARAMDESC.PARAMFLAG_FIN)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("IN");
			node.addChild(modifer);
		}
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_FOUT)==PARAMDESC.PARAMFLAG_FOUT)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("OUT");
			node.addChild(modifer);
		}
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_FLCID)==PARAMDESC.PARAMFLAG_FLCID)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("LCID");
			node.addChild(modifer);
		}
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_FRETVAL)==PARAMDESC.PARAMFLAG_FRETVAL)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("RETVAL");
			node.addChild(modifer);
		}
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_FOPT)==PARAMDESC.PARAMFLAG_FOPT)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("OPT");
			node.addChild(modifer);
		}
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_FHASDEFAULT)==PARAMDESC.PARAMFLAG_FHASDEFAULT)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("HAS_DEFAULT");
			node.addChild(modifer);
//			Variant variant=paramDesc.pparamdescex[0].varDefaultValue;
//			flagElement.setAttribute("Type", ""+variant.vt);
//			buildVariant(flagElement, variant);
//			element.appendChild(flagElement);
		}
		if((paramDesc.wParamFlags&PARAMDESC.PARAMFLAG_FHASCUSTDATA)==PARAMDESC.PARAMFLAG_FHASCUSTDATA)
		{
			ParameterModifierNode modifer = new ParameterModifierNode("HAS_CUSTDATA");
			node.addChild(modifer);
		}
	}

	/**
	 * Extracts the value of a variant and stores it on the requested PropertyNode
	 *
	 * @param variantNode the node to store the value or another variant on
	 * @param variant the variant to extract info from
	 */
	private void buildVariant(VariantNode variantNode, Variant variant)
	{
		switch(variant.vt)
		{
			case VarTypes.VT_EMPTY:
			{
				break;
			}
			case VarTypes.VT_NULL:
			{
				break;
			}
			case VarTypes.VT_UI1:
			{
				variantNode.setValue(""+variant.bVal);
				break;
			}
			case VarTypes.VT_I2:
			{
				variantNode.setValue(""+variant.iVal);
				break;
			}
			case VarTypes.VT_I4:
			{
				variantNode.setValue(""+variant.lVal);
				break;
			}
			case VarTypes.VT_R4:
			{
				variantNode.setValue(""+variant.fltVal);
				break;
			}
			case VarTypes.VT_R8:
			{
				variantNode.setValue(""+variant.dblVal);
				break;
			}
			case VarTypes.VT_CY:
			{
				variantNode.setValue(""+variant.cyVal);
				break;
			}
			case VarTypes.VT_DATE:
			{
				variantNode.setValue(""+variant.date);
				break;
			}
			case VarTypes.VT_BSTR:
			{
				variantNode.setValue(""+variant.bstrVal);
				break;
			}
			case VarTypes.VT_DISPATCH:
			{
				break;
			}
			case VarTypes.VT_ERROR:
			{
				break;
			}
			case VarTypes.VT_BOOL:
			{
				variantNode.setValue(""+variant.boolVal);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_VARIANT):
			{
				VariantNode childVariant = new VariantNode();
				buildVariant(childVariant, variant.pvarVal[0]);
				variantNode.addChild(childVariant);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_I1):
			{
				variantNode.setValue(""+variant.pbVal[0]);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_I2):
			{
				variantNode.setValue(""+variant.piVal[0]);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_I4):
			{
				variantNode.setValue(""+variant.plVal[0]);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_R4):
			{
				variantNode.setValue(""+variant.pfltVal[0]);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_R8):
			{
				variantNode.setValue(""+variant.pdblVal[0]);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_CY):
			{
				variantNode.setValue(""+variant.pcyVal[0]);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_DATE):
			{
				variantNode.setValue(""+variant.pdate[0]);
				break;
			}
			case VarTypes.VT_UNKNOWN:
			{
				break;
			}
			case VarTypes.VT_DECIMAL:
			{
				break;
			}
			case VarTypes.VT_I1:
			{
				variantNode.setValue(""+variant.cVal);
				break;
			}
			case VarTypes.VT_UI2:
			{
				variantNode.setValue(""+variant.uiVal);
				break;
			}
			case VarTypes.VT_UI4:
			{
				variantNode.setValue(""+variant.ulVal);
				break;
			}
			case VarTypes.VT_I8:
			{
				//fieldID=env->GetFieldID(variant_clazz, "ulVal", "J");
				//env->SetLongField(native_variant, fieldID, (((jlong)variant.cyVal.Hi)>>32+(jlong)variant.cyVal.Lo));
				//clazz=env->FindClass("java/lang/Long");
				//mid = env->GetMethodID(clazz, "<init>","(L)V");
				//variant_obj=env->NewObject(clazz, mid, (((jlong)variant.cyVal.Hi)>>32+(jlong)variant.cyVal.Lo));
				break;
			}
			case VarTypes.VT_UI8:
			{
				//clazz=env->FindClass("java/lang/Long");
				//mid = env->GetMethodID(clazz, "<init>","(L)V");
				//variant_obj=env->NewObject(clazz, mid, (((jlong)variant.cyVal.Hi)>>32+(jlong)variant.cyVal.Lo));
				break;
			}
			case VarTypes.VT_INT:
			{
				variantNode.setValue(""+variant.intVal);
				break;
			}
			case VarTypes.VT_UINT:
			{
				variantNode.setValue(""+variant.uintVal);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_INT):
			{
				variantNode.setValue(""+variant.pintVal[0]);
				break;
			}
			case (VarTypes.VT_BYREF|VarTypes.VT_UINT):
			{
				variantNode.setValue(""+variant.puintVal[0]);
				break;
			}
		/**
			case VT_VOID:
			{
				clazz=env->FindClass("java/lang/Object");
				mid = env->GetMethodID(clazz, "<init>","(V)V");
				variant_obj=env->NewObject(clazz, mid);
				break;
			}
		*/
			case VarTypes.VT_HRESULT:
			{
				break;
			}
			case VarTypes.VT_PTR:
			{
				break;
			}
			case VarTypes.VT_SAFEARRAY:
			{
				break;
			}
			case VarTypes.VT_CARRAY:
			{
				break;
			}
			case VarTypes.VT_USERDEFINED:
			{
				break;
			}
			case VarTypes.VT_LPSTR:
			{
				break;
			}
			case VarTypes.VT_LPWSTR:
			{
				break;
			}
		/**
			case VarTypes.VT_RECORD:
			{
				break;
			}
			case VarTypes.VT_INT_PTR:
			{
				break;
			}
			case VarTypes.VT_UINT_PTR:
			{
				break;
			}
		*/
			case VarTypes.VT_FILETIME:
			{
				break;
			}
			case VarTypes.VT_BLOB:
			{
				break;
			}
			case VarTypes.VT_STREAM:
			{
				break;
			}
			case VarTypes.VT_STORAGE:
			{
				break;
			}
			case VarTypes.VT_STREAMED_OBJECT:
			{
				break;
			}
			case VarTypes.VT_STORED_OBJECT:
			{
				break;
			}
			case VarTypes.VT_BLOB_OBJECT:
			{
				break;
			}
			case VarTypes.VT_CF:
			{
				break;
			}
			case VarTypes.VT_CLSID:
			{
				break;
			}
		/**
			case VarTypes.VT_VERSIONED_STREAM:
			{
					break;
			}
			case VarTypes.VT_BSTR_BLOB:
			{
					break;
			}
		*/
			case VarTypes.VT_VECTOR:
			{
				break;
			}
			case VarTypes.VT_ARRAY:
			{
				break;
			}
			case VarTypes.VT_BYREF:
			{
				break;
			}
			case VarTypes.VT_RESERVED:
			{
				break;
			}
			case VarTypes.VT_ILLEGAL:
			{
				break;
			}
		/**
			case VarTypes.VT_ILLEGALMASKED:
			{
				break;
			}
			case VarTypes.VT_TYPEMASK:
			{
				break;
			}
		*/
			default:
			{
				break;
			}
		}
	}


}