jcomgenerator.java

使用JCom的时候

			out.close();
			return true;
		}catch(Exception e) { e.printStackTrace(); }
		return false;
	}

	//	TYPEATTR.typekind 偑 TKIND_COCLASS 偺儌僲偵懳偟偰惗惉
	public boolean generateCoClass(ITypeInfo info) {
		String packagename = currentPackageName;
		// 僼傽僀儖柤偼 
		try {
			String[] docs = info.getDocumentation(-1);
			// 僼傽僀儖傪僆乕僾儞
			makedirs(packagename);
			String fname = getFilename(packagename, docs[0]);
			PrintWriter out = 
					new PrintWriter(new BufferedWriter(new FileWriter(fname)));
			// 僼傽僀儖僿僢僟傪弌椡
			outHeader(out, packagename);
			// 娭悢僿僢僟傪弌椡
			out.println("/**");
			out.println("\tCoClass "+docs[0]+((docs[1]!=null)?docs[1]:""));
			out.println("\t"+docs[3]+" "+docs[2]);
			ITypeInfo.TypeAttr attr = info.getTypeAttr();
			for(int i=0; i<attr.getImplTypes(); i++) {
				ITypeInfo imp = info.getImplType(i);
				out.println("\t"+imp.getDocumentation(-1)[0]);
			}
			out.println("*/");
			ITypeInfo impl = info.getImplType(0);
			out.println("public class "+docs[0]+" extends "+impl.getDocumentation(-1)[0]+" {");
			// 昗弨偺儊儞僶傪弌椡
			out.println("\t/**");
			out.println("\t\tIDispatch偐傜惗惉丅栠傝抣偐傜惗惉偡傞偲偒偵巊梡");
			out.println("\t*/");
			out.println("\tpublic "+docs[0]+"(IDispatch disp) { super(disp); }");
			out.println();
			out.println("}");
			// 僼傽僀儖傪暵偠傞
			out.close();
			return true;
		}catch(Exception e) { e.printStackTrace(); }
		return false;
	}
	/**
		IDispatch僀儞僞乕僼僃乕僗偱掕媊偝傟偰偄傞娭悢偐偳偆偐傪挷傋傞丅
		扨弮偵娭悢柤偱敾抐偟偰偄傞偩偗丅
	*/
	protected boolean isIDispatchFunction(String funcname) {
		String[] fnames = {
			"QueryInterface",
			"AddRef",
			"Release",
			"GetTypeInfoCount",
			"GetTypeInfo",
			"GetIDsOfNames",
			"Invoke" };
		for(int i=0; i<fnames.length; i++) {
			if(funcname.equals(fnames[i])) return true;
		}
		return false;
	}
	/**
		VARIANT偺宆偐傜Java偺宆偵曄姺
	*/
	protected String getJavaType(String type) {
		if(type.equals("VT_INT")) return "int";				// 悇彠偝傟側偄
		if(type.equals("VT_UI1")) return "byte";
		if(type.equals("VT_I2")) return "short";
		if(type.equals("VT_I4")) return "int";
		if(type.equals("VT_R4")) return "float";
		if(type.equals("VT_R8")) return "double";
		if(type.equals("VT_BSTR")) return "String";
		if(type.equals("VT_VOID")) return "void";			// 悇彠偝傟側偄
		if(type.equals("VT_VARIANT")) return "Object";		// 悇彠偝傟側偄
		if(type.equals("VT_BOOL")) return "boolean";
		if(type.equals("VT_DISPATCH")) return "IDispatch";
		if(type.equals("VT_UNKNOWN")) return "IUnknown";
		if(type.equals("VT_DATE")) return "java.util.Date";
		if(type.equals("VT_PTR+VT_I4")) return "int[]";
		if(type.equals("VT_PTR+VT_R8")) return "double[]";
		if(type.equals("VT_PTR+VT_BOOL")) return "boolean[]";
		if(type.equals("VT_PTR+VT_BSTR")) return "String[]";

		if(type.startsWith("VT_PTR+VT_USERDEFINED")) {
			String clsname = type.substring(type.indexOf(':')+1);
			// 摨偠儔僀僽儔儕撪偐丠
			try {
				int hRefType = ITypeInfo.getRefTypeFromTypeDesc(type);
				ITypeLib reflib = currentInfo.getRefTypeInfo(hRefType).getTypeLib();
				if(reflib.getTLibAttr().equals(currentLib.getTLibAttr())) {
					return clsname;
				}
				// 堘偭偨傜丒丒丒丄僼儖僷僗偱昞帵
				String packagename = getPackageName(packagePath, reflib);
				return packagename+"."+clsname;
			} catch(Exception e) { e.printStackTrace(); }
			return "@@@"+clsname;
		}

		// VT_PTR偺側偄VT_USERDEFINED傪Enum偲尒側偟丄Enum傪int偲傒側偡丅偪傚偭偲棎朶偐傕丠
		if(type.startsWith("VT_USERDEFINED")) return "int";
		return "@@@"+type;
	}
	/**
		懠偺儔僀僽儔儕偺僐儞億乕僱儞僩傪娷傓偐丠
	*/
	protected boolean containStranger(ITypeInfo.FuncDesc funcdesc) {
		ITypeInfo.ElemDesc   elemFunc   = funcdesc.getFunc();
		if(isStranger(elemFunc.getTypeDesc())) return true;
		ITypeInfo.ElemDesc[] elemParams = funcdesc.getParams();
		if(elemParams == null) return false;
		for(int p=0; p<elemParams.length; p++) {
			if(isStranger(elemParams[p].getTypeDesc())) return true;
		}
		return false;
	}
	/**
		懠偺儔僀僽儔儕偺僐儞億乕僱儞僩偐丠
	*/
	protected boolean isStranger(String type) {
		if(! type.startsWith("VT_PTR+VT_USERDEFINED")) return false;
		String clsname = type.substring(type.indexOf(':')+1);
		// 摨偠儔僀僽儔儕撪偐丠
		try {
			int hRefType = ITypeInfo.getRefTypeFromTypeDesc(type);
			ITypeLib reflib = currentInfo.getRefTypeInfo(hRefType).getTypeLib();
			if(reflib.getTLibAttr().equals(currentLib.getTLibAttr())) return false;
		} catch(Exception e) { e.printStackTrace(); }
		// 堘偭偨傜丒丒丒
		return true;
	}
	/**
		堷悢傪愝掕偡傞売強傪惗惉偡傞
	*/
	String generateArgument(ITypeInfo.ElemDesc elem, String name) {
		String jtype = getJavaType(elem.getTypeDesc());
		if(jtype.equals("byte")) return "new Byte("+name+")";
		if(jtype.equals("short")) return "new Short("+name+")";
		if(jtype.equals("int")) return "new Integer("+name+")";
		if(jtype.equals("float")) return "new Float("+name+")";
		if(jtype.equals("double")) return "new Double("+name+")";
		if(jtype.equals("boolean")) return "new Boolean("+name+")";
		if(jtype.equals("String")) return name;
		if(jtype.equals("Object")) return name;			// 悇彠偝傟側偄
		if(jtype.equals("IUnknown")) return name;	// 傛偄偐丠
		if(jtype.equals("IDispatch")) return name;	// 傛偄偐丠
		if(elem.getTypeDesc().startsWith("VT_PTR+VT_USERDEFINED")) return name;
		if(jtype.equals("int[]")) return name;
		if(jtype.equals("double[]")) return name;
		if(jtype.equals("boolean[]")) return name;
		if(jtype.equals("String[]")) return name;
		return "@@@"+name;
	}
	/**
		return暥傪惗惉偡傞
	*/
	String generateReturnStatement(ITypeInfo.ElemDesc elem, String var) {
		String jtype = getJavaType(elem.getTypeDesc());
		if(jtype.equals("void")) return "return;";			// 悇彠偝傟側偄
		if(jtype.equals("byte")) return "return ((Byte)"+var+").byteValue();";
		if(jtype.equals("short")) return "return ((Short)"+var+").shortValue();";
		if(jtype.equals("int")) return "return ((Integer)"+var+").intValue();";
		if(jtype.equals("float")) return "return ((Float)"+var+").floatValue();";
		if(jtype.equals("double")) return "return ((Double)"+var+").doubleValue();";
		if(jtype.equals("boolean")) return "return ((Boolean)"+var+").booleanValue();";
		if(jtype.equals("Object")) return "return "+var+";";			// 悇彠偝傟側偄
		if(jtype.equals("String")) return "return (String)"+var+";";
		if(jtype.equals("java.util.Date")) return "return (java.util.Date)"+var+";";
		if(elem.getTypeDesc().startsWith("VT_PTR+VT_USERDEFINED"))
				return "return new "+getJavaType(elem.getTypeDesc())+"((IDispatch)"+var+");";
		if(elem.getTypeDesc().equals("VT_DISPATCH"))
				return "return (IDispatch)"+var+";";
		if(elem.getTypeDesc().equals("VT_UNKNOWN"))
				return "return (IUnknown)"+var+";";

		return "return "+jtype+"@@@"+var;
	}

	//	儐乕僓掕媊宆偺応崌丄偦偺恎尦乮ITypeLib乯傪愻偆丅
	public void checkUserDefined(ITypeInfo info, String type) {
		if(! type.startsWith("VT_PTR+VT_USERDEFINED")) return;
		try {
			// "VT_PTR+VT_USERDEFINED(50383648):Application"偐傜hreftype傪庢傝弌偡
			int hreftype = ITypeInfo.getRefTypeFromTypeDesc(type);
			ITypeInfo refinfo = info.getRefTypeInfo(hreftype);
			ITypeLib lib = refinfo.getTypeLib();
			addTLibAttr(lib.getTLibAttr());
		}
		catch(Exception ex) { ex.printStackTrace(); }
	}
	// TLibAttr傪廤傔傞
	Vector libset = new Vector();
	public boolean addTLibAttr(ITypeLib.TLibAttr attr) {
		// 偡偱偵摨偠ITypeLib偑偁傞偐偳偆偐丠
		for(int i=0; i<libset.size(); i++) {
			if(libset.get(i).equals(attr)) return false;
		}
		libset.add(attr);
		return true;
	}

	// 僞僀僾儔僀僽儔儕偐傜巜掕偟偨ITypeInfo偺撪梕傪弌椡偡傞
	void generate(ITypeLib lib, String packagename, String infoname) {
		currentLib = lib;
		currentPackageName = packagename;
		try {
			int infocount = lib.getTypeInfoCount();
			// 巜掕偟偨僆僽僕僃僋僩傪昞帵丅
			for(int i=0; i<infocount; i++) {
				ITypeInfo info = lib.getTypeInfo(i);
				if(info.getDocumentation(-1)[0].equals(infoname)) {
					generate(info);
					System.out.println("弌椡偟傑偟偨丅懡暘");
					break;	// 廔椆
				}
			}
		} catch(Exception e) { e.printStackTrace(); }
	}

	// 僞僀僾儔僀僽儔儕偺撪梕傪偡傋偰弌椡偡傞
	void generateAll(ITypeLib lib, String packagename) {
		currentLib = lib;
		currentPackageName = packagename;
		try {
			// 偡傋偰偺僐儞億乕僱儞僩傪昞帵丅
			int infocount = lib.getTypeInfoCount();
			for(int i=0; i<infocount; i++) {
				ITypeInfo info = lib.getTypeInfo(i);
System.out.print(packagename+"."+info.getDocumentation(-1)[0]);
				generate(info);
System.out.println();
			}
System.out.println(""+infocount+" file(s)");
		} catch(Exception e) { e.printStackTrace(); }
	}

	/**
		巊偄曽
	*/
	public static void usage() {
		System.out.println("巜掕偟偨ProgID偺僆僽僕僃僋僩偺僜乕僗傪帺摦惗惉偟傑偡丅");
		System.out.println();
		System.out.println("巊偄曽: JComGenerator [<options>] <ProgID>");
		System.out.println("options");
		System.out.println("  -package <packagename>   僷僢働乕僕偵偟傑偡");
		System.out.println("  -d <directory>           惗惉偝傟傞僜乕僗僼傽僀儖偺埵抲傪巜掕偟傑偡(枛旜偵\\側偟)");
		System.out.println();
		System.out.println("椺: JComGenerator \"Excel.Application\"");
		System.out.println("    偡傋偰偺僆僽僕僃僋僩偺僜乕僗傪惗惉偟傑偡丅");
		System.out.println("椺: JComGenerator \"Excel.Application.8\" jp.ne.so_net.ga2.no_ji.jcom.excel8");
		System.out.println("    _Application僆僽僕僃僋僩偺僜乕僗傪惗惉偟傑偡丅");
		System.out.println();
		System.out.println("戙昞揑側 ProgID 偲 Interface");
		System.out.println(" Excel.Application _Application");
		System.out.println(" InternetExplorer.Application IWebBrowser");
	}
	// 偲傝偁偊偢丄儔僀僽儔儕柤傪偔偭偮偗傞丅
	// jp.ne.so_net.ga2.no_ji.jcom.excel偲偄偆嬶崌偵側傞
	String getPackageName(String packagepath, ITypeLib lib) throws JComException {
		if(packagepath==null) return lib.getDocumentation(-1)[0];
		return packagepath+"."+lib.getDocumentation(-1)[0];
	}

	public static void main(String[] args) throws Exception {
		// 堷悢夝愅
		if(args.length==0) { JComGenerator.usage(); return; }
		String packagepath = null;
		String outdirs = ".";
		String progID = null;
		for(int i=0; i<args.length; i++) {
			if(args[i].equals("-package")) {
				packagepath = args[++i];	// "jp.ne.so_net.ga2.no_ji.jcom"
			}
			else if(args[i].equals("-d")) {
				outdirs = args[++i];		// "../.."
			}
			else {
				progID = args[i];
			}
		}
		if(progID==null) { JComGenerator.usage(); return; }
		// 嶌傞両
		JComGenerator generator = new JComGenerator();
		generator.setOutDirs(outdirs);	// 枛旜偵\側偟
		generator.setPackagePath(packagepath);

		ReleaseManager rm = new ReleaseManager();
		try {
			System.out.println(progID+"傪婲摦拞...");
			IDispatch disp = new IDispatch(rm, progID);
			generator.progID = progID;
			// 巜掕偝傟偨ProgID傪帩偮ITypeLib傪庢摼
			ITypeInfo typeInfo = disp.getTypeInfo();
			generator.entryInfo = typeInfo;
			ITypeLib typeLib = typeInfo.getTypeLib();

			// 儕僗僩偵捛壛丅
			generator.addTLibAttr(typeLib.getTLibAttr());

			// ITypeLIb偺撪梕傪偡傋偰夝愅偟偰弌椡丅
			// 偦偺嵺偵丄暿偺ITypeLib偺僐儞億乕僱儞僩偼悘帪棴傔偰偍偄偰丄
			// 偦傟偑側偔側傞傑偱弌椡偡傞丅
			for(int i=0; i<generator.libset.size(); i++) {
				ITypeLib.TLibAttr attr = (ITypeLib.TLibAttr)generator.libset.get(i);
System.out.println("TyepLib: "+attr);
				ITypeLib lib = ITypeLib.loadRegTypeLib(rm, attr.getLIBID(), attr.getVerMajor(), attr.getVerMinor());
				// 僷僢働乕僕柤傪嶌傞丅
				String packagename = generator.getPackageName(packagepath, lib);
				// 惗惉偡傞偤両
				generator.generateAll(lib, packagename);
			}
		}
		catch(Exception e) { e.printStackTrace(); }
		finally { rm.release(); }
	}
}

/*
	generate(ITypeInfo info)
		generateEnum(ITypeInfo info)
		generateDispatch(ITypeInfo info)
		generateCoClass(ITypeInfo info)

*/