typeparser.java

java 调用windows的api

			net.sourceforge.chaperon.process.LexicalAutomaton lexicalautomaton = (new net.sourceforge.chaperon.build.LexicalAutomatonBuilder(lexicon,logger)).getLexicalAutomaton();
			// Create a processor for the lexicon
			net.sourceforge.chaperon.process.LexicalProcessor lexer = new net.sourceforge.chaperon.process.LexicalProcessor();
			lexer.setLogger(logger);
			lexer.setLexicalAutomaton(lexicalautomaton);

			// Get a SAX parser
			xmlparser = parserFactoryImpl.newSAXParser().getXMLReader();

			// Create a grammar model for a given grammar file
			handler = new org.apache.avalon.framework.configuration.NamespacedSAXConfigurationHandler();
			xmlparser.setContentHandler(handler);
			xmlparser.parse("./chaperon/header.xgrm");
			org.apache.avalon.framework.configuration.Configuration grammarconfig = handler.getConfiguration();
			net.sourceforge.chaperon.model.grammar.Grammar grammar = net.sourceforge.chaperon.adapter.avalon.GrammarFactory.createGrammar(grammarconfig);

			// Build a automaton from the grammar model
			net.sourceforge.chaperon.process.ParserAutomaton parserautomaton = (new net.sourceforge.chaperon.build.ParserAutomatonBuilder(grammar,logger)).getParserAutomaton();

			// Create a processor for the grammar
			net.sourceforge.chaperon.process.ParserProcessor parser = new net.sourceforge.chaperon.process.ParserProcessor();
			parser.setLogger(logger);
			parser.setParserAutomaton(parserautomaton);

			// Create an adapter to produce a SAX stream as result
			net.sourceforge.chaperon.adapter.sax.ParserHandlerAdapter parseradapter = new net.sourceforge.chaperon.adapter.sax.ParserHandlerAdapter();

			// Create factory for SAX transformer
			javax.xml.transform.sax.SAXTransformerFactory transformerFactoryImpl = (javax.xml.transform.sax.SAXTransformerFactory) javax.xml.transform.sax.SAXTransformerFactory.newInstance();

//BaseData newNode = null;
//		newNode = new InterfaceNode(libaryName, null, null, 0, null, projectItem);
//		enumCollection.addChild(newNode);
			// Create serializer to write the SAX stream into dom tree
			javax.xml.transform.sax.TransformerHandler serializer = transformerFactoryImpl.newTransformerHandler();
			javax.xml.transform.dom.DOMResult domResult=new javax.xml.transform.dom.DOMResult();
			serializer.setResult(new javax.xml.transform.stream.StreamResult("output.xml"));//domResult);

			// Connect components into a pipeline
			lexer.setLexicalHandler(parser);
			parser.setParserHandler(parseradapter);
			parseradapter.setContentHandler(serializer);

			// Push text into this pipeline
			// Create locator, which help to find possible syntax errors
			net.sourceforge.chaperon.process.TextLocator locator = new net.sourceforge.chaperon.process.TextLocator();
			locator.setURI(libraryFile.toURL().toString());
			locator.setLineNumber(1);
			locator.setColumnNumber(1);
			lexer.handleLocator(locator);

			// Start document
			lexer.handleStartDocument();

			reader = new java.io.LineNumberReader(new java.io.InputStreamReader(new java.io.FileInputStream(libraryFile.getAbsolutePath())));

			String separator = System.getProperty("line.separator");

			boolean done=false;
			int subtractCount=0;
			// Push text 
			while (!done)
			{
			  if (newline==null)
				line = reader.readLine();
			  else
				line = newline;

			  if (line==null)
				done=true;

			  newline = reader.readLine();

			  line = (newline!=null) ? line+separator : line;
			  int commentIndex=line.indexOf("//");

			  if(line.startsWith("#include") || (line.indexOf("#include")>=0 && commentIndex==-1) || (commentIndex!=-1 && line.indexOf("#include")>=0 && line.indexOf("#include")<commentIndex))
			  {
				  System.out.println(line);
				  subtractCount--;
			  //lexer.handleText(line);
			  }
			  //else if(line.startsWith("#"))
			  {
			  //    subtractCount--;
			  }
			  else if(line!=null)
			  {
			  locator.setLineNumber(reader.getLineNumber()-subtractCount);
			  locator.setColumnNumber(1);
			  lexer.handleText(line);
			  }

			  if (newline==null)
				done=true;
			}
			reader.close();

                    
			System.out.println("handle end ");
			// End document
			lexer.handleEndDocument();
			}
			catch(javax.xml.parsers.ParserConfigurationException pce)
			{
				System.out.println("pce:"+pce.getMessage());
			}
			catch(org.xml.sax.SAXException se)
			{
				System.out.println("se:"+se.getMessage());
			}
			catch( java.io.IOException ioe)
			{
				System.out.println("ioe:"+ioe.getMessage());
			}
			catch(org.apache.avalon.framework.configuration.ConfigurationException ce)
			{
				System.out.println("ce:"+ce.getMessage());
			}
			catch(javax.xml.transform.TransformerConfigurationException tce)
			{
				System.out.println("tce:"+tce.getMessage());
			}
			catch(java.lang.Exception e)
			{
				System.out.println(reader.getLineNumber()+": "+line+" e:"+e.getMessage());
			}
			System.out.println("done");
                    
		}
		else*/

	private BaseData createTypeInfoNode(
		TypeLibWrapper typeLibWrapper,
		ITypeLib iTypeLib,
		int i,
		ITypeInfo[] iTypeInfo,
		TYPEATTR typeAttributeArray[])
	{
		//int [] pTKind = new int [1];
		//iTypeLib.getTypeInfoType(i, pTKind);

		int typeInfoType = typeLibWrapper.getTypeInfoType(i);

		String[] nameArray = new String[1];
		String[] docArray = new String[1];
		String[] helpFileArray = new String[1];
		int [] helpContextArray = new int[1];

		int err = iTypeLib.getDocumentation(i, nameArray, docArray, helpContextArray, helpFileArray);
		if (HRESULT.FAILED(err)) {
			throw new RuntimeException(new COMException(err).toString());
		}

		String guid = typeAttributeArray[0].guid.toProxyTypeString();

		BaseData node =
			createTypeInfoNode(
				typeInfoType,
				nameArray[0],
				docArray[0],
				helpContextArray[0],
				helpFileArray[0],
				guid);

		if (typeInfoType == TYPEKIND.TKIND_ALIAS) {
			TypeConversionConfig config =
				TypeConversionManager.getInstance().getConfig(
					typeAttributeArray[0].tdescAlias.vt);
			buildTypeDescription(
				iTypeInfo[0],
				(AliasNode) node,
				typeAttributeArray[0].tdescAlias,
				config);
		}
		
		return node;
	}
	/**
	 * Get a node for this type info according to its type in the
	 * TYPEKIND enumeration
	 *
	 * @param typeInfoType
	 * @param name
	 * @param desc
	 * @param helpContext
	 * @param helpFile
	 * @param guid
	 * @return the newly created BaseData of the appropriate type
	 */
	private BaseData createTypeInfoNode(int typeInfoType, String name,
		String desc, int helpContext, String helpFile, String guid)
	{
		BaseData newNode = null;

		switch (typeInfoType)
		{
			case TYPEKIND.TKIND_ENUM:
			{
				newNode = new EnumNode(name, desc, helpFile, helpContext, projectItem);
				enumCollection.addChild(newNode);
				break;
			}
			case TYPEKIND.TKIND_RECORD:
			{
				newNode = new RecordNode(name, desc, helpFile, helpContext, projectItem);
				recordCollection.addChild(newNode);
				break;
			}
			case TYPEKIND.TKIND_MODULE:
			{
				newNode = new ModuleNode(name, desc, helpFile, helpContext, projectItem);
				moduleCollection.addChild(newNode);
				break;
			}
			case TYPEKIND.TKIND_INTERFACE:
			{
				newNode = new InterfaceNode(name, desc, helpFile, helpContext, guid, projectItem);
				interfaceCollection.addChild(newNode);
				break;
			}
			case TYPEKIND.TKIND_DISPATCH:
			{
				newNode = new DispatchNode(name, desc, helpFile, helpContext, guid, projectItem);
				dispatchCollection.addChild(newNode);
				break;
			}
			case TYPEKIND.TKIND_COCLASS:
			{
				newNode = new CoClassNode(name, desc, helpFile, helpContext, guid, projectItem);
				coClassCollection.addChild(newNode);
				break;
			}
			case TYPEKIND.TKIND_ALIAS:
			{
				newNode = new AliasNode(name, desc, helpFile, helpContext, projectItem);
				aliasCollection.addChild(newNode);
				break;
			}
			case TYPEKIND.TKIND_UNION:
			{
				newNode = new UnionNode(name, desc, helpFile, helpContext, projectItem);
				unionCollection.addChild(newNode);
				break;
			}
		}

		return newNode;
	}


	/**
	 * Display info about this type library attribute
	 */
	private void debugTypeLibraryAttribute(TLIBATTR attribute)
	{
		Log log = Log.getInstance();

		log.debug("********************************************");
		log.debug("TypeInfo GUID: " + attribute.guid);
		log.debug("TypeInfo Locale: " + attribute.lcid);
		log.debug("TypeInfo Platform: " + attribute.syskind);
		log.debug("TypeInfo Major version: " + attribute.wMajorVerNum);
		log.debug("TypeInfo Minor version: " + attribute.wMinorVerNum);
		log.debug("TypeInfo Flags: " + attribute.wLibFlags);
	}

	private void debugFunctionDescription(FUNCDESC funcDesc)
	{
		Log log = Log.getInstance();
		log.debug("********************************************");
		log.debug("FUNCDESC funckind: " + funcDesc.funckind);
	}

	/**
	 * Build the description of a AliasNode's type (Alias)
	 *
	 * @param iTypeInfo
	 * @param element
	 * @param typeDesc
	 */
	private void buildTypeDescription(ITypeInfo iTypeInfo, AliasNode node, TYPEDESC typeDesc, TypeConversionConfig config)
	{
		if (config == null)
		{
			Log.getInstance().debug("TypeParser.buildTypeDescription() failed to find a configured type for alias: " + node.toString() + " with type code: " + typeDesc.vt);
			return;
		}

		switch (config.getIntId())
		{
			case VarTypes.VT_PTR:
			{
				/**
				 * Since this is a pointer, throw it through the function again
				 */
				TypeConversionConfig newConfig = TypeConversionManager.getInstance().getConfig(typeDesc.lptdesc[0].vt);

				if (newConfig != null)
				{
					PointerNode pointerNode = new PointerNode("pointer", VarTypes.VT_PTR);
					pointerNode.setTypeConfig(newConfig);
					node.addChild(pointerNode);
					buildTypeDescription(iTypeInfo, pointerNode, typeDesc.lptdesc[0], newConfig);
				}
				else if (typeDesc.lptdesc[0].vt != VarTypes.VT_SAFEARRAY)
				{
					System.out.println("TypeParser.buildTypeDescription() the pointer property with type = " +
							typeDesc.lptdesc[0].vt + " is not implemented yet");
				}
				break;
			}
			case VarTypes.VT_CARRAY:
			{
				ArrayNode arrayNode = new ArrayNode();
				node.addChild(arrayNode);
				/**
				 * @todo add array description parsing
				 */
				//buildArrayDescription(iTypeInfo, arrayNode, typeDesc.lpadesc[0], config);
				break;
			}
			case VarTypes.VT_SAFEARRAY:
			{
				break;
			}
			case VarTypes.VT_USERDEFINED:
			{
				ITypeInfo[] userDefinedType = new ITypeInfo[1];
				int err = iTypeInfo.getRefTypeInfo(typeDesc.hreftype, userDefinedType);
				String [] userDefinedName=new String[1];
				String [] userDefinedDocString=new String[1];
				String [] userDefinedHelpFile=new String[1];
				int [] userDefinedHelpContext=new int[1];
				err = userDefinedType[0].getDocumentation(-1, userDefinedName, userDefinedDocString, userDefinedHelpContext, userDefinedHelpFile);
				node.setTypeName(userDefinedName[0]);
				break;
			}
			default:
			{
				String javaType = config.getJavaType().getString();
				node.setTypeName(javaType);
				break;
			}
		}
	}

	/**
	 * Build the description of a property's type. Call this form of the
	 * method when the call is a top-level non-recursive call. At the top level
	 * we may need to remove a single level of indirection (VT_PTR) because
	 * of the inconsistent way that type libraries encode different types.
	 * For example, SAFEARRAY is always encoded as SAFEARRAY *, IUnknown and
	 * IDispatch are encoded without a pointer type while all other interfaces
	 * are encoded as IFoo *.
	 * 
	 * @todo need to check to see of the AliasNode form of this method
	 * needs special handling for SAFEARRAY.
	 *
	 * @param iTypeInfo
	 * @param element
	 * @param typeDesc
	 */
	private void buildTypeDescription(
		ITypeInfo iTypeInfo,
		PropertyNode node,
		TYPEDESC typeDesc,
		TypeConversionConfig config) 
	{
		buildTypeDescription(iTypeInfo, node, typeDesc, config, false);
	}
	/**
	 * Build the description of a property's type
	 *
	 * @param iTypeInfo
	 * @param element
	 * @param typeDesc
	 * @param isRecurse
	 */
	private void buildTypeDescription(
		ITypeInfo iTypeInfo,
		PropertyNode node,
		TYPEDESC typeDesc,
		TypeConversionConfig config,
		boolean isRecurse)
	{
		if (config == null)
		{
			Log.getInstance().debug("TypeParser.buildTypeDescription() failed to find a configured type for property: " + node.toString() + " with type code: " + typeDesc.vt);
			return;
		}

		switch (config.getIntId())
		{
			case VarTypes.VT_PTR:
			{
				
				/**
				 * Since this is a pointer, throw it through the function again
				 */
				TypeConversionConfig newConfig = TypeConversionManager.getInstance().getConfig(typeDesc.lptdesc[0].vt);

				if (newConfig != null)
				{
					if (!isRecurse && newConfig.getIntId() == VarTypes.VT_SAFEARRAY) {
						// Special handling for SAFEARRAY's
						node.setTypeConfig(newConfig);
					} else {
						PointerNode pointerNode = new PointerNode("pointer", VarTypes.VT_PTR);
						pointerNode.setTypeConfig(newConfig);
						node.addChild(pointerNode);
						buildTypeDescription(iTypeInfo, pointerNode, typeDesc.lptdesc[0], newConfig, true);
					}
				}
				else if (typeDesc.lptdesc[0].vt != VarTypes.VT_SAFEARRAY)
				{
					System.out.println("TypeParser.buildTypeDescription() the pointer property with type = " +
							typeDesc.lptdesc[0].vt + " is not implemented yet");
				}
				else
				{
					System.out.println("TypeParser.buildTypeDescription() newConfig was NULL");
				}
				break;
			}
			case VarTypes.VT_CARRAY:
			{
				ArrayNode arrayNode = new ArrayNode();
				node.addChild(arrayNode);
				/**
				 * @todo add array description parsing
				 */
				//buildArrayDescription(iTypeInfo, arrayNode, typeDesc.lpadesc[0], config);
				break;
			}
			case VarTypes.VT_SAFEARRAY:
			{
				break;
			}
			case VarTypes.VT_USERDEFINED:
			{
				if (isRecurse && (typeDesc.lptdesc != null)) {
					// put it through the function again with a new config
					TypeConversionConfig newConfig = TypeConversionManager.getInstance().getConfig(typeDesc.lptdesc[0].vt);
					node.setTypeConfig(newConfig);
					buildTypeDescription(iTypeInfo, node, typeDesc.lptdesc[0], newConfig, true);
				} else {
					buildUserDefinedDescription(iTypeInfo, node, typeDesc, config);
				}
				break;
			}
			default:
			{
				String javaType = config.getJavaType().getString();
				node.setTypeName(javaType);
				break;
			}
		}
	}