| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| import com.sun.star.beans.UnknownPropertyException; |
| import com.sun.star.beans.XPropertySet; |
| import com.sun.star.container.XNameAccess; |
| import com.sun.star.lang.Locale; |
| import com.sun.star.lang.WrappedTargetException; |
| import com.sun.star.lang.XServiceInfo; |
| import com.sun.star.reflection.ParamInfo; |
| import com.sun.star.reflection.XIdlClass; |
| import com.sun.star.reflection.XIdlMethod; |
| import com.sun.star.reflection.XTypeDescription; |
| import com.sun.star.text.XTextTablesSupplier; |
| import com.sun.star.uno.Any; |
| import com.sun.star.uno.AnyConverter; |
| import com.sun.star.uno.Type; |
| import com.sun.star.uno.TypeClass; |
| import com.sun.star.uno.UnoRuntime; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.Vector; |
| |
| |
| |
| public class SourceCodeGenerator { |
| private Vector sExceptions = new Vector(); |
| Vector sHeaderStatements = new HeaderStatements(); |
| private XLanguageSourceCodeGenerator m_xLanguageSourceCodeGenerator; |
| private String sHeaderCode = ""; |
| private String sStatementCode = ""; |
| private String sMainMethodSignature = ""; |
| |
| private Hashtable aVariables = new Hashtable(); |
| private final String SSUFFIXSEPARATOR = "_"; |
| private final String SVARIABLENAME = "VariableName"; |
| private final String SARRAYVARIABLENAME = "VariableNameList"; |
| private final String SUNOOBJECTNAME = "oUnobject"; |
| private final String SUNOSTRUCTNAME = "aUnoStruct"; |
| private Introspector m_oIntrospector; |
| private Vector aTreepathProviders = new Vector(); |
| private XTreePathProvider xTreepathProvider = null; |
| private boolean baddExceptionHandling = false; |
| private boolean bXPropertySetExceptionsAreAdded = false; |
| private XUnoNode oInitialUnoNode = null; |
| private final String sINITIALVARIABLENAME = "_oUnoEntryObject"; |
| |
| |
| /** Creates a new instance of SourceCodeGenerator */ |
| public SourceCodeGenerator(int _nLanguage) { |
| this.setLanguage(_nLanguage); |
| m_oIntrospector = Introspector.getIntrospector(); |
| } |
| |
| |
| public String addSourceCodeOfUnoObject(XTreePathProvider _xTreepathProvider, boolean _brememberPath, boolean _bAddMethodSignature, boolean _baddHeader){ |
| String sSourceCode = ""; |
| String sVariableName = ""; |
| if (_xTreepathProvider != null) { |
| for (int i = 0; i < _xTreepathProvider.getPathCount(); i++){ |
| XUnoNode oUnoNode = _xTreepathProvider.getPathComponent(i); |
| if (i == 0){ |
| sVariableName = sINITIALVARIABLENAME; |
| oInitialUnoNode = oUnoNode; |
| } |
| else{ |
| if (oUnoNode instanceof XUnoMethodNode){ |
| XUnoMethodNode oUnoMethodNode = (XUnoMethodNode) oUnoNode; |
| if (oUnoMethodNode.isInvoked()){ |
| UnoObjectDefinition oUnoReturnObjectDefinition = getUnoObjectDefinition(_xTreepathProvider, oUnoMethodNode, i); |
| if (!isVariableDeclared(oUnoReturnObjectDefinition, this.generateVariableNameFromMethod(oUnoMethodNode.getXIdlMethod()))){ |
| // sStatementCode += "\n"; |
| sStatementCode += "\n" + getMethodStatementSourceCode(oUnoMethodNode, sVariableName, oUnoReturnObjectDefinition); |
| } |
| sVariableName = oUnoReturnObjectDefinition.getVariableName(); |
| } |
| } |
| else if (oUnoNode instanceof XUnoPropertyNode){ |
| XUnoPropertyNode oUnoPropertyNode = (XUnoPropertyNode) oUnoNode; |
| Any oReturnObject = com.sun.star.uno.Any.complete(oUnoPropertyNode.getUnoReturnObject()); |
| UnoObjectDefinition oUnoReturnObjectDefinition = new UnoObjectDefinition(oReturnObject); |
| if (!isVariableDeclared(oUnoReturnObjectDefinition, oUnoPropertyNode.getProperty().Name)){ |
| // sStatementCode += "\n"; |
| sStatementCode += "\n" + getPropertyStatementSourceCode(oUnoPropertyNode, sVariableName, oUnoReturnObjectDefinition); |
| } |
| sVariableName = oUnoReturnObjectDefinition.getVariableName(); |
| } |
| } |
| } |
| } |
| String sCompleteCode = combineCompleteSourceCode(sMainMethodSignature, _baddHeader); |
| xTreepathProvider = _xTreepathProvider; |
| if (_brememberPath){ |
| aTreepathProviders.add(_xTreepathProvider); |
| } |
| return sCompleteCode; |
| } |
| |
| |
| private void setLanguage(int _nLanguage){ |
| XLanguageSourceCodeGenerator xLanguageSourceCodeGenerator = null; |
| switch(_nLanguage){ |
| case XLanguageSourceCodeGenerator.nJAVA: |
| xLanguageSourceCodeGenerator = new JavaCodeGenerator(); |
| break; |
| case XLanguageSourceCodeGenerator.nCPLUSPLUS: |
| xLanguageSourceCodeGenerator = new CPlusPlusCodeGenerator(); |
| break; |
| case XLanguageSourceCodeGenerator.nBASIC: |
| xLanguageSourceCodeGenerator = new BasicCodeGenerator(); |
| break; |
| default: |
| System.out.println("Unknown Sourcecode Language. Check Menus!"); |
| } |
| if (xLanguageSourceCodeGenerator != null){ |
| m_xLanguageSourceCodeGenerator = xLanguageSourceCodeGenerator; |
| } |
| } |
| |
| private void resetSourceCodeGeneration(int _nLanguage){ |
| aVariables.clear(); |
| this.sHeaderStatements.clear(); |
| setLanguage(_nLanguage); |
| String sHeaderCode = ""; |
| sStatementCode = ""; |
| } |
| |
| private String generateVariableNameFromMethod(String _sMethodName, String _sPrefix, boolean _bConsiderAll){ |
| String sReturn = ""; |
| if (_sMethodName.startsWith(_sPrefix)){ |
| int nPrefixLength = _sPrefix.length(); |
| if (_sMethodName.length() > nPrefixLength){ |
| String sChar = _sMethodName.substring(nPrefixLength, nPrefixLength + 1); |
| String sUpperChar = sChar.toUpperCase(); |
| if (sUpperChar.equals(sChar)){ |
| if (_bConsiderAll){ |
| sReturn = _sMethodName; |
| } |
| else{ |
| sReturn = _sMethodName.substring(nPrefixLength, _sMethodName.length()); |
| } |
| } |
| } |
| } |
| return sReturn; |
| } |
| |
| |
| private String generateVariableNameFromMethod(XIdlMethod _xIdlMethod){ |
| // todo: refactor this!!! |
| String sMethodName = _xIdlMethod.getName(); |
| String sReturn = ""; |
| sReturn = generateVariableNameFromMethod(sMethodName, "getBy", false); |
| if (sReturn.equals("")){ |
| sReturn = generateVariableNameFromMethod(sMethodName, "get", false); |
| } |
| if (sReturn.equals("")){ |
| sReturn = generateVariableNameFromMethod(sMethodName, "attach", false); |
| } |
| if (sReturn.equals("")){ |
| sReturn = generateVariableNameFromMethod(sMethodName, "assign", false); |
| } |
| if (sReturn.equals("")){ |
| sReturn = generateVariableNameFromMethod(sMethodName, "attach", false); |
| } |
| if (sReturn.equals("")){ |
| sReturn = generateVariableNameFromMethod(sMethodName, "create", false); |
| } |
| if (sReturn.equals("")){ |
| sReturn = generateVariableNameFromMethod(sMethodName, "is", true); |
| } |
| if (sReturn.equals("")){ |
| sReturn = generateVariableNameFromMethod(sMethodName, "has", true); |
| } |
| if (sReturn.equals("")){ |
| sReturn = sMethodName; |
| } |
| return sReturn; |
| } |
| |
| |
| public String convertAllUnoObjects(int _nLanguage){ |
| String sSourceCode = ""; |
| resetSourceCodeGeneration(_nLanguage); |
| int ncount = aTreepathProviders.size(); |
| for (int i=0; i< ncount; i++){ |
| sSourceCode = addSourceCodeOfUnoObject((XTreePathProvider) aTreepathProviders.get(i), false, (i==0), (i == (ncount-1))); |
| } |
| return sSourceCode; |
| } |
| |
| private UnoObjectDefinition getUnoObjectDefinition(XTreePathProvider _xTreePathProvider, XUnoMethodNode _oUnoMethodNode, int _nindex){ |
| XUnoNode oUnoNode = null; |
| Object oUnoReturnObject = null; |
| Object[] oParamObjects = null; |
| XIdlClass xIdlClass = _oUnoMethodNode.getXIdlMethod().getReturnType(); |
| String sTypeName = xIdlClass.getName(); |
| TypeClass aTypeClass = xIdlClass.getTypeClass(); |
| if (aTypeClass.getValue() != TypeClass.VOID_value){ |
| if (_xTreePathProvider.getPathCount() > _nindex + 1){ |
| oUnoNode = _xTreePathProvider.getPathComponent(_nindex + 1); |
| oUnoReturnObject = oUnoNode.getUnoObject(); |
| } |
| } |
| if (oUnoReturnObject == null){ |
| oUnoReturnObject = _oUnoMethodNode.getLastUnoReturnObject(); |
| } |
| UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(oUnoReturnObject, sTypeName, aTypeClass); |
| if (_oUnoMethodNode.hasParameters()){ |
| if (oUnoNode != null){ |
| oParamObjects = oUnoNode.getParameterObjects(); |
| } |
| else{ |
| oParamObjects = _oUnoMethodNode.getLastParameterObjects(); |
| } |
| } |
| if (oParamObjects != null){ |
| oUnoObjectDefinition.addParameterObjects(oParamObjects); |
| } |
| return oUnoObjectDefinition; |
| } |
| |
| |
| private String combineCompleteSourceCode(String _sMethodSignature, boolean _bAddHeader){ |
| String sCompleteCode = ""; |
| if (_bAddHeader){ |
| sMainMethodSignature = m_xLanguageSourceCodeGenerator.getMainMethodSignatureSourceCode(oInitialUnoNode, sINITIALVARIABLENAME); |
| m_xLanguageSourceCodeGenerator.assignqueryInterfaceHeaderSourceCode(); |
| sCompleteCode += getHeaderSourceCode(); |
| } |
| sCompleteCode += sMainMethodSignature; |
| sCompleteCode += sStatementCode; |
| if (_bAddHeader){ |
| sCompleteCode += m_xLanguageSourceCodeGenerator.getMethodTerminationSourceCode(); |
| sCompleteCode += "\n" + m_xLanguageSourceCodeGenerator.getCommentSign() + "..."; |
| } |
| return sCompleteCode; |
| } |
| |
| |
| public String getPropertyStatementSourceCode(XUnoPropertyNode _oUnoPropertyNode, String _sVariableName, UnoObjectDefinition _oUnoReturnObjectDefinition){ |
| String sReturnObjectVariableDefinition = ""; |
| String sStatement = ""; |
| String sPropertyName = _oUnoPropertyNode.getProperty().Name; |
| UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoPropertyNode.getUnoObject(), "com.sun.star.beans.XPropertySet"); |
| if (!m_xLanguageSourceCodeGenerator.needsqueryInterface() || (oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.STRUCT_value)){ |
| oUnoObjectDefinition.setVariableName(_sVariableName); |
| if (oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.STRUCT_value){ |
| sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, false); |
| sStatement += m_xLanguageSourceCodeGenerator.getStructSourceCode(sReturnObjectVariableDefinition, oUnoObjectDefinition.getVariableName(), sPropertyName); |
| return sStatement; |
| } |
| } |
| sStatement += addQueryInterfaceSourceCode(oUnoObjectDefinition, _sVariableName, "com.sun.star.beans.XPropertySet"); |
| if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){ |
| sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, true); |
| } |
| sStatement += m_xLanguageSourceCodeGenerator.getPropertyValueGetterSourceCode(sPropertyName, sReturnObjectVariableDefinition, oUnoObjectDefinition.getVariableName(), _oUnoReturnObjectDefinition.getTypeClass(), _oUnoReturnObjectDefinition.getTypeName()); |
| addXPropertySetRelatedExceptions(); |
| return sStatement; |
| } |
| |
| |
| public String getMethodStatementSourceCode(XUnoMethodNode _oUnoMethodNode, String _sVariableName, UnoObjectDefinition _oUnoReturnObjectDefinition){ |
| String sReturnObjectVariableDefinition = ""; |
| String sStatement = ""; |
| XIdlMethod xIdlMethod = _oUnoMethodNode.getXIdlMethod(); |
| TypeClass aReturnTypeClass = xIdlMethod.getReturnType().getTypeClass(); |
| UnoObjectDefinition oUnoObjectDefinition = new UnoObjectDefinition(_oUnoMethodNode.getUnoObject(), _oUnoMethodNode.getClassName()); |
| String sVariableStemName = this.generateVariableNameFromMethod(xIdlMethod); |
| sStatement += addQueryInterfaceSourceCode(oUnoObjectDefinition, _sVariableName, oUnoObjectDefinition.getTypeName()); |
| if (_oUnoReturnObjectDefinition.getTypeClass().getValue() != TypeClass.VOID_value){ |
| sReturnObjectVariableDefinition = getVariableInitialization(_oUnoReturnObjectDefinition, false) + " = "; |
| } |
| Object[] oParamObjects = _oUnoReturnObjectDefinition.getParameterObjects(); |
| String sParameterCode = getMethodParameterValueDescription(_oUnoMethodNode, oParamObjects, false); |
| String sSeparator = m_xLanguageSourceCodeGenerator.getMethodSeparator(); |
| sStatement += "\t" + sReturnObjectVariableDefinition + oUnoObjectDefinition.getVariableName() + sSeparator + xIdlMethod.getName() + "(" + sParameterCode + ")"; |
| sStatement += m_xLanguageSourceCodeGenerator.getStatementTerminationCharacter(); |
| addExceptions(xIdlMethod); |
| return sStatement; |
| } |
| |
| |
| private String addQueryInterfaceSourceCode(UnoObjectDefinition _oUnoObjectDefinition, String _sVariableName, String _sTypeName){ |
| String sLocStatement = ""; |
| if (m_xLanguageSourceCodeGenerator.needsqueryInterface()){ |
| if (!isVariableDeclared(_oUnoObjectDefinition, "")){ |
| String sObjectVariableDefinition = getVariableDeclaration(_oUnoObjectDefinition, false, ""); |
| sLocStatement += m_xLanguageSourceCodeGenerator.getqueryInterfaceSourceCode(_sTypeName, sObjectVariableDefinition, _sVariableName); |
| } |
| } |
| else{ |
| _oUnoObjectDefinition.setVariableName(_sVariableName); |
| } |
| return sLocStatement; |
| } |
| |
| |
| private void addXPropertySetRelatedExceptions(){ |
| if (!bXPropertySetExceptionsAreAdded){ |
| sExceptions.add("com.sun.star.beans.UnknownPropertyException"); |
| sExceptions.add("com.sun.star.lang.WrappedTargetException"); |
| sExceptions.add("com.sun.star.lang.IllegalArgumentException"); |
| bXPropertySetExceptionsAreAdded = true; |
| baddExceptionHandling = true; |
| } |
| } |
| |
| |
| private void addExceptions(XIdlMethod _xIdlMethod){ |
| XIdlClass[] xIdlClasses = _xIdlMethod.getExceptionTypes(); |
| for (int i = 0; i > xIdlClasses.length; i++){ |
| sExceptions.add(xIdlClasses[0].getName()); |
| baddExceptionHandling = true; |
| } |
| } |
| |
| private String getRootDescription(XUnoNode _oUnoNode){ |
| return "_o" + _oUnoNode.toString(); |
| } |
| |
| |
| private String getHeaderSourceCode(){ |
| Enumeration aEnumeration = aVariables.elements(); |
| while(aEnumeration.hasMoreElements()){ |
| UnoObjectDefinition oUnoObjectDefinition = (UnoObjectDefinition) aEnumeration.nextElement(); |
| String sCurHeaderStatement = m_xLanguageSourceCodeGenerator.getHeaderSourceCode(oUnoObjectDefinition.getUnoObject(), oUnoObjectDefinition.getTypeName(), oUnoObjectDefinition.getTypeClass()); |
| sHeaderStatements.add(sCurHeaderStatement); |
| } |
| String sHeaderSourcecode = ""; |
| String[] sHeaderStatementArray = new String[sHeaderStatements.size()]; |
| sHeaderStatements.toArray(sHeaderStatementArray); |
| java.util.Arrays.sort(sHeaderStatementArray); |
| for (int i = 0; i < sHeaderStatementArray.length; i++){ |
| sHeaderSourcecode += sHeaderStatementArray[i]; |
| } |
| sHeaderSourcecode += m_xLanguageSourceCodeGenerator.getFinalHeaderStatements(); |
| return sHeaderSourcecode +"\n" + m_xLanguageSourceCodeGenerator.getCommentSign() + "...\n"; |
| } |
| |
| |
| private class HeaderStatements extends Vector{ |
| |
| public boolean contains(Object _oElement){ |
| String sCompName = (String) _oElement; |
| for (int i = 0; i < this.size(); i++){ |
| String sElement = (String) this.get(i); |
| if (sElement.equals(sCompName)){ |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| |
| public boolean add(Object _oElement){ |
| if (_oElement instanceof String){ |
| if (!contains(_oElement)){ |
| super.add(_oElement); |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
| |
| |
| private boolean isVariableDeclared(UnoObjectDefinition _oUnoObjectDefinition, String _sDefaultStemName){ |
| boolean bisDeclared = false; |
| if (!_sDefaultStemName.equals("")){ |
| _oUnoObjectDefinition.setCentralVariableStemName(_sDefaultStemName); |
| } |
| String sVariableStemName = _oUnoObjectDefinition.getVariableStemName(); |
| bisDeclared = aVariables.containsKey(sVariableStemName); |
| if (bisDeclared){ |
| Object oUnoObject = _oUnoObjectDefinition.getUnoObject(); |
| if (m_oIntrospector.isObjectPrimitive(oUnoObject)){ |
| bisDeclared = false; |
| } |
| else if (m_oIntrospector.isObjectSequence(oUnoObject)){ |
| bisDeclared = false; |
| } |
| else{ |
| String sCompVariableName = sVariableStemName; |
| String sUnoObjectIdentity = oUnoObject.toString(); |
| boolean bleaveloop = false; |
| int a = 2; |
| while (!bleaveloop){ |
| if (aVariables.containsKey(sCompVariableName)){ |
| Object oUnoCompObject = ((UnoObjectDefinition) aVariables.get(sCompVariableName)).getUnoObject(); |
| String sUnoCompObjectIdentity = oUnoCompObject.toString(); |
| bleaveloop = sUnoCompObjectIdentity.equals(sUnoObjectIdentity); |
| bisDeclared = bleaveloop; |
| if (!bleaveloop){ |
| sCompVariableName = sVariableStemName + SSUFFIXSEPARATOR + a++; |
| } |
| } |
| else{ |
| bleaveloop = true; |
| bisDeclared = false; |
| } |
| } |
| } |
| } |
| return bisDeclared; |
| } |
| |
| |
| private String addUniqueVariableName(String _sStemVariableName, UnoObjectDefinition _oUnoObjectDefinition){ |
| boolean bElementexists = true; |
| int a = 2; |
| String sCompName = _sStemVariableName; |
| while (bElementexists){ |
| if (! aVariables.containsKey(sCompName)){ |
| aVariables.put(sCompName, _oUnoObjectDefinition); |
| break; |
| } |
| sCompName = _sStemVariableName + SSUFFIXSEPARATOR + a++; |
| } |
| return sCompName; |
| } |
| |
| |
| |
| private String getTypeString(String _sTypeName, TypeClass _aTypeClass, boolean _bAsHeaderSourceCode){ |
| String sTypeString = ""; |
| switch (_aTypeClass.getValue()){ |
| case TypeClass.BOOLEAN_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getbooleanTypeDescription(); |
| break; |
| case TypeClass.BYTE_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getbyteTypeDescription(); |
| break; |
| case TypeClass.CHAR_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getcharTypeDescription(); |
| break; |
| case TypeClass.DOUBLE_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getdoubleTypeDescription(); |
| break; |
| case TypeClass.FLOAT_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getfloatTypeDescription(); |
| break; |
| case TypeClass.HYPER_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.gethyperTypeDescription(); |
| break; |
| case TypeClass.LONG_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getlongTypeDescription(); |
| break; |
| case TypeClass.SHORT_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getshortTypeDescription(); |
| break; |
| case TypeClass.STRING_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getstringTypeDescription(_bAsHeaderSourceCode); |
| break; |
| case TypeClass.UNSIGNED_HYPER_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getunsignedhyperTypeDescription(); |
| break; |
| case TypeClass.UNSIGNED_LONG_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getunsignedlongTypeDescription(); |
| break; |
| case TypeClass.UNSIGNED_SHORT_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getdoubleTypeDescription(); |
| break; |
| case TypeClass.SEQUENCE_value: |
| //TODO consider mulitdimensional Arrays |
| XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(_sTypeName); |
| if (xTypeDescription != null){ |
| sTypeString = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), _bAsHeaderSourceCode); |
| } |
| break; |
| case TypeClass.ANY_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getanyTypeDescription(_bAsHeaderSourceCode); |
| break; |
| case TypeClass.TYPE_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription("com.sun.star.uno.Type", _bAsHeaderSourceCode); |
| break; |
| case TypeClass.ENUM_value: |
| case TypeClass.STRUCT_value: |
| case TypeClass.INTERFACE_ATTRIBUTE_value: |
| case TypeClass.INTERFACE_METHOD_value: |
| case TypeClass.INTERFACE_value: |
| case TypeClass.PROPERTY_value: |
| sTypeString = m_xLanguageSourceCodeGenerator.getObjectTypeDescription(_sTypeName, _bAsHeaderSourceCode); |
| break; |
| default: |
| } |
| return sTypeString; |
| } |
| |
| |
| private String getVariableDeclaration(UnoObjectDefinition _oUnoObjectDefinition, boolean _bInitialize, String _sVariableDefaultName){ |
| TypeClass aTypeClass = _oUnoObjectDefinition.getTypeClass(); |
| TypeClass aLocTypeClass = aTypeClass; |
| boolean bIsArray = false; |
| if (_oUnoObjectDefinition.getUnoObject() != null){ |
| bIsArray = m_oIntrospector.isObjectSequence(_oUnoObjectDefinition.getUnoObject()); |
| } |
| else{ |
| bIsArray = _oUnoObjectDefinition.getTypeClass().getValue() == TypeClass.SEQUENCE_value; |
| } |
| String sVariableName = _oUnoObjectDefinition.getVariableName(_sVariableDefaultName); |
| String sTypeName = _oUnoObjectDefinition.getTypeName(); |
| String sTypeString = getTypeString(sTypeName, aLocTypeClass, false); |
| if (bIsArray){ |
| XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(sTypeName); |
| if (xTypeDescription != null){ |
| aLocTypeClass = xTypeDescription.getTypeClass(); |
| } |
| } |
| String sVariableDeclaration = m_xLanguageSourceCodeGenerator.getVariableDeclaration(sTypeString, sVariableName, bIsArray, aLocTypeClass, _bInitialize); |
| addUniqueVariableName(sVariableName, _oUnoObjectDefinition); |
| return sVariableDeclaration; |
| } |
| |
| |
| public String getVariableInitialization(UnoObjectDefinition _oUnoObjectDefinition, boolean _bInitialize){ |
| String sObjectVariableDeclaration = ""; |
| String sVariableName = _oUnoObjectDefinition.getVariableName(); |
| if (isVariableDeclared(_oUnoObjectDefinition, "")){ |
| sObjectVariableDeclaration = sVariableName; |
| } |
| else{ |
| sObjectVariableDeclaration = getVariableDeclaration(_oUnoObjectDefinition, _bInitialize, ""); |
| } |
| return sObjectVariableDeclaration; |
| } |
| |
| |
| |
| public String getVariableNameforUnoObject(String _sShortClassName){ |
| if (_sShortClassName.startsWith("X")){ |
| return "x" + _sShortClassName.substring(1); |
| } |
| else{ |
| return _sShortClassName; |
| } |
| } |
| |
| |
| class UnoObjectDefinition{ |
| Object m_oUnoObject = null; |
| Type aType = null; |
| String sVariableStemName = ""; |
| String m_sCentralVariableStemName = ""; |
| String sVariableName = ""; |
| String m_sTypeName = ""; |
| TypeClass m_aTypeClass = null; |
| Object[] m_oParameterObjects = null; |
| |
| |
| public UnoObjectDefinition(Any _oUnoObject){ |
| m_sTypeName = _oUnoObject.getType().getTypeName(); |
| m_aTypeClass = _oUnoObject.getType().getTypeClass(); |
| m_oUnoObject = _oUnoObject; |
| m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass); |
| } |
| |
| |
| public UnoObjectDefinition(Object _oUnoObject, String _sTypeName, TypeClass _aTypeClass){ |
| m_oUnoObject = _oUnoObject; |
| m_sTypeName = _sTypeName; |
| m_aTypeClass = _aTypeClass; |
| m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass); |
| } |
| |
| |
| public UnoObjectDefinition(Object _oUnoObject, String _sTypeName){ |
| m_oUnoObject = _oUnoObject; |
| m_sTypeName = _sTypeName; |
| m_aTypeClass = AnyConverter.getType(_oUnoObject).getTypeClass(); |
| m_sCentralVariableStemName = getCentralVariableStemName(m_aTypeClass); |
| } |
| |
| |
| private String getCentralVariableStemName(TypeClass _aTypeClass){ |
| String sCentralVariableStemName = ""; |
| int nTypeClass = _aTypeClass.getValue(); |
| switch(nTypeClass){ |
| case TypeClass.SEQUENCE_value: |
| //TODO consider mulitdimensional Arrays |
| XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName()); |
| if (xTypeDescription != null){ |
| sCentralVariableStemName = getCentralVariableStemName(xTypeDescription.getTypeClass()); |
| } |
| break; |
| case TypeClass.TYPE_value: |
| sCentralVariableStemName = SVARIABLENAME; |
| break; |
| case TypeClass.STRUCT_value: |
| sCentralVariableStemName = Introspector.getShortClassName(getTypeName()); |
| break; |
| case TypeClass.INTERFACE_ATTRIBUTE_value: |
| case TypeClass.INTERFACE_METHOD_value: |
| case TypeClass.INTERFACE_value: |
| case TypeClass.PROPERTY_value: |
| String sShortClassName = m_oIntrospector.getShortClassName(getTypeName()); |
| sCentralVariableStemName = getVariableNameforUnoObject(sShortClassName); |
| default: |
| sCentralVariableStemName = SVARIABLENAME; |
| } |
| return sCentralVariableStemName; |
| } |
| |
| /** may return null |
| */ |
| public Object getUnoObject(){ |
| return m_oUnoObject; |
| } |
| |
| |
| public void setTypeClass(TypeClass _aTypeClass){ |
| sVariableStemName = ""; |
| m_aTypeClass = _aTypeClass; |
| } |
| |
| |
| public TypeClass getTypeClass(){ |
| return m_aTypeClass; |
| } |
| |
| |
| public void setTypeName(String _sTypeName){ |
| sVariableStemName = ""; |
| m_sTypeName = _sTypeName; |
| } |
| |
| |
| public String getTypeName(){ |
| return m_sTypeName; |
| } |
| |
| |
| public void setCentralVariableStemName(String _sCentralVariableStemName){ |
| m_sCentralVariableStemName = _sCentralVariableStemName; |
| } |
| |
| |
| public String getVariableStemName(){ |
| if (sVariableStemName.equals("")){ |
| sVariableStemName = getVariableStemName(m_aTypeClass); |
| } |
| return sVariableStemName; |
| } |
| |
| |
| public void addParameterObjects(Object[] _oParameterObjects){ |
| m_oParameterObjects = _oParameterObjects; |
| } |
| |
| |
| public Object[] getParameterObjects(){ |
| return m_oParameterObjects; |
| } |
| |
| |
| public boolean hasParameterObjects(){ |
| boolean breturn = false; |
| if (m_oParameterObjects != null){ |
| breturn = m_oParameterObjects.length > 0; |
| } |
| return breturn; |
| } |
| |
| |
| public String getVariableStemName(TypeClass _aTypeClass){ |
| int nTypeClass = _aTypeClass.getValue(); |
| switch(nTypeClass){ |
| case TypeClass.BOOLEAN_value: |
| sVariableStemName = "b" + m_sCentralVariableStemName; |
| break; |
| case TypeClass.DOUBLE_value: |
| case TypeClass.FLOAT_value: |
| sVariableStemName = "f" + m_sCentralVariableStemName; |
| break; |
| case TypeClass.BYTE_value: |
| case TypeClass.HYPER_value: |
| case TypeClass.LONG_value: |
| case TypeClass.UNSIGNED_HYPER_value: |
| case TypeClass.UNSIGNED_LONG_value: |
| case TypeClass.UNSIGNED_SHORT_value: |
| case TypeClass.SHORT_value: |
| sVariableStemName = "n" + m_sCentralVariableStemName; |
| break; |
| case TypeClass.CHAR_value: |
| case TypeClass.STRING_value: |
| sVariableStemName = "s" + m_sCentralVariableStemName; |
| break; |
| case TypeClass.SEQUENCE_value: |
| //TODO consider mulitdimensional Arrays |
| XTypeDescription xTypeDescription = Introspector.getIntrospector().getReferencedType(getTypeName()); |
| if (xTypeDescription != null){ |
| sVariableStemName = getVariableStemName(xTypeDescription.getTypeClass()); |
| } |
| break; |
| case TypeClass.TYPE_value: |
| sVariableStemName = "a" + m_sCentralVariableStemName; |
| break; |
| case TypeClass.ANY_value: |
| sVariableStemName = "o" + m_sCentralVariableStemName; |
| break; |
| case TypeClass.STRUCT_value: |
| case TypeClass.ENUM_value: |
| sVariableStemName = "a" + m_sCentralVariableStemName; |
| break; |
| case TypeClass.INTERFACE_ATTRIBUTE_value: |
| case TypeClass.INTERFACE_METHOD_value: |
| case TypeClass.INTERFACE_value: |
| case TypeClass.PROPERTY_value: |
| String sShortClassName = m_oIntrospector.getShortClassName(getTypeName()); |
| sVariableStemName = getVariableNameforUnoObject(sShortClassName); |
| default: |
| } |
| return sVariableStemName; |
| } |
| |
| |
| private void setVariableName(String _sVariableName){ |
| sVariableName = _sVariableName; |
| } |
| |
| |
| private String getVariableName(String _sCentralVariableStemName){ |
| if (!_sCentralVariableStemName.equals("")){ |
| this.m_sCentralVariableStemName = _sCentralVariableStemName; |
| } |
| return getVariableName(); |
| } |
| |
| |
| private String getVariableName() throws NullPointerException{ |
| if (sVariableName.equals("")){ |
| int a = 2; |
| sVariableName = getVariableStemName(); |
| boolean bleaveloop = false; |
| while (!bleaveloop){ |
| if (aVariables.containsKey(sVariableName)){ |
| String sUnoObjectIdentity = ((UnoObjectDefinition) aVariables.get(sVariableName)).getUnoObject().toString(); |
| if (m_oUnoObject != null){ |
| if ((sUnoObjectIdentity.equals(m_oUnoObject.toString()) && (!m_oIntrospector.isPrimitive(this.getTypeClass())) && |
| (! m_oIntrospector.isObjectSequence(m_oUnoObject)))){ |
| bleaveloop = true; |
| } |
| else{ |
| sVariableName = getVariableStemName() + SSUFFIXSEPARATOR + a++; |
| } |
| } |
| else{ |
| bleaveloop = true; |
| } |
| } |
| else{ |
| bleaveloop = true; |
| // throw new NullPointerException("SourceCode Variable " + _sStemVariableName + " not defined"); |
| } |
| } |
| } |
| return sVariableName; |
| } |
| } |
| |
| |
| public String getStringValueOfObject(Object _oUnoObject, TypeClass _aTypeClass){ |
| String sReturn = ""; |
| switch (_aTypeClass.getValue()){ |
| case TypeClass.BOOLEAN_value: |
| boolean bbooleanValue = ((Boolean) _oUnoObject).booleanValue(); |
| sReturn += Boolean.toString(bbooleanValue); |
| case TypeClass.CHAR_value: |
| break; |
| case TypeClass.DOUBLE_value: |
| double fdoubleValue = ((Double) _oUnoObject).doubleValue(); |
| sReturn += Double.toString(fdoubleValue); |
| break; |
| case TypeClass.ENUM_value: |
| break; |
| case TypeClass.FLOAT_value: |
| float floatValue = ((Float) _oUnoObject).floatValue(); |
| sReturn += Float.toString(floatValue); |
| break; |
| case TypeClass.HYPER_value: |
| long nlongValue = ((Long) _oUnoObject).longValue(); |
| sReturn += Long.toString(nlongValue); |
| break; |
| case TypeClass.LONG_value: |
| int nintValue = ((Integer) _oUnoObject).intValue(); |
| sReturn += Integer.toString(nintValue); |
| break; |
| case TypeClass.SHORT_value: |
| short nshortValue = ((Short) _oUnoObject).shortValue(); |
| sReturn += Short.toString(nshortValue); |
| break; |
| case TypeClass.STRING_value: |
| sReturn += (String) _oUnoObject; |
| break; |
| case TypeClass.UNSIGNED_HYPER_value: |
| nlongValue = ((Long) _oUnoObject).longValue(); |
| sReturn += Long.toString(nlongValue); |
| break; |
| case TypeClass.UNSIGNED_LONG_value: |
| nintValue = ((Integer) _oUnoObject).intValue(); |
| sReturn += Integer.toString(nintValue); |
| break; |
| case TypeClass.UNSIGNED_SHORT_value: |
| nshortValue = ((Short) _oUnoObject).shortValue(); |
| sReturn += Short.toString(nshortValue); |
| break; |
| default: |
| System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'getStringValueOfObject()'"); |
| } |
| return sReturn; |
| } |
| |
| |
| public String getMethodParameterValueDescription(XUnoMethodNode _oUnoMethodNode, Object[] _oParamObjects, boolean _bIncludeParameterNames){ |
| String sParamSourceCode = ""; |
| ParamInfo[] aParamInfos = _oUnoMethodNode.getXIdlMethod().getParameterInfos(); |
| if (_oParamObjects != null){ |
| for (int i = 0; i < _oParamObjects.length; i++){ |
| TypeClass aTypeClass = aParamInfos[i].aType.getTypeClass(); |
| if (_bIncludeParameterNames){ |
| sParamSourceCode += aParamInfos[i].aName + "="; |
| } |
| String sParamDescription = getStringValueOfObject(_oParamObjects[i], aTypeClass); |
| sParamDescription = this.m_xLanguageSourceCodeGenerator.castLiteral(sParamDescription, aTypeClass); |
| sParamSourceCode += sParamDescription; |
| |
| if (i < _oParamObjects.length - 1){ |
| sParamSourceCode += ", "; |
| } |
| } |
| } |
| return sParamSourceCode; |
| } |
| |
| |
| public class JavaCodeGenerator implements XLanguageSourceCodeGenerator{ |
| String sStatementsCode = ""; |
| boolean bAddAnyConverter = false; |
| // boolean bAddTypeImport = false; |
| boolean bIsPropertyUnoObjectDefined = false; |
| |
| public JavaCodeGenerator(){ |
| } |
| |
| |
| public String getStatementTerminationCharacter(){ |
| return ";"; |
| } |
| |
| |
| public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){ |
| String sClassName = _sClassName; |
| String sHeaderStatement = ""; |
| if (_oUnoObject != null){ |
| if (!m_oIntrospector.isObjectPrimitive(_oUnoObject)){ |
| if (m_oIntrospector.isObjectSequence(_oUnoObject)){ |
| XTypeDescription xTypeDescription = m_oIntrospector.getReferencedType(sClassName); |
| if (xTypeDescription != null){ |
| if (!m_oIntrospector.isPrimitive(xTypeDescription.getTypeClass())){ |
| sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), true); |
| } |
| // primitive Types are not supposed to turn up in the import section... |
| else{ |
| sClassName = ""; |
| } |
| } |
| } |
| else{ |
| sClassName = getTypeString(_sClassName, _aTypeClass, true); |
| } |
| } |
| else if (_aTypeClass.getValue() == TypeClass.ENUM_value){ |
| sClassName = _sClassName; |
| } |
| else{ |
| sClassName = ""; |
| } |
| if (!sClassName.equals("")){ |
| sHeaderStatement = "import " + sClassName + ";\n"; |
| } |
| } |
| return sHeaderStatement; |
| } |
| |
| |
| public String getFinalHeaderStatements(){ |
| return ""; |
| } |
| |
| |
| public void assignqueryInterfaceHeaderSourceCode(){ |
| sHeaderStatements.add("import com.sun.star.uno.UnoRuntime;\n"); |
| sHeaderStatements.add("import com.sun.star.uno.XInterface;\n"); |
| if (bAddAnyConverter){ |
| sHeaderStatements.add("import com.sun.star.uno.AnyConverter;\n"); |
| } |
| } |
| |
| |
| |
| public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){ |
| boolean bLocAddAnyConverter = true; |
| String sReturn = ""; |
| switch (_aTypeClass.getValue()){ |
| case TypeClass.BOOLEAN_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toBoolean(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.CHAR_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toChar(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.BYTE_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toByte(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.DOUBLE_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toDouble(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.FLOAT_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toFloat(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.UNSIGNED_HYPER_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedLong(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.HYPER_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toLong(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.UNSIGNED_LONG_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedInt(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.LONG_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toInt(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.SHORT_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toShort(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.UNSIGNED_SHORT_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toUnsignedShort(" + _sObjectDescription + ")"; |
| break; |
| case TypeClass.STRING_value: |
| sReturn = _sReturnVariableName + " = AnyConverter.toString(" + _sObjectDescription + ")"; |
| break; |
| default: |
| String sShortTypeName = Introspector.getShortClassName(_sTypeName); |
| if (bIsPropertyUnoObjectDefined){ |
| sReturn = "oUnoObject = " + _sObjectDescription + ";\n\t"; |
| } |
| else{ |
| sReturn = "Object oUnoObject = " + _sObjectDescription + ";\n\t"; |
| bIsPropertyUnoObjectDefined = true; |
| } |
| sReturn += _sReturnVariableName + " = (" + sShortTypeName + ") AnyConverter.toObject(" + sShortTypeName + ".class, oUnoObject);"; |
| // this.bAddTypeImport = true; |
| break; |
| } |
| if (!bAddAnyConverter){ |
| bAddAnyConverter = bLocAddAnyConverter; |
| } |
| return sReturn; |
| } |
| |
| |
| public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){ |
| return "\t" + _sReturnVariableDescription + " = " + _sObjectDescription + "." + _sMember + ";"; |
| } |
| |
| public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){ |
| //TODO try to use + _oUnoNode.getClassName() instead of the hack |
| String sReturn = "public void codesnippet(XInterface " + _soReturnObjectDescription + "){"; |
| if (baddExceptionHandling){ |
| sReturn += "\ntry{"; |
| } |
| return sReturn; |
| } |
| |
| public String getMethodSeparator(){ |
| return "."; |
| } |
| |
| public boolean needsqueryInterface(){ |
| return true; |
| } |
| |
| public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){ |
| String sShortClassName = m_oIntrospector.getShortClassName(_sClassName); |
| return "\t" + _sReturnVariableName + " = (" + sShortClassName + ") UnoRuntime.queryInterface(" + sShortClassName + ".class, " + _sIncomingObjectName + ");\n"; |
| } |
| |
| |
| public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){ |
| String sObjectDescription = _sIncomingObjectName + ".getPropertyValue(\"" + _sPropertyName + "\")"; |
| String sReturn = getConvertedSourceCodeValueOfObject(_sReturnVariableName, sObjectDescription, _aTypeClass, _sTypeName); |
| sReturn += ";"; |
| sReturn = "\t" + sReturn; |
| return sReturn; |
| // return "\t" + _sReturnVariableName + " = " + _sIncomingObjectName + ".getPropertyValue(\"" + _sPropertyName + "\");"; |
| } |
| |
| |
| public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){ |
| String sReturn = ""; |
| if (_bAsHeader){ |
| sReturn = _sClassName; |
| } |
| else{ |
| sReturn = m_oIntrospector.getShortClassName(_sClassName); |
| } |
| return sReturn; |
| } |
| |
| |
| public String getMethodTerminationSourceCode(){ |
| String sReturn = ""; |
| int nIndex = 1; |
| String sExceptionName = "e"; |
| if (baddExceptionHandling){ |
| for (int i = 0; i < sExceptions.size(); i++){ |
| String sCurException = (String) sExceptions.get(i); |
| if (sReturn.indexOf(sCurException) == -1){ |
| if (nIndex > 1){ |
| sExceptionName = "e"+ nIndex; |
| } |
| else{ |
| sReturn +="\n}"; |
| } |
| sReturn += "catch (" + sCurException + " " + sExceptionName + "){\n"; |
| sReturn += "\t" + sExceptionName + ".printStackTrace(System.out);\n"; |
| sReturn += "\t" + getCommentSign() + "Enter your Code here...\n}"; |
| nIndex++; |
| } |
| } |
| } |
| sReturn += "\n}"; |
| return sReturn; |
| } |
| |
| public String castLiteral(String _sExpression, TypeClass _aTypeClass){ |
| String sReturn = ""; |
| switch (_aTypeClass.getValue()){ |
| case TypeClass.BOOLEAN_value: |
| sReturn = _sExpression; |
| break; |
| case TypeClass.BYTE_value: |
| sReturn = "(byte) " + _sExpression; |
| break; |
| case TypeClass.CHAR_value: |
| sReturn = "'" + _sExpression + "'"; |
| break; |
| case TypeClass.DOUBLE_value: |
| sReturn = "(double) " + _sExpression; |
| break; |
| case TypeClass.FLOAT_value: |
| sReturn = "(float) " + _sExpression; |
| break; |
| case TypeClass.UNSIGNED_SHORT_value: |
| case TypeClass.SHORT_value: |
| sReturn = "(short) " + _sExpression; |
| break; |
| case TypeClass.STRING_value: |
| sReturn = "\"" + _sExpression + "\""; |
| break; |
| case TypeClass.HYPER_value: |
| case TypeClass.UNSIGNED_HYPER_value: |
| sReturn = "(long) " + _sExpression; |
| break; |
| case TypeClass.LONG_value: |
| sReturn = _sExpression; |
| break; |
| case TypeClass.ENUM_value: |
| default: |
| sReturn = _sExpression; |
| System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'"); |
| } |
| return sReturn; |
| } |
| |
| |
| public String getbooleanTypeDescription(){ |
| return "boolean"; |
| } |
| |
| public String getbyteTypeDescription(){ |
| return "byte"; |
| } |
| |
| public String getshortTypeDescription(){ |
| return "short"; |
| } |
| |
| public String getunsignedshortTypeDescription(){ |
| return "short"; |
| } |
| |
| public String getlongTypeDescription(){ |
| return "int"; |
| } |
| |
| public String getunsignedlongTypeDescription(){ |
| return "int"; |
| } |
| |
| public String gethyperTypeDescription(){ |
| return "long"; |
| } |
| |
| public String getunsignedhyperTypeDescription(){ |
| return "long"; |
| } |
| |
| public String getfloatTypeDescription(){ |
| return "float"; |
| } |
| |
| public String getdoubleTypeDescription(){ |
| return "double"; |
| } |
| |
| public String getcharTypeDescription(){ |
| return "char"; |
| } |
| |
| public String getstringTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return ""; |
| } |
| else{ |
| return "String"; |
| } |
| } |
| |
| public String gettypeTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return "com.sun.star.uno.Type"; |
| } |
| else{ |
| return "Type"; |
| } |
| } |
| |
| public String getanyTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return ""; |
| } |
| else{ |
| return "Object"; |
| } |
| } |
| |
| |
| public String getStringValue(String _sValue){ |
| return _sValue; |
| } |
| |
| |
| public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean _bIsArray, TypeClass _aTypeClass, boolean _bInitialize){ |
| String sReturn = ""; |
| if (_bIsArray){ |
| sReturn = _sTypeString + "[] " + _sVariableName; |
| } |
| else{ |
| sReturn = _sTypeString + " " + _sVariableName; |
| } |
| return sReturn; |
| } |
| |
| |
| public String getArrayDeclaration(String _sVariableDeclaration){ |
| String sReturn = ""; |
| String[] sDeclarations = _sVariableDeclaration.split(" "); |
| for (int i = 0; i< sDeclarations.length;i++){ |
| sReturn += sDeclarations[i]; |
| if (i == 0){ |
| sReturn += "[]"; |
| } |
| if (i < (sDeclarations.length -1)){ |
| sReturn += " "; |
| } |
| } |
| return sReturn; |
| } |
| |
| public String getCommentSign(){ |
| return "//"; |
| } |
| } |
| |
| |
| public class BasicCodeGenerator implements XLanguageSourceCodeGenerator{ |
| String sStatementsCode = ""; |
| |
| public BasicCodeGenerator(){ |
| } |
| |
| public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){ |
| String sHeaderStatement = ""; |
| return sHeaderStatement; |
| } |
| |
| public String getFinalHeaderStatements(){ |
| return ""; |
| } |
| |
| public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){ |
| //TODO try to use + _oUnoNode.getClassName() instead of the hack |
| return "Sub Main(" + _soReturnObjectDescription + " as " + getanyTypeDescription(false) + ")"; |
| } |
| |
| public boolean needsqueryInterface(){ |
| return false; |
| } |
| |
| public void assignqueryInterfaceHeaderSourceCode(){ |
| } |
| |
| public String getMethodSeparator(){ |
| return "."; |
| } |
| |
| |
| public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){ |
| return _sIncomingObjectName; |
| } |
| |
| |
| public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){ |
| return "\t" + _sReturnVariableName + " = " + _sIncomingObjectName + "." + _sPropertyName; |
| } |
| |
| |
| public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){ |
| return getPropertyValueGetterSourceCode(_sMember, _sReturnVariableDescription, _sObjectDescription, null, "" ); |
| } |
| |
| public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){ |
| return _sReturnVariableName + " = " + _sObjectDescription; |
| } |
| |
| |
| public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){ |
| return "Object"; |
| } |
| |
| |
| public String getMethodTerminationSourceCode(){ |
| return "\nEnd Sub\n"; |
| } |
| |
| |
| public String castLiteral(String _sExpression, TypeClass _aTypeClass){ |
| String sReturn = ""; |
| switch (_aTypeClass.getValue()){ |
| case TypeClass.BOOLEAN_value: |
| case TypeClass.BYTE_value: |
| case TypeClass.DOUBLE_value: |
| case TypeClass.FLOAT_value: |
| case TypeClass.UNSIGNED_SHORT_value: |
| case TypeClass.SHORT_value: |
| case TypeClass.LONG_value: |
| case TypeClass.UNSIGNED_LONG_value: |
| case TypeClass.HYPER_value: |
| case TypeClass.UNSIGNED_HYPER_value: |
| sReturn = _sExpression; |
| break; |
| case TypeClass.CHAR_value: |
| case TypeClass.STRING_value: |
| sReturn = "\"" +_sExpression + "\""; |
| break; |
| case TypeClass.ENUM_value: |
| default: |
| sReturn = _sExpression; |
| System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'"); |
| } |
| return sReturn; |
| } |
| |
| |
| |
| public String getbooleanTypeDescription(){ |
| return "Boolean"; |
| } |
| |
| public String getbyteTypeDescription(){ |
| return "Integer"; |
| } |
| |
| public String getshortTypeDescription(){ |
| return "Integer"; |
| } |
| |
| public String getunsignedshortTypeDescription(){ |
| return "Integer"; |
| } |
| |
| public String getlongTypeDescription(){ |
| return "Integer"; |
| } |
| |
| public String getunsignedlongTypeDescription(){ |
| return "Long"; |
| } |
| |
| public String gethyperTypeDescription(){ |
| return "Long"; |
| } |
| |
| public String getunsignedhyperTypeDescription(){ |
| return "Long"; |
| } |
| |
| public String getfloatTypeDescription(){ |
| return "Double"; |
| } |
| |
| public String getdoubleTypeDescription(){ |
| return "Double"; |
| } |
| |
| public String getcharTypeDescription(){ |
| return "String"; |
| } |
| |
| public String getstringTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return ""; |
| } |
| else{ |
| return "String"; |
| } |
| } |
| |
| public String gettypeTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return ""; |
| } |
| else{ |
| return "Object"; |
| } |
| } |
| |
| public String getanyTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return ""; |
| } |
| else{ |
| return "Object"; |
| } |
| } |
| |
| public String getStatementTerminationCharacter(){ |
| return ""; |
| } |
| |
| |
| public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray, TypeClass _aTypeClass, boolean _bInitialize){ |
| String sReturn = ""; |
| if (bIsArray){ |
| sReturn = "Dim " + _sVariableName + "() as " + _sTypeString + "\n\t" + _sVariableName; |
| } |
| else{ |
| sReturn = "Dim " + _sVariableName + " as " + _sTypeString + "\n\t" + _sVariableName; |
| } |
| return sReturn; |
| } |
| |
| |
| public String getStringValue(String _sValue){ |
| return _sValue; |
| } |
| |
| |
| public String getArrayDeclaration(String _sVariableDeclaration){ |
| String sReturn = ""; |
| String[] sDeclarations = _sVariableDeclaration.split(" "); |
| for (int i = 0; i< sDeclarations.length;i++){ |
| sReturn += sDeclarations[i]; |
| if (i == 0){ |
| sReturn += "[]"; |
| } |
| if (i < (sDeclarations.length -1)){ |
| sReturn += " "; |
| } |
| } |
| return sReturn; |
| } |
| |
| public String getCommentSign(){ |
| return "'"; |
| } |
| |
| } |
| |
| public class CPlusPlusCodeGenerator implements XLanguageSourceCodeGenerator{ |
| String sStatementsCode = ""; |
| boolean bIncludeStringHeader = false; |
| boolean bIncludeAny = false; |
| boolean bIncludeSequenceHeader = false; |
| |
| public CPlusPlusCodeGenerator(){ |
| } |
| |
| private String getCSSNameSpaceString(){ |
| return "css"; |
| } |
| |
| public String getStatementTerminationCharacter(){ |
| return ";"; |
| } |
| |
| |
| public String getHeaderSourceCode(Object _oUnoObject, String _sClassName, TypeClass _aTypeClass){ |
| String sClassName = _sClassName; |
| String sHeaderStatement = ""; |
| if (_oUnoObject != null){ |
| if (!m_oIntrospector.isObjectPrimitive(_oUnoObject)){ |
| if (m_oIntrospector.isObjectSequence(_oUnoObject)){ |
| XTypeDescription xTypeDescription = m_oIntrospector.getReferencedType(sClassName); |
| if (xTypeDescription != null){ |
| if (!m_oIntrospector.isPrimitive(xTypeDescription.getTypeClass())){ |
| sClassName = getTypeString(xTypeDescription.getName(), xTypeDescription.getTypeClass(), true); |
| } |
| // primitive Types are not supposed to turn up in the import section... |
| else{ |
| sClassName = ""; |
| } |
| } |
| } |
| else{ |
| sClassName = getTypeString(_sClassName, _aTypeClass, true); |
| } |
| if (!sClassName.equals("")){ |
| sHeaderStatement = getHeaderOfClass(sClassName); |
| } |
| } |
| } |
| return sHeaderStatement; |
| } |
| |
| |
| |
| public String getFinalHeaderStatements(){ |
| String sReturn = ""; |
| sReturn += "\nnamespace " + getCSSNameSpaceString() + " = com::sun::star;\n"; |
| sReturn += "using namespace rtl;\n"; |
| return sReturn; |
| } |
| |
| |
| private String getHeaderOfClass(String _sClassName){ |
| return "#include \"" + _sClassName.replace('.', '/') + ".hpp\"\n"; // #include <com/sun/star/uno/XComponentContext.hpp> |
| } |
| |
| |
| |
| public void assignqueryInterfaceHeaderSourceCode(){ |
| sHeaderStatements.add("#include \"sal/config.h\"\n"); |
| sHeaderStatements.add("#include \"sal/types.h\"\n"); |
| if (bIncludeStringHeader){ |
| sHeaderStatements.add("#include \"rtl/ustring.hxx\"\n"); |
| } |
| sHeaderStatements.add("#include \"com/sun/star/uno/Reference.hxx\"\n"); |
| if (bIncludeSequenceHeader){ |
| sHeaderStatements.add("#include \"com/sun/star/uno/Sequence.hxx\"\n"); |
| } |
| sHeaderStatements.add(getHeaderOfClass("com.sun.star.uno.XInterface")); |
| if (bIncludeAny){ |
| sHeaderStatements.add(getHeaderOfClass("com.sun.star.uno.Any")); |
| } |
| } |
| |
| |
| public String getMainMethodSignatureSourceCode(XUnoNode _oUnoNode, String _soReturnObjectDescription){ |
| String sReturn = ""; |
| sReturn = "void codesnippet(const " + getCSSNameSpaceString() + "::uno::Reference<" + getCSSNameSpaceString() + "::uno::XInterface>& " + _soReturnObjectDescription + " ){"; |
| int a = 0; |
| if (!sExceptions.contains("com.sun.star.uno.RuntimeException")){ |
| sExceptions.add("com.sun.star.uno.RuntimeException"); |
| } |
| if (baddExceptionHandling){ |
| sReturn += "\n//throw "; |
| for (int i = 0; i < sExceptions.size(); i++){ |
| String sCurException = (String) sExceptions.get(i); |
| if (sReturn.indexOf(sCurException) == -1){ |
| if (a++ > 0){ |
| sReturn += ", "; |
| } |
| sReturn += getObjectTypeDescription(sCurException, false); |
| |
| } |
| } |
| |
| } |
| sReturn += "{"; |
| return sReturn; |
| } |
| |
| |
| public boolean needsqueryInterface(){ |
| return true; |
| } |
| |
| |
| public String getqueryInterfaceSourceCode(String _sClassName, String _sReturnVariableName, String _sIncomingObjectName){ |
| return "\t" + _sReturnVariableName + "( " + _sIncomingObjectName + ", " + getCSSNameSpaceString() + "::uno::UNO_QUERY_THROW);\n"; |
| } |
| |
| |
| public String getPropertyValueGetterSourceCode(String _sPropertyName, String _sReturnVariableName, String _sIncomingObjectName, TypeClass _aTypeClass, String _sTypeName){ |
| String sFirstLine = "\t"; |
| String sReturnVariableName = _sReturnVariableName; |
| // e.g. uno::Any a = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" )) ); |
| String[] sVarDefinition = _sReturnVariableName.split("="); |
| if (sVarDefinition.length > 0){ |
| String sVariable = sVarDefinition[0]; |
| String[] sVarDeclaration = sVariable.split(" "); |
| if (sVarDeclaration.length > 0){ |
| sFirstLine += sReturnVariableName + ";\n"; |
| sReturnVariableName = sVarDeclaration[sVarDeclaration.length-1]; |
| } |
| } |
| String sObjectDescription = _sIncomingObjectName + "->getPropertyValue(" + getStringValue(_sPropertyName) + ")"; |
| String sSecondLine = "\t" + getConvertedSourceCodeValueOfObject(sReturnVariableName, sObjectDescription, _aTypeClass, _sTypeName) + ";"; |
| return sFirstLine + sSecondLine; |
| } |
| |
| |
| public String getStructSourceCode(String _sReturnVariableDescription, String _sObjectDescription, String _sMember){ |
| return "\t" + _sReturnVariableDescription + " = " + _sObjectDescription + "->" + _sMember + ";"; |
| } |
| |
| |
| public String getConvertedSourceCodeValueOfObject(String _sReturnVariableName, String _sObjectDescription, TypeClass _aTypeClass, String _sTypeName){ |
| // if (m_oIntrospector.isPrimitive(_aTypeClass)){ |
| return _sObjectDescription + " >>= " + _sReturnVariableName; |
| // } |
| // else{ |
| // return _sReturnVariableName + " = " + _sObjectDescription; |
| // } |
| } |
| |
| |
| public String getStringValue(String _sValue){ |
| bIncludeStringHeader = true; |
| return "OUString(RTL_CONSTASCII_USTRINGPARAM(\"" + _sValue + "\"))"; |
| } |
| |
| |
| public String getObjectTypeDescription(String _sClassName, boolean _bAsHeader){ |
| String sReturn = ""; |
| if (_bAsHeader){ |
| sReturn = _sClassName.replace('.', '/'); |
| } |
| else{ |
| String sModuleName = m_oIntrospector.getModuleName(_sClassName); |
| sModuleName = m_oIntrospector.getShortClassName(sModuleName); |
| sReturn = getCSSNameSpaceString() + "::" + sModuleName + "::" + m_oIntrospector.getShortClassName(_sClassName); |
| } |
| return sReturn; |
| } |
| |
| |
| public String getMethodTerminationSourceCode(){ |
| return "\n}"; |
| } |
| |
| public String getMethodSeparator(){ |
| return "->"; |
| } |
| |
| |
| public String castLiteral(String _sExpression, TypeClass _aTypeClass){ |
| String sReturn = ""; |
| switch (_aTypeClass.getValue()){ |
| case TypeClass.BOOLEAN_value: |
| case TypeClass.BYTE_value: |
| case TypeClass.DOUBLE_value: |
| case TypeClass.FLOAT_value: |
| case TypeClass.UNSIGNED_SHORT_value: |
| case TypeClass.SHORT_value: |
| case TypeClass.LONG_value: |
| case TypeClass.UNSIGNED_LONG_value: |
| case TypeClass.HYPER_value: |
| case TypeClass.UNSIGNED_HYPER_value: |
| sReturn = _sExpression; |
| break; |
| case TypeClass.CHAR_value: |
| sReturn = "'" + _sExpression + "'"; |
| break; |
| case TypeClass.STRING_value: |
| sReturn = getStringValue(_sExpression); |
| break; |
| case TypeClass.ENUM_value: |
| default: |
| sReturn = _sExpression; |
| System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'castliteral()'"); |
| } |
| return sReturn; |
| } |
| |
| public String getbooleanTypeDescription(){ |
| return "sal_Bool"; |
| } |
| |
| public String getbyteTypeDescription(){ |
| return "sal_Int8"; |
| } |
| |
| public String getshortTypeDescription(){ |
| return "sal_Int16"; |
| } |
| |
| public String getunsignedshortTypeDescription(){ |
| return "sal_uInt16"; |
| } |
| |
| public String getlongTypeDescription(){ |
| return "sal_Int32"; |
| } |
| |
| public String getunsignedlongTypeDescription(){ |
| return "sal_uInt32"; |
| } |
| |
| public String gethyperTypeDescription(){ |
| return "sal_Int64"; |
| } |
| |
| public String getunsignedhyperTypeDescription(){ |
| return "sal_uInt64"; |
| } |
| |
| public String getfloatTypeDescription(){ |
| return "float"; |
| } |
| |
| public String getdoubleTypeDescription(){ |
| return "double"; |
| } |
| |
| public String getcharTypeDescription(){ |
| return "sal_Unicode"; |
| } |
| |
| public String getstringTypeDescription(boolean _bAsHeaderSourceCode){ |
| bIncludeStringHeader = true; |
| if (_bAsHeaderSourceCode){ |
| return ""; |
| } |
| else{ |
| return "OUString"; |
| } |
| } |
| |
| public String gettypeTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return "com/sun/star/uno/Type"; |
| } |
| else{ |
| return "Type"; |
| } |
| } |
| |
| public String getanyTypeDescription(boolean _bAsHeaderSourceCode){ |
| if (_bAsHeaderSourceCode){ |
| return "com/sun/star/uno/XInterface"; |
| } |
| else{ |
| return "XInterface"; |
| } |
| } |
| |
| |
| public String getVariableDeclaration(String _sTypeString, String _sVariableName, boolean bIsArray, TypeClass _aTypeClass, boolean _bInitialize){ |
| boolean bIsPrimitive = m_oIntrospector.isPrimitive(_aTypeClass); |
| |
| // uno::Reference< frame::XDispatch > m_xDispatch |
| String sReturn = ""; |
| if (bIsArray){ |
| bIncludeSequenceHeader = true; |
| sReturn = getCSSNameSpaceString() + "::uno::Sequence<" + _sTypeString + "> " + _sVariableName; |
| } |
| else{ |
| if (bIsPrimitive){ |
| sReturn = _sTypeString + " " + _sVariableName; |
| if (_bInitialize){ |
| switch (_aTypeClass.getValue()){ |
| case TypeClass.BOOLEAN_value: |
| sReturn = sReturn + " = false"; |
| break; |
| case TypeClass.BYTE_value: |
| case TypeClass.UNSIGNED_SHORT_value: |
| case TypeClass.SHORT_value: |
| case TypeClass.LONG_value: |
| case TypeClass.UNSIGNED_LONG_value: |
| case TypeClass.HYPER_value: |
| case TypeClass.UNSIGNED_HYPER_value: |
| sReturn = sReturn + " = 0"; |
| break; |
| case TypeClass.DOUBLE_value: |
| case TypeClass.FLOAT_value: |
| sReturn = sReturn + " = 0.0"; |
| break; |
| case TypeClass.CHAR_value: |
| sReturn = sReturn + "'0'"; |
| break; |
| case TypeClass.STRING_value: |
| sReturn = _sTypeString + " " + _sVariableName; |
| break; |
| default: |
| sReturn = _sTypeString + " " + _sVariableName; |
| System.out.println("Type " + _aTypeClass.getValue() + " not yet defined in 'getVariableDeclaration()'"); |
| } |
| } |
| } |
| else{ |
| sReturn = getCSSNameSpaceString() + "::uno::Reference<" + _sTypeString + "> " +_sVariableName; |
| } |
| } |
| return sReturn; |
| } |
| |
| public String getArrayDeclaration(String _sVariableDeclaration){ |
| this.bIncludeSequenceHeader = true; |
| String sReturn = ""; |
| String[] sDeclarations = _sVariableDeclaration.split(" "); |
| if (sDeclarations.length == 2){ |
| sReturn = getCSSNameSpaceString() +"::uno::Sequence<" + sDeclarations[1] + ">"; |
| } |
| return sReturn; |
| } |
| |
| public String getCommentSign(){ |
| return "//"; |
| } |
| |
| } |
| } |
