rdbmaker/source/codemaker/dependency.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: dependency.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <osl/interlck.h>
  32 #include        <rtl/alloc.h>
  33 #include        <codemaker/dependency.hxx>
  34
  35 using namespace rtl;
  36
  37 TypeDependency::TypeDependency()
  38 {
  39     m_pImpl = new TypeDependencyImpl();
  40     acquire();
  41 }
  42
  43 TypeDependency::~TypeDependency()
  44 {
  45     release();
  46 }
  47
  48 void TypeDependency::acquire()
  49 {
  50     osl_incrementInterlockedCount(&m_pImpl->m_refCount);
  51 }
  52
  53 void TypeDependency::release()
  54 {
  55     if (0 == osl_decrementInterlockedCount(&m_pImpl->m_refCount))
  56     {
  57         delete m_pImpl;
  58     }
  59 }
  60
  61 sal_Bool TypeDependency::insert(const OString& type, const OString& depend, sal_uInt16 use)
  62 {
  63     sal_Bool ret =  sal_False;
  64
  65     if (type.getLength() > 0 && depend.getLength() > 0)
  66     {
  67         if (m_pImpl->m_dependencies.count(type) > 0)
  68         {
  69             TypeUsing typeUsing(depend, use);
  70             TypeUsingSet::iterator iter;
  71             if ((iter = m_pImpl->m_dependencies[type].find(typeUsing)) != m_pImpl->m_dependencies[type].end())
  72             {
  73                   (((TypeUsing *) &(*iter))->m_use) = (*iter).m_use | use;
  74             } else
  75             {
  76                 m_pImpl->m_dependencies[type].insert(typeUsing);
  77             }
  78         } else
  79         {
  80             TypeUsing typeUsing(depend, use);
  81             TypeUsingSet tmpSet;
  82             tmpSet.insert(typeUsing);
  83             m_pImpl->m_dependencies[type]=tmpSet;
  84         }
  85     }
  86
  87     return ret;
  88 }
  89
  90 TypeUsingSet TypeDependency::getDependencies(const OString& type)
  91 {
  92     if (type.getLength() > 0)
  93     {
  94         if (m_pImpl->m_dependencies.count(type) > 0)
  95         {
  96             return m_pImpl->m_dependencies[type];
  97         }
  98     }
  99
 100     return TypeUsingSet();
 101 }
 102
 103 sal_Bool TypeDependency::hasDependencies(const OString& type)
 104 {
 105     if (type.getLength() > 0)
 106     {
 107         if (m_pImpl->m_dependencies.count(type) > 0)
 108         {
 109             return sal_True;
 110         }
 111     }
 112
 113     return sal_False;
 114 }
 115
 116 void TypeDependency::setGenerated(const OString& type, sal_uInt16 genFlag)
 117 {
 118 //      m_pImpl->m_generatedTypes.insert(type);
 119     if (m_pImpl->m_generatedTypes.count(type) > 0)
 120         m_pImpl->m_generatedTypes[type]= m_pImpl->m_generatedTypes[type] | genFlag;
 121     else
 122         m_pImpl->m_generatedTypes[type]=genFlag;
 123 }
 124
 125 sal_Bool TypeDependency::isGenerated(const OString& type, sal_uInt16 genFlag)
 126 {
 127 /*
 128     if (m_pImpl->m_generatedTypes.count(type) > 0)
 129         return sal_True;
 130
 131     return sal_False;
 132 */
 133     if (m_pImpl->m_generatedTypes.count(type) > 0 &&
 134         m_pImpl->m_generatedTypes[type] & genFlag)
 135     {
 136         return sal_True;
 137     }
 138
 139     return sal_False;
 140 }
 141
 142 static sal_Bool checkFieldDependencies(TypeManager& typeMgr, TypeDependency& dependencies,
 143                                        TypeReader& reader, const OString& type)
 144 {
 145     sal_uInt32 count = reader.getFieldCount();
 146
 147     if (count == 0 || reader.getTypeClass() == RT_TYPE_ENUM)
 148         return sal_True;
 149
 150     OString fieldType;
 151     for (sal_uInt16 i=0; i < count; i++)
 152     {
 153         fieldType = reader.getFieldType(i);
 154
 155         if (fieldType.getLength() > 0)
 156         {
 157             dependencies.insert(type, fieldType, TYPEUSE_MEMBER);
 158             checkTypeDependencies(typeMgr, dependencies, fieldType);
 159         }
 160     }
 161
 162     return sal_True;
 163 }
 164
 165 static sal_Bool checkMethodDependencies(TypeManager& typeMgr, TypeDependency& dependencies,
 166                                         TypeReader& reader, const OString& type)
 167 {
 168     sal_uInt32 count = reader.getMethodCount();
 169
 170     if (count == 0)
 171         return sal_True;
 172
 173     OString returnType, paramType, excType;
 174     sal_uInt32 paramCount = 0;
 175     sal_uInt32 excCount = 0;
 176     RTParamMode paramMode = RT_PARAM_INVALID;
 177     for (sal_uInt16 i=0; i < count; i++)
 178     {
 179         returnType = reader.getMethodReturnType(i);
 180
 181         dependencies.insert(type, returnType, TYPEUSE_RETURN);
 182         checkTypeDependencies(typeMgr, dependencies, returnType);
 183
 184         paramCount = reader.getMethodParamCount(i);
 185         excCount = reader.getMethodExcCount(i);
 186
 187         sal_uInt16 j;
 188         for (j=0; j < paramCount; j++)
 189         {
 190             paramType = reader.getMethodParamType(i, j);
 191             paramMode = reader.getMethodParamMode(i, j);
 192
 193             switch (paramMode)
 194             {
 195                 case RT_PARAM_IN:
 196                     dependencies.insert(type, paramType, TYPEUSE_INPARAM);
 197                     break;
 198                 case RT_PARAM_OUT:
 199                     dependencies.insert(type, paramType, TYPEUSE_OUTPARAM);
 200                     break;
 201                 case RT_PARAM_INOUT:
 202                     dependencies.insert(type, paramType, TYPEUSE_INOUTPARAM);
 203                     break;
 204                 default:
 205                     break;
 206             }
 207
 208             checkTypeDependencies(typeMgr, dependencies, paramType);
 209         }
 210
 211         for (j=0; j < excCount; j++)
 212         {
 213             excType = reader.getMethodExcType(i, j);
 214             dependencies.insert(type, excType, TYPEUSE_EXCEPTION);
 215             checkTypeDependencies(typeMgr, dependencies, excType);
 216         }
 217
 218     }
 219
 220     return sal_True;
 221 }
 222
 223 static sal_Bool checkReferenceDependencies(TypeManager& typeMgr, TypeDependency& dependencies,
 224                                            TypeReader& reader, const OString& type)
 225 {
 226     sal_uInt32 count = reader.getReferenceCount();
 227
 228     if (count == 0)
 229         return sal_True;
 230
 231     OString referenceName;
 232     for (sal_uInt16 i=0; i < count; i++)
 233     {
 234         referenceName = reader.getReferenceName(i);
 235
 236         dependencies.insert(type, referenceName, TYPEUSE_NORMAL);
 237         checkTypeDependencies(typeMgr, dependencies, referenceName);
 238     }
 239
 240     return sal_True;
 241 }
 242
 243 sal_Bool checkTypeDependencies(TypeManager& typeMgr, TypeDependency& dependencies, const OString& type, sal_Bool bDepend)
 244 {
 245     if (!typeMgr.isValidType(type))
 246         return sal_False;
 247
 248     if (dependencies.hasDependencies(type))
 249         return sal_True;
 250
 251     TypeReader reader = typeMgr.getTypeReader(type);
 252
 253     if ( !reader.isValid() )
 254     {
 255         if (type.equals("/"))
 256             return sal_True;
 257         else
 258             return sal_False;
 259     }
 260
 261     if ( bDepend && reader.getTypeClass() == RT_TYPE_MODULE)
 262     {
 263         checkFieldDependencies(typeMgr, dependencies, reader, type);
 264         return sal_True;
 265     }
 266
 267     for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) {
 268         OString superType(reader.getSuperTypeName(i));
 269         dependencies.insert(type, superType, TYPEUSE_SUPER);
 270         checkTypeDependencies(typeMgr, dependencies, superType);
 271     }
 272
 273     if (reader.getTypeClass() == RT_TYPE_INTERFACE)
 274     {
 275         dependencies.insert(type, "com/sun/star/uno/RuntimeException", TYPEUSE_EXCEPTION);
 276         dependencies.insert(type, "com/sun/star/uno/TypeClass", TYPEUSE_NORMAL);
 277         checkTypeDependencies(typeMgr, dependencies, "com/sun/star/uno/RuntimeException", bDepend);
 278     }
 279
 280     checkFieldDependencies(typeMgr, dependencies, reader, type);
 281     checkMethodDependencies(typeMgr, dependencies, reader, type);
 282     checkReferenceDependencies(typeMgr, dependencies, reader, type);
 283
 284     // make the scope modules as dependencies
 285     sal_Int32 nPos = type.lastIndexOf( '/' );
 286
 287     if ( nPos >= 0 )
 288     {
 289         OString aScope( type.copy( 0, nPos ) );
 290         OStringBuffer tmpBuf(aScope.getLength());
 291
 292         nPos = 0;
 293         do
 294         {
 295             tmpBuf.append(aScope.getToken(0, '/', nPos));
 296             dependencies.insert(type, tmpBuf.getStr(), TYPEUSE_SCOPE);
 297             tmpBuf.append('/');
 298         } while( nPos != -1 );
 299     }
 300
 301     return sal_True;
 302 }
 303
 304