tdf#123936 Formatting files in module idl with clang-format

Change-Id: I0a2681218773288c14b6faf98dd0bb8a7dbac56d Reviewed-on: https://gerrit.libreoffice.org/c/core/+/105679 Tested-by: Jenkins Reviewed-by: Christian Lohmaier <lohmaier+LibreOffice@googlemail.com>
2020-11-12 13:00:40 +01:00
parent 7721e7a797
commit 9c9a822920
15 changed files with 107 additions and 120 deletions
--- a/idl/source/objects/module.cxx
+++ b/idl/source/objects/module.cxx
@@ -22,17 +22,14 @@
 #include <database.hxx>
 #include <osl/file.hxx>

+SvMetaModule::SvMetaModule() {}

-SvMetaModule::SvMetaModule()
+void SvMetaModule::WriteSfx(SvIdlDataBase& rBase, SvStream& rOutStm)
 {
-}
-
-void SvMetaModule::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
-{
-    for( sal_uLong n = 0; n < aClassList.size(); n++ )
+    for (sal_uLong n = 0; n < aClassList.size(); n++)
    {
-        SvMetaClass * pClass = aClassList[n];
-        pClass->WriteSfx( rBase, rOutStm );
+        SvMetaClass* pClass = aClassList[n];
+        pClass->WriteSfx(rBase, rOutStm);
    }
 }

--- a/idlc/inc/astconstants.hxx
+++ b/idlc/inc/astconstants.hxx
@@ -26,7 +26,8 @@ class AstConstants final : public AstModule
 public:
    AstConstants(const OString& name, AstScope* pScope)
        : AstModule(NT_constants, name, pScope)
-    {}
+    {
+    }
 };

 #endif // INCLUDED_IDLC_INC_ASTCONSTANTS_HXX
--- a/idlc/inc/astenum.hxx
+++ b/idlc/inc/astenum.hxx
@@ -23,23 +23,21 @@
 #include "astscope.hxx"
 #include "astconstant.hxx"

-class AstEnum final : public AstType
-              , public AstScope
+class AstEnum final : public AstType, public AstScope
 {
 public:
    AstEnum(const OString& name, AstScope* pScope);

    virtual ~AstEnum() override;

-    sal_Int32 getEnumValueCount()
-        { return m_enumValueCount++; }
+    sal_Int32 getEnumValueCount() { return m_enumValueCount++; }

    AstConstant* checkValue(AstExpression* pExpr);

    virtual bool dump(RegistryKey& rKey) override;

 private:
-    sal_Int32   m_enumValueCount;
+    sal_Int32 m_enumValueCount;
 };

 #endif // INCLUDED_IDLC_INC_ASTENUM_HXX
--- a/idlc/inc/astexception.hxx
+++ b/idlc/inc/astexception.hxx
@@ -24,9 +24,10 @@
 class AstException final : public AstStruct
 {
 public:
-    AstException(const OString& name, AstException const * pBaseType, AstScope* pScope)
+    AstException(const OString& name, AstException const* pBaseType, AstScope* pScope)
        : AstStruct(NT_exception, name, pBaseType, pScope)
-        {}
+    {
+    }
 };

 #endif // INCLUDED_IDLC_INC_ASTEXCEPTION_HXX
--- a/idlc/inc/astmodule.hxx
+++ b/idlc/inc/astmodule.hxx
@@ -22,18 +22,19 @@
 #include "astdeclaration.hxx"
 #include "astscope.hxx"

-class AstModule : public AstDeclaration
-                , public AstScope
+class AstModule : public AstDeclaration, public AstScope
 {
 public:
    AstModule(const OString& name, AstScope* pScope)
        : AstDeclaration(NT_module, name, pScope)
        , AstScope(NT_module)
-    {}
+    {
+    }
    AstModule(NodeType type, const OString& name, AstScope* pScope)
        : AstDeclaration(type, name, pScope)
        , AstScope(type)
-    {}
+    {
+    }

    virtual bool dump(RegistryKey& rKey) override;
 };
--- a/idlc/inc/astneeds.hxx
+++ b/idlc/inc/astneeds.hxx
@@ -27,10 +27,11 @@ public:
    AstNeeds(AstService* pRealService, const OString& name, AstScope* pScope)
        : AstDeclaration(NT_needs, name, pScope)
        , m_pRealService(pRealService)
-        {}
+    {
+    }
+
+    AstService* getRealService() { return m_pRealService; }

-    AstService* getRealService()
-        { return m_pRealService; }
 private:
    AstService* m_pRealService;
 };
--- a/idlc/inc/astobserves.hxx
+++ b/idlc/inc/astobserves.hxx
@@ -27,12 +27,13 @@ public:
    AstObserves(AstInterface* pRealInterface, const OString& name, AstScope* pScope)
        : AstDeclaration(NT_observes, name, pScope)
        , m_pRealInterface(pRealInterface)
-        {}
+    {
+    }
+
+    AstInterface* getRealInterface() { return m_pRealInterface; }

-    AstInterface* getRealInterface()
-        { return m_pRealInterface; }
 private:
-    AstInterface*   m_pRealInterface;
+    AstInterface* m_pRealInterface;
 };

 #endif // INCLUDED_IDLC_INC_ASTOBSERVES_HXX
--- a/idlc/inc/astscope.hxx
+++ b/idlc/inc/astscope.hxx
@@ -31,17 +31,13 @@ public:
    AstScope(NodeType nodeType);
    virtual ~AstScope();

-    NodeType getScopeNodeType() const
-        { return m_nodeType; }
+    NodeType getScopeNodeType() const { return m_nodeType; }

    AstDeclaration* addDeclaration(AstDeclaration* pDecl);

-    sal_uInt32 nMembers() const
-        { return static_cast<sal_uInt32>(m_declarations.size()); }
-    DeclList::const_iterator getIteratorBegin() const
-        { return m_declarations.begin(); }
-    DeclList::const_iterator getIteratorEnd() const
-        { return m_declarations.end(); }
+    sal_uInt32 nMembers() const { return static_cast<sal_uInt32>(m_declarations.size()); }
+    DeclList::const_iterator getIteratorBegin() const { return m_declarations.begin(); }
+    DeclList::const_iterator getIteratorEnd() const { return m_declarations.end(); }
    sal_uInt16 getNodeCount(NodeType nType) const;

    // Name look up mechanism
@@ -54,15 +50,14 @@ public:
    // Look up a predefined type by its ExprType
    AstDeclaration* lookupPrimitiveType(ExprType type);

-    AstDeclaration* lookupForAdd(AstDeclaration const * pDecl) const;
+    AstDeclaration* lookupForAdd(AstDeclaration const* pDecl) const;

 protected:
-    AstDeclaration const * getLast() const
-    { return m_declarations.back(); }
+    AstDeclaration const* getLast() const { return m_declarations.back(); }

 private:
-    DeclList    m_declarations;
-    NodeType    m_nodeType;
+    DeclList m_declarations;
+    NodeType m_nodeType;
 };

 #endif // INCLUDED_IDLC_INC_ASTSCOPE_HXX
--- a/idlc/inc/astsequence.hxx
+++ b/idlc/inc/astsequence.hxx
@@ -24,20 +24,23 @@
 class AstSequence final : public AstType
 {
 public:
-    AstSequence(AstType const * pMemberType, AstScope* pScope)
-        : AstType(NT_sequence, OStringLiteral("[]")+pMemberType->getScopedName(), pScope)
+    AstSequence(AstType const* pMemberType, AstScope* pScope)
+        : AstType(NT_sequence, OStringLiteral("[]") + pMemberType->getScopedName(), pScope)
        , m_pMemberType(pMemberType)
-    {}
+    {
+    }

-    AstType const * getMemberType() const
-        { return m_pMemberType; }
+    AstType const* getMemberType() const { return m_pMemberType; }

    virtual bool isUnsigned() const override
-    { return m_pMemberType != nullptr && m_pMemberType->isUnsigned(); }
+    {
+        return m_pMemberType != nullptr && m_pMemberType->isUnsigned();
+    }

    virtual const char* getRelativName() const override;
+
 private:
-    AstType const * m_pMemberType;
+    AstType const* m_pMemberType;
    mutable std::optional<OString> m_xRelativName;
 };

--- a/idlc/inc/aststack.hxx
+++ b/idlc/inc/aststack.hxx
@@ -30,7 +30,7 @@ public:
    AstStack();
    ~AstStack();

-    sal_uInt32 depth() const { return m_stack.size();}
+    sal_uInt32 depth() const { return m_stack.size(); }
    AstScope* top();
    AstScope* bottom();
    AstScope* nextToTop();
@@ -40,7 +40,7 @@ public:
    void clear();

 private:
-    std::vector<AstScope*>  m_stack;
+    std::vector<AstScope*> m_stack;
 };

 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
--- a/idlc/inc/asttype.hxx
+++ b/idlc/inc/asttype.hxx
@@ -26,7 +26,8 @@ class AstType : public AstDeclaration
 public:
    AstType(const NodeType type, const OString& name, AstScope* pScope)
        : AstDeclaration(type, name, pScope)
-        {}
+    {
+    }

    virtual bool isUnsigned() const { return false; }
 };
--- a/idlc/source/astexpression.cxx
+++ b/idlc/source/astexpression.cxx
@@ -17,7 +17,6 @@
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

-
 #include <astexpression.hxx>
 #include <astconstant.hxx>
 #include <astscope.hxx>
@@ -30,7 +29,7 @@
 #include <float.h>
 #include <memory>

-AstExpression::AstExpression(ExprComb c, AstExpression *pExpr1, AstExpression *pExpr2)
+AstExpression::AstExpression(ExprComb c, AstExpression* pExpr1, AstExpression* pExpr2)
    : m_combOperator(c)
    , m_subExpr1(pExpr1)
    , m_subExpr2(pExpr2)
@@ -40,23 +39,23 @@ AstExpression::AstExpression(ExprComb c, AstExpression *pExpr1, AstExpression *p
 AstExpression::AstExpression(sal_Int32 l)
    : m_combOperator(ExprComb::NONE)
 {
-    m_exprValue.reset( new AstExprValue );
+    m_exprValue.reset(new AstExprValue);
    m_exprValue->et = ET_long;
    m_exprValue->u.lval = l;
 }

-AstExpression::AstExpression(sal_Int32  l, ExprType et)
+AstExpression::AstExpression(sal_Int32 l, ExprType et)
    : m_combOperator(ExprComb::NONE)
 {
-    m_exprValue.reset( new AstExprValue );
+    m_exprValue.reset(new AstExprValue);
    m_exprValue->et = et;
    m_exprValue->u.lval = l;
 }

-AstExpression::AstExpression(sal_Int64  h)
+AstExpression::AstExpression(sal_Int64 h)
    : m_combOperator(ExprComb::NONE)
 {
-    m_exprValue.reset( new AstExprValue );
+    m_exprValue.reset(new AstExprValue);
    m_exprValue->et = ET_hyper;
    m_exprValue->u.hval = h;
 }
@@ -64,7 +63,7 @@ AstExpression::AstExpression(sal_Int64  h)
 AstExpression::AstExpression(sal_uInt64 uh)
    : m_combOperator(ExprComb::NONE)
 {
-    m_exprValue.reset( new AstExprValue );
+    m_exprValue.reset(new AstExprValue);
    m_exprValue->et = ET_uhyper;
    m_exprValue->u.uhval = uh;
 }
@@ -72,7 +71,7 @@ AstExpression::AstExpression(sal_uInt64 uh)
 AstExpression::AstExpression(double d)
    : m_combOperator(ExprComb::NONE)
 {
-    m_exprValue.reset( new AstExprValue );
+    m_exprValue.reset(new AstExprValue);
    m_exprValue->et = ET_double;
    m_exprValue->u.dval = d;
 }
@@ -84,17 +83,14 @@ AstExpression::AstExpression(OString* scopedName)
        m_xSymbolicName = *scopedName;
 }

-AstExpression::~AstExpression()
-{
-}
+AstExpression::~AstExpression() {}

 /*
 * Perform the coercion from the given AstExprValue to the requested
 * ExprType. Return an AstExprValue if successful, NULL if failed.
 * must be done for hyper, uhyper
 */
-static bool
-coerce_value(AstExprValue *ev, ExprType t)
+static bool coerce_value(AstExprValue* ev, ExprType t)
 {
    if (ev == nullptr)
        return false;
@@ -735,7 +731,8 @@ coerce_value(AstExprValue *ev, ExprType t)
                    return true;
                case ET_double:
                {
-                    if (static_cast<float>(ev->u.dval) > FLT_MAX || static_cast<float>(ev->u.dval) < -FLT_MAX)
+                    if (static_cast<float>(ev->u.dval) > FLT_MAX
+                        || static_cast<float>(ev->u.dval) < -FLT_MAX)
                        return false;
                    auto tmp = static_cast<float>(ev->u.dval);
                    ev->u.fval = tmp;
@@ -944,7 +941,7 @@ bool AstExpression::coerce(ExprType t)
    return m_exprValue != nullptr;
 }

-bool AstExpression::compareLong(AstExpression *pExpr)
+bool AstExpression::compareLong(AstExpression* pExpr)
 {
    bool bRet = false;
    if (m_combOperator != pExpr->m_combOperator)
@@ -973,7 +970,7 @@ void AstExpression::evaluate()
    /*
     * Already evaluated?
     */
-    if ( m_exprValue != nullptr )
+    if (m_exprValue != nullptr)
        return;
    /*
     * OK, must evaluate operator
@@ -1010,7 +1007,7 @@ std::unique_ptr<AstExprValue> AstExpression::eval_bin_op()
 {
    ExprType eType = ET_double;

-    if ( m_combOperator == ExprComb::Mod )
+    if (m_combOperator == ExprComb::Mod)
        eType = ET_hyper;

    if (m_subExpr1 == nullptr || m_subExpr2 == nullptr)
@@ -1026,7 +1023,7 @@ std::unique_ptr<AstExprValue> AstExpression::eval_bin_op()
    if (!m_subExpr2->coerce(eType))
        return nullptr;

-    std::unique_ptr< AstExprValue > retval(new AstExprValue);
+    std::unique_ptr<AstExprValue> retval(new AstExprValue);
    retval->et = eType;

    switch (m_combOperator)
@@ -1034,21 +1031,26 @@ std::unique_ptr<AstExprValue> AstExpression::eval_bin_op()
        case ExprComb::Mod:
            if (m_subExpr2->getExprValue()->u.hval == 0)
                return nullptr;
-            retval->u.hval = m_subExpr1->getExprValue()->u.hval % m_subExpr2->getExprValue()->u.hval;
+            retval->u.hval
+                = m_subExpr1->getExprValue()->u.hval % m_subExpr2->getExprValue()->u.hval;
            break;
        case ExprComb::Add:
-            retval->u.dval = m_subExpr1->getExprValue()->u.dval + m_subExpr2->getExprValue()->u.dval;
+            retval->u.dval
+                = m_subExpr1->getExprValue()->u.dval + m_subExpr2->getExprValue()->u.dval;
            break;
        case ExprComb::Minus:
-            retval->u.dval = m_subExpr1->getExprValue()->u.dval - m_subExpr2->getExprValue()->u.dval;
+            retval->u.dval
+                = m_subExpr1->getExprValue()->u.dval - m_subExpr2->getExprValue()->u.dval;
            break;
        case ExprComb::Mul:
-            retval->u.dval = m_subExpr1->getExprValue()->u.dval * m_subExpr2->getExprValue()->u.dval;
+            retval->u.dval
+                = m_subExpr1->getExprValue()->u.dval * m_subExpr2->getExprValue()->u.dval;
            break;
        case ExprComb::Div:
            if (m_subExpr2->getExprValue()->u.dval == 0.0)
                return nullptr;
-            retval->u.dval = m_subExpr1->getExprValue()->u.dval / m_subExpr2->getExprValue()->u.dval;
+            retval->u.dval
+                = m_subExpr1->getExprValue()->u.dval / m_subExpr2->getExprValue()->u.dval;
            break;
        default:
            return nullptr;
@@ -1072,25 +1074,30 @@ std::unique_ptr<AstExprValue> AstExpression::eval_bit_op()
    if (!m_subExpr2->coerce(ET_long))
        return nullptr;

-    std::unique_ptr< AstExprValue > retval(new AstExprValue);
+    std::unique_ptr<AstExprValue> retval(new AstExprValue);
    retval->et = ET_long;

    switch (m_combOperator)
    {
        case ExprComb::Or:
-            retval->u.lval = m_subExpr1->getExprValue()->u.lval | m_subExpr2->getExprValue()->u.lval;
+            retval->u.lval
+                = m_subExpr1->getExprValue()->u.lval | m_subExpr2->getExprValue()->u.lval;
            break;
        case ExprComb::Xor:
-            retval->u.lval = m_subExpr1->getExprValue()->u.lval ^ m_subExpr2->getExprValue()->u.lval;
+            retval->u.lval
+                = m_subExpr1->getExprValue()->u.lval ^ m_subExpr2->getExprValue()->u.lval;
            break;
        case ExprComb::And:
-            retval->u.lval = m_subExpr1->getExprValue()->u.lval & m_subExpr2->getExprValue()->u.lval;
+            retval->u.lval
+                = m_subExpr1->getExprValue()->u.lval & m_subExpr2->getExprValue()->u.lval;
            break;
        case ExprComb::Left:
-            retval->u.lval = m_subExpr1->getExprValue()->u.lval << m_subExpr2->getExprValue()->u.lval;
+            retval->u.lval = m_subExpr1->getExprValue()->u.lval
+                             << m_subExpr2->getExprValue()->u.lval;
            break;
        case ExprComb::Right:
-            retval->u.lval = m_subExpr1->getExprValue()->u.lval >> m_subExpr2->getExprValue()->u.lval;
+            retval->u.lval
+                = m_subExpr1->getExprValue()->u.lval >> m_subExpr2->getExprValue()->u.lval;
            break;
        default:
            return nullptr;
@@ -1109,7 +1116,7 @@ std::unique_ptr<AstExprValue> AstExpression::eval_un_op()
    if (!m_subExpr1->coerce(ET_double))
        return nullptr;

-    std::unique_ptr< AstExprValue > retval(new AstExprValue);
+    std::unique_ptr<AstExprValue> retval(new AstExprValue);
    retval->et = ET_double;

    switch (m_combOperator)
@@ -1129,9 +1136,9 @@ std::unique_ptr<AstExprValue> AstExpression::eval_un_op()

 std::unique_ptr<AstExprValue> AstExpression::eval_symbol()
 {
-    AstScope        *pScope = nullptr;
-    AstDeclaration  *pDecl;
-    AstConstant     *pConst;
+    AstScope* pScope = nullptr;
+    AstDeclaration* pDecl;
+    AstConstant* pConst;

    /*
     * Is there a symbol stored?
@@ -1146,7 +1153,7 @@ std::unique_ptr<AstExprValue> AstExpression::eval_symbol()
     */
    if (idlc()->scopes()->depth() > 0)
        pScope = idlc()->scopes()->topNonNull();
-    if ( !pScope )
+    if (!pScope)
    {
        ErrorHandler::lookupError(*m_xSymbolicName);
        return nullptr;
@@ -1163,8 +1170,7 @@ std::unique_ptr<AstExprValue> AstExpression::eval_symbol()
    /*
     * Is it a constant?
     */
-    if (pDecl->getNodeType() != NT_const &&
-        pDecl->getNodeType() != NT_enum_val)
+    if (pDecl->getNodeType() != NT_const && pDecl->getNodeType() != NT_enum_val)
    {
        ErrorHandler::constantExpected(pDecl, *m_xSymbolicName);
        return nullptr;
@@ -1176,7 +1182,7 @@ std::unique_ptr<AstExprValue> AstExpression::eval_symbol()
    /*
     * OK, now evaluate the constant we just got, to produce its value
     */
-    pConst = static_cast< AstConstant* >(pDecl);
+    pConst = static_cast<AstConstant*>(pDecl);
    pConst->getConstValue()->evaluate();
    auto const val = pConst->getConstValue()->getExprValue();
    return val == nullptr ? nullptr : std::make_unique<AstExprValue>(*val);
@@ -1185,10 +1191,10 @@ std::unique_ptr<AstExprValue> AstExpression::eval_symbol()
 OString AstExpression::toString()
 {
    OString exprStr;
-    if ( m_combOperator == ExprComb::Symbol )
+    if (m_combOperator == ExprComb::Symbol)
        return m_xSymbolicName ? *m_xSymbolicName : OString("<Undefined Name>");

-    if ( m_exprValue )
+    if (m_exprValue)
    {
        switch (m_exprValue->et)
        {
@@ -1211,7 +1217,7 @@ OString AstExpression::toString()
            case ET_byte:
                return OString::number(m_exprValue->u.byval);
            case ET_boolean:
-                if ( m_exprValue->u.lval == 0)
+                if (m_exprValue->u.lval == 0)
                    return "FALSE";
                else
                    return "TRUE";
@@ -1232,7 +1238,7 @@ OString AstExpression::toString()
        default:
            break;
    }
-    if ( m_subExpr1 )
+    if (m_subExpr1)
        exprStr += m_subExpr1->toString();
    switch (m_combOperator)
    {
@@ -1270,7 +1276,7 @@ OString AstExpression::toString()
            break;
    }

-    if ( m_subExpr2 )
+    if (m_subExpr2)
        exprStr += m_subExpr2->toString();

    return exprStr;
--- a/idlc/source/aststack.cxx
+++ b/idlc/source/aststack.cxx
@@ -21,9 +21,7 @@
 #include <aststack.hxx>
 #include <astscope.hxx>

-AstStack::AstStack()
-{
-}
+AstStack::AstStack() {}

 AstStack::~AstStack()
 {
@@ -31,7 +29,6 @@ AstStack::~AstStack()
        delete p;
 }

-
 AstScope* AstStack::top()
 {
    if (m_stack.empty())
@@ -58,7 +55,7 @@ AstScope* AstStack::topNonNull()
 {
    for (sal_uInt32 i = m_stack.size(); i > 0; i--)
    {
-        if ( m_stack[i - 1] )
+        if (m_stack[i - 1])
            return m_stack[i - 1];
    }
    return nullptr;
@@ -77,9 +74,6 @@ void AstStack::pop()
    m_stack.pop_back();
 }

-void AstStack::clear()
-{
-   m_stack.clear();
-}
+void AstStack::clear() { m_stack.clear(); }

 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
--- a/idlc/source/attributeexceptions.hxx
+++ b/idlc/source/attributeexceptions.hxx
@@ -22,10 +22,12 @@

 #include <rtl/ustring.hxx>

-struct AttributeExceptions {
-    struct Part {
-        OUString const * documentation;
-        DeclList const * exceptions;
+struct AttributeExceptions
+{
+    struct Part
+    {
+        OUString const* documentation;
+        DeclList const* exceptions;
    };
    Part get;
    Part set;
--- a/solenv/clang-format/excludelist
+++ b/solenv/clang-format/excludelist
@@ -5020,7 +5020,6 @@ idl/source/cmptools/hash.cxx
 idl/source/cmptools/lex.cxx
 idl/source/objects/basobj.cxx
 idl/source/objects/bastype.cxx
-idl/source/objects/module.cxx
 idl/source/objects/object.cxx
 idl/source/objects/slot.cxx
 idl/source/objects/types.cxx
@@ -5032,27 +5031,17 @@ idl/source/prj/svidl.cxx
 idlc/inc/astattribute.hxx
 idlc/inc/astbasetype.hxx
 idlc/inc/astconstant.hxx
-idlc/inc/astconstants.hxx
 idlc/inc/astdeclaration.hxx
-idlc/inc/astenum.hxx
-idlc/inc/astexception.hxx
 idlc/inc/astexpression.hxx
 idlc/inc/astinterface.hxx
 idlc/inc/astinterfacemember.hxx
 idlc/inc/astmember.hxx
-idlc/inc/astmodule.hxx
-idlc/inc/astneeds.hxx
-idlc/inc/astobserves.hxx
 idlc/inc/astoperation.hxx
 idlc/inc/astparameter.hxx
-idlc/inc/astscope.hxx
-idlc/inc/astsequence.hxx
 idlc/inc/astservice.hxx
 idlc/inc/astservicemember.hxx
-idlc/inc/aststack.hxx
 idlc/inc/aststruct.hxx
 idlc/inc/aststructinstance.hxx
-idlc/inc/asttype.hxx
 idlc/inc/asttypedef.hxx
 idlc/inc/errorhandler.hxx
 idlc/inc/fehelper.hxx
@@ -5064,15 +5053,12 @@ idlc/source/astconstant.cxx
 idlc/source/astdeclaration.cxx
 idlc/source/astdump.cxx
 idlc/source/astenum.cxx
-idlc/source/astexpression.cxx
 idlc/source/astinterface.cxx
 idlc/source/astoperation.cxx
 idlc/source/astscope.cxx
 idlc/source/astservice.cxx
-idlc/source/aststack.cxx
 idlc/source/aststruct.cxx
 idlc/source/aststructinstance.cxx
-idlc/source/attributeexceptions.hxx
 idlc/source/errorhandler.cxx
 idlc/source/fehelper.cxx
 idlc/source/idlc.cxx