| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| #include <osl/interlck.h> | |
| #include <rtl/alloc.h> | |
| #include <codemaker/dependency.hxx> | |
| using namespace rtl; | |
| TypeDependency::TypeDependency() | |
| { | |
| m_pImpl = new TypeDependencyImpl(); | |
| acquire(); | |
| } | |
| TypeDependency::~TypeDependency() | |
| { | |
| release(); | |
| } | |
| void TypeDependency::acquire() | |
| { | |
| osl_incrementInterlockedCount(&m_pImpl->m_refCount); | |
| } | |
| void TypeDependency::release() | |
| { | |
| if (0 == osl_decrementInterlockedCount(&m_pImpl->m_refCount)) | |
| { | |
| delete m_pImpl; | |
| } | |
| } | |
| sal_Bool TypeDependency::insert(const OString& type, const OString& depend, sal_uInt16 use) | |
| { | |
| sal_Bool ret = sal_False; | |
| if (type.getLength() > 0 && depend.getLength() > 0) | |
| { | |
| if (m_pImpl->m_dependencies.count(type) > 0) | |
| { | |
| TypeUsing typeUsing(depend, use); | |
| TypeUsingSet::iterator iter; | |
| if ((iter = m_pImpl->m_dependencies[type].find(typeUsing)) != m_pImpl->m_dependencies[type].end()) | |
| { | |
| (((TypeUsing *) &(*iter))->m_use) = (*iter).m_use | use; | |
| } else | |
| { | |
| m_pImpl->m_dependencies[type].insert(typeUsing); | |
| } | |
| } else | |
| { | |
| TypeUsing typeUsing(depend, use); | |
| TypeUsingSet tmpSet; | |
| tmpSet.insert(typeUsing); | |
| m_pImpl->m_dependencies[type]=tmpSet; | |
| } | |
| } | |
| return ret; | |
| } | |
| TypeUsingSet TypeDependency::getDependencies(const OString& type) | |
| { | |
| if (type.getLength() > 0) | |
| { | |
| if (m_pImpl->m_dependencies.count(type) > 0) | |
| { | |
| return m_pImpl->m_dependencies[type]; | |
| } | |
| } | |
| return TypeUsingSet(); | |
| } | |
| sal_Bool TypeDependency::hasDependencies(const OString& type) | |
| { | |
| if (type.getLength() > 0) | |
| { | |
| if (m_pImpl->m_dependencies.count(type) > 0) | |
| { | |
| return sal_True; | |
| } | |
| } | |
| return sal_False; | |
| } | |
| void TypeDependency::setGenerated(const OString& type, sal_uInt16 genFlag) | |
| { | |
| // m_pImpl->m_generatedTypes.insert(type); | |
| if (m_pImpl->m_generatedTypes.count(type) > 0) | |
| m_pImpl->m_generatedTypes[type]= m_pImpl->m_generatedTypes[type] | genFlag; | |
| else | |
| m_pImpl->m_generatedTypes[type]=genFlag; | |
| } | |
| sal_Bool TypeDependency::isGenerated(const OString& type, sal_uInt16 genFlag) | |
| { | |
| /* | |
| if (m_pImpl->m_generatedTypes.count(type) > 0) | |
| return sal_True; | |
| return sal_False; | |
| */ | |
| if (m_pImpl->m_generatedTypes.count(type) > 0 && | |
| m_pImpl->m_generatedTypes[type] & genFlag) | |
| { | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| static sal_Bool checkFieldDependencies(TypeManager& typeMgr, TypeDependency& dependencies, | |
| TypeReader& reader, const OString& type) | |
| { | |
| sal_uInt32 count = reader.getFieldCount(); | |
| if (count == 0 || reader.getTypeClass() == RT_TYPE_ENUM) | |
| return sal_True; | |
| OString fieldType; | |
| for (sal_uInt16 i=0; i < count; i++) | |
| { | |
| fieldType = reader.getFieldType(i); | |
| if (fieldType.getLength() > 0) | |
| { | |
| dependencies.insert(type, fieldType, TYPEUSE_MEMBER); | |
| checkTypeDependencies(typeMgr, dependencies, fieldType); | |
| } | |
| } | |
| return sal_True; | |
| } | |
| static sal_Bool checkMethodDependencies(TypeManager& typeMgr, TypeDependency& dependencies, | |
| TypeReader& reader, const OString& type) | |
| { | |
| sal_uInt32 count = reader.getMethodCount(); | |
| if (count == 0) | |
| return sal_True; | |
| OString returnType, paramType, excType; | |
| sal_uInt32 paramCount = 0; | |
| sal_uInt32 excCount = 0; | |
| RTParamMode paramMode = RT_PARAM_INVALID; | |
| for (sal_uInt16 i=0; i < count; i++) | |
| { | |
| returnType = reader.getMethodReturnType(i); | |
| dependencies.insert(type, returnType, TYPEUSE_RETURN); | |
| checkTypeDependencies(typeMgr, dependencies, returnType); | |
| paramCount = reader.getMethodParamCount(i); | |
| excCount = reader.getMethodExcCount(i); | |
| sal_uInt16 j; | |
| for (j=0; j < paramCount; j++) | |
| { | |
| paramType = reader.getMethodParamType(i, j); | |
| paramMode = reader.getMethodParamMode(i, j); | |
| switch (paramMode) | |
| { | |
| case RT_PARAM_IN: | |
| dependencies.insert(type, paramType, TYPEUSE_INPARAM); | |
| break; | |
| case RT_PARAM_OUT: | |
| dependencies.insert(type, paramType, TYPEUSE_OUTPARAM); | |
| break; | |
| case RT_PARAM_INOUT: | |
| dependencies.insert(type, paramType, TYPEUSE_INOUTPARAM); | |
| break; | |
| default: | |
| break; | |
| } | |
| checkTypeDependencies(typeMgr, dependencies, paramType); | |
| } | |
| for (j=0; j < excCount; j++) | |
| { | |
| excType = reader.getMethodExcType(i, j); | |
| dependencies.insert(type, excType, TYPEUSE_EXCEPTION); | |
| checkTypeDependencies(typeMgr, dependencies, excType); | |
| } | |
| } | |
| return sal_True; | |
| } | |
| static sal_Bool checkReferenceDependencies(TypeManager& typeMgr, TypeDependency& dependencies, | |
| TypeReader& reader, const OString& type) | |
| { | |
| sal_uInt32 count = reader.getReferenceCount(); | |
| if (count == 0) | |
| return sal_True; | |
| OString referenceName; | |
| for (sal_uInt16 i=0; i < count; i++) | |
| { | |
| referenceName = reader.getReferenceName(i); | |
| dependencies.insert(type, referenceName, TYPEUSE_NORMAL); | |
| checkTypeDependencies(typeMgr, dependencies, referenceName); | |
| } | |
| return sal_True; | |
| } | |
| sal_Bool checkTypeDependencies(TypeManager& typeMgr, TypeDependency& dependencies, const OString& type, sal_Bool bDepend) | |
| { | |
| if (!typeMgr.isValidType(type)) | |
| return sal_False; | |
| if (dependencies.hasDependencies(type)) | |
| return sal_True; | |
| TypeReader reader = typeMgr.getTypeReader(type); | |
| if ( !reader.isValid() ) | |
| { | |
| if (type.equals("/")) | |
| return sal_True; | |
| else | |
| return sal_False; | |
| } | |
| if ( bDepend && reader.getTypeClass() == RT_TYPE_MODULE) | |
| { | |
| checkFieldDependencies(typeMgr, dependencies, reader, type); | |
| return sal_True; | |
| } | |
| for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) { | |
| OString superType(reader.getSuperTypeName(i)); | |
| dependencies.insert(type, superType, TYPEUSE_SUPER); | |
| checkTypeDependencies(typeMgr, dependencies, superType); | |
| } | |
| if (reader.getTypeClass() == RT_TYPE_INTERFACE) | |
| { | |
| dependencies.insert(type, "com/sun/star/uno/RuntimeException", TYPEUSE_EXCEPTION); | |
| dependencies.insert(type, "com/sun/star/uno/TypeClass", TYPEUSE_NORMAL); | |
| checkTypeDependencies(typeMgr, dependencies, "com/sun/star/uno/RuntimeException", bDepend); | |
| } | |
| checkFieldDependencies(typeMgr, dependencies, reader, type); | |
| checkMethodDependencies(typeMgr, dependencies, reader, type); | |
| checkReferenceDependencies(typeMgr, dependencies, reader, type); | |
| // make the scope modules as dependencies | |
| sal_Int32 nPos = type.lastIndexOf( '/' ); | |
| if ( nPos >= 0 ) | |
| { | |
| OString aScope( type.copy( 0, nPos ) ); | |
| OStringBuffer tmpBuf(aScope.getLength()); | |
| nPos = 0; | |
| do | |
| { | |
| tmpBuf.append(aScope.getToken(0, '/', nPos)); | |
| dependencies.insert(type, tmpBuf.getStr(), TYPEUSE_SCOPE); | |
| tmpBuf.append('/'); | |
| } while( nPos != -1 ); | |
| } | |
| return sal_True; | |
| } |