Date: prev next · Thread: first prev next last
2011 Archives by date, by thread · List index


Hi,

first attempt so I will take any advise (split the patch into smaller files?).
License is LGPLv3+/MPL.

I would have edited the wiki that I am working on this directory but the 
registration is disabled.

Regards,
Michael
From 422ba0decf7b925bdf83c22149981b4eb065ec81 Mon Sep 17 00:00:00 2001
From: Michael Muench <michael@codingmicha.de>
Date: Sun, 13 Feb 2011 01:17:15 +0100
Subject: [PATCH] idl removed and translated comments

---
 idl/inc/basobj.hxx             |    7 +-
 idl/inc/bastype.hxx            |   15 +-
 idl/inc/char.hxx               |    1 -
 idl/inc/command.hxx            |    1 -
 idl/inc/database.hxx           |   10 +-
 idl/inc/hash.hxx               |    7 +-
 idl/inc/lex.hxx                |   26 +--
 idl/inc/module.hxx             |    3 +-
 idl/inc/object.hxx             |    2 -
 idl/inc/slot.hxx               |   13 +-
 idl/inc/types.hxx              |   20 +--
 idl/source/cmptools/char.cxx   |    2 -
 idl/source/cmptools/hash.cxx   |  111 +--------
 idl/source/cmptools/lex.cxx    |  110 +--------
 idl/source/objects/basobj.cxx  |  219 ++---------------
 idl/source/objects/bastype.cxx |  133 +----------
 idl/source/objects/module.cxx  |  104 ++------
 idl/source/objects/object.cxx  |  188 +++------------
 idl/source/objects/slot.cxx    |  221 ++++-------------
 idl/source/objects/types.cxx   |  526 +++-------------------------------------
 idl/source/prj/command.cxx     |  101 ++------
 idl/source/prj/database.cxx    |  218 +++--------------
 idl/source/prj/globals.cxx     |   11 -
 idl/source/prj/idldll.cxx      |    8 +-
 idl/source/prj/svidl.cxx       |   13 +-
 25 files changed, 272 insertions(+), 1798 deletions(-)

diff --git a/idl/inc/basobj.hxx b/idl/inc/basobj.hxx
index 5993e0f..ff0d72b 100644
--- a/idl/inc/basobj.hxx
+++ b/idl/inc/basobj.hxx
@@ -59,7 +59,6 @@ enum
 };
 typedef int WriteAttribute;
 
-/******************** Meta Factory **************************************/
 #define SV_DECL_META_FACTORY( Class, CLASS_ID )                         \
     SV_DECL_PERSIST( Class, CLASS_ID )
 
@@ -74,7 +73,6 @@ typedef int WriteAttribute;
 #define SV_IMPL_META_FACTORY1( Class, Super1 )                          \
     SV_IMPL_PERSIST1( Class, Super1 )
 
-/******************** class SvMetaObject ********************************/
 class SvMetaObject : public SvPersistBase
 {
 public:
@@ -128,7 +126,6 @@ public:
                     }
 };
 
-/******************** class SvMetaName **********************************/
 class SvMetaName : public SvMetaObject
 {
     SvString      aName;
@@ -180,7 +177,6 @@ SV_DECL_IMPL_REF(SvMetaName)
 SV_DECL_IMPL_PERSIST_LIST(SvMetaName,SvMetaName *)
 
 
-/******************** class SvMetaReference *****************************/
 SV_DECL_REF(SvMetaReference)
 class SvMetaReference : public SvMetaName
 {
@@ -229,11 +225,10 @@ SV_IMPL_REF(SvMetaReference)
 SV_DECL_IMPL_PERSIST_LIST(SvMetaReference,SvMetaReference *)
 
 
-/******************** class SvMetaExtern *********************************/
 class SvMetaModule;
 class SvMetaExtern : public SvMetaReference
 {
-    SvMetaModule *          pModule;    // in welchem Modul enthalten
+    SvMetaModule *          pModule;    // included in which module
 
     SvUUId                  aUUId;
     SvVersion               aVersion;
diff --git a/idl/inc/bastype.hxx b/idl/inc/bastype.hxx
index 9cdb38c..1f97998 100644
--- a/idl/inc/bastype.hxx
+++ b/idl/inc/bastype.hxx
@@ -40,7 +40,6 @@ class SvStringHashEntry;
 class SvIdlDataBase;
 class SvTokenStream;
 
-/******************** class SvUINT32 **********************************/
 class SvUINT32
 {
     UINT32  nVal;
@@ -61,7 +60,6 @@ public:
 };
 
 
-/******************** class SvINT16 **********************************/
 class SvINT16
 {
     short   nVal;
@@ -79,7 +77,6 @@ public:
 };
 
 
-/******************** class SvUINT16 **********************************/
 class SvUINT16
 {
     USHORT  nVal;
@@ -97,7 +94,6 @@ public:
 };
 
 
-/******************** class SvINT32 **********************************/
 class SvINT32
 {
     INT32   nVal;
@@ -115,7 +111,6 @@ public:
 };
 
 
-/******************** class Svint **********************************/
 class Svint
 {
     int        nVal;
@@ -136,7 +131,6 @@ public:
 };
 
 
-/******************** class SvBOOL **********************************/
 class SvBOOL
 {
     BOOL  nVal:1,
@@ -165,7 +159,6 @@ public:
 };
 
 
-/******************** class SvIdentifier **********************************/
 class SvIdentifier : public ByteString
 {
 public:
@@ -184,11 +177,10 @@ public:
 };
 
 
-/******************** class SvIdentifier **********************************/
 class SvNumberIdentifier : public SvIdentifier
 {
     UINT32  nValue;
-    // darf nicht benutzt werden
+    // must not be used
     BOOL    ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm );
 public:
                 SvNumberIdentifier() : nValue( 0 ) {};
@@ -209,7 +201,6 @@ public:
 };
 
 
-/******************** class SvString **********************************/
 class SvString : public ByteString
 {
 public:
@@ -228,7 +219,6 @@ public:
 };
 
 
-/******************** class SvHelpText **********************************/
 class SvHelpText : public SvString
 {
 public:
@@ -241,12 +231,10 @@ public:
 };
 
 
-/******************** class SvHelpContext *******************************/
 class SvHelpContext : public SvNumberIdentifier
 {
 };
 
-/******************** class SvUUId *************************************/
 class SvUUId : public SvGlobalName
 {
 public:
@@ -258,7 +246,6 @@ public:
 };
 
 
-/******************** class SvVersion **********************************/
 class SvVersion
 {
     USHORT  nMajorVersion;
diff --git a/idl/inc/char.hxx b/idl/inc/char.hxx
index d0a4825..248eac3 100644
--- a/idl/inc/char.hxx
+++ b/idl/inc/char.hxx
@@ -31,7 +31,6 @@
 
 #include <tools/string.hxx>
 
-/******************* T y p e s *******************************************/
 class SvChar
 {
 public:
diff --git a/idl/inc/command.hxx b/idl/inc/command.hxx
index 8332569..3162bcc 100644
--- a/idl/inc/command.hxx
+++ b/idl/inc/command.hxx
@@ -41,7 +41,6 @@ typedef ::std::vector< String* > StringList;
 
 typedef ::std::vector< ByteString* > ByteStringList;
 
-/******************** class SvCommand ************************************/
 class SvCommand
 {
 public:
diff --git a/idl/inc/database.hxx b/idl/inc/database.hxx
index 0b41dad..76a6b02 100644
--- a/idl/inc/database.hxx
+++ b/idl/inc/database.hxx
@@ -34,13 +34,10 @@
 #include <lex.hxx>
 #include <tools/pstm.hxx>
 
-/*************************************************************************
-*************************************************************************/
-
 class SvCommand;
 
 #ifdef IDL_COMPILER
-/******************** class SvIdlError ***********************************/
+
 class SvIdlError
 {
     ByteString  aText;
@@ -64,7 +61,6 @@ public:
 };
 #endif
 
-/******************** class SvIdlDataBase ********************************/
 class SvIdlDataBase
 {
     BOOL                                               bExport;
@@ -82,7 +78,7 @@ class SvIdlDataBase
     SvMetaClassMemberList       aClassList;
     SvMetaModuleMemberList      aModuleList;
     SvMetaAttributeMemberList  aAttrList;
-    SvMetaTypeMemberList        aTmpTypeList; // nicht Persistent
+    SvMetaTypeMemberList        aTmpTypeList; // not persistent
 
 protected:
 #ifdef IDL_COMPILER
@@ -111,7 +107,7 @@ public:
     SvMetaModuleMemberList &  GetModuleList() { return aModuleList; }
     SvMetaModule *            GetModule( const ByteString & rName );
 
-    // Liste der benutzten Typen beim Schreiben
+    // list of used types while writing
     SvMetaTypeMemberList       aUsedTypes;
     ByteString                                 aIFaceName;
     SvNumberIdentifier         aStructSlotId;
diff --git a/idl/inc/hash.hxx b/idl/inc/hash.hxx
index 8f13536..41ee6db 100644
--- a/idl/inc/hash.hxx
+++ b/idl/inc/hash.hxx
@@ -33,13 +33,12 @@
 #include <tools/string.hxx>
 #include <vector>
 
-/****************** H a s h - T a b l e **********************************/
 class SvHashTable
 {
     UINT32       nMax;                 // size of hash-tabel
     UINT32       nFill;                // elements in hash-tabel
-    UINT32       lAsk;                 // Anzahl der Anfragen
-    UINT32       lTry;                 // Anzahl der Versuche
+    UINT32       lAsk;                 // number of requests
+    UINT32       lTry;                 // number of tries
 protected:
     BOOL        Test_Insert( const void *, BOOL bInsert, UINT32 * pInsertPos );
 
@@ -56,7 +55,6 @@ public:
     virtual BOOL            IsEntry( UINT32 ) const = 0;
 };
 
-/************** S t r i n g H a s h T a b l e E n t r y ******************/
 class SvStringHashTable;
 class SvStringHashEntry : public SvRefBase
 {
@@ -97,7 +95,6 @@ public:
 
 SV_DECL_IMPL_REF(SvStringHashEntry)
 
-/****************** S t r i n g H a s h T a b l e ************************/
 typedef ::std::vector< SvStringHashEntry* > SvStringHashList;
 
 class SvStringHashTable : public SvHashTable
diff --git a/idl/inc/lex.hxx b/idl/inc/lex.hxx
index fe8d29ea..da2d5ed 100644
--- a/idl/inc/lex.hxx
+++ b/idl/inc/lex.hxx
@@ -33,14 +33,12 @@
 #include <tools/gen.hxx>
 #include <tools/stream.hxx>
 
-/******************** enum ***********************************************/
 enum SVTOKEN_ENUM { SVTOKEN_EMPTY,      SVTOKEN_COMMENT,
                     SVTOKEN_INTEGER,    SVTOKEN_STRING,
                     SVTOKEN_BOOL,       SVTOKEN_IDENTIFIER,
                     SVTOKEN_CHAR,       SVTOKEN_RTTIBASE,
                     SVTOKEN_EOF,               SVTOKEN_HASHID };
 
-/******************** class SvToken **************************************/
 class BigInt;
 class SvToken
 {
@@ -53,7 +51,6 @@ friend class SvTokenStream;
         ULONG                  nLong;
         BOOL                   bBool;
         char                   cChar;
-//         SvRttiBase *        pComplexObj;
         SvStringHashEntry *    pHash;
     };
 public:
@@ -63,7 +60,6 @@ public:
             SvToken( SVTOKEN_ENUM nTypeP, BOOL b );
             SvToken( char c );
             SvToken( SVTOKEN_ENUM nTypeP, const ByteString & rStr );
-//            SvToken( SvRttiBase * pComplexObj );
             SvToken( SVTOKEN_ENUM nTypeP );
 
     SvToken & operator = ( const SvToken & rObj );
@@ -102,7 +98,6 @@ public:
     ULONG       GetNumber() const       { return nLong;         }
     BOOL        GetBool() const         { return bBool;         }
     char        GetChar() const         { return cChar;         }
-//    SvRttiBase *GetObject() const       { return pComplexObj;   }
 
     void        SetHash( SvStringHashEntry * pHashP )
                 { pHash = pHashP; nType = SVTOKEN_HASHID; }
@@ -128,26 +123,19 @@ inline SvToken::SvToken( char c )
 inline SvToken::SvToken( SVTOKEN_ENUM nTypeP, const ByteString & rStr )
     : nType( nTypeP ), aString( rStr ) {}
 
-/*
-inline SvToken::SvToken( SvRttiBase * pObj )
-    : nType( SVTOKEN_RTTIBASE ), pComplexObj( pObj )
-        { pObj->AddRef(); }
-*/
-
 inline SvToken::SvToken( SVTOKEN_ENUM nTypeP )
 : nType( nTypeP ) {}
 
 DECLARE_LIST( SvTokenList, SvToken * )
 
-/******************** class SvTokenStream ********************************/
 class SvTokenStream
 {
     ULONG       nLine, nColumn;
     int                        nBufPos;
-    int         c;          // naechstes Zeichen
+    int         c;          // next character
     CharSet     nCharSet;
-    char *      pCharTab;   // Zeiger auf die Konverierungstabelle
-    USHORT      nTabSize;   // Tabulator Laenge
+    char *      pCharTab;   // pointer to conversion table
+    USHORT      nTabSize;   // length of tabulator
     ByteString         aStrTrue;
     ByteString         aStrFalse;
     ULONG              nMaxPos;
@@ -179,7 +167,7 @@ class SvTokenStream
                     }
     void                       CalcColumn()
                     {
-                        // wenn Zeilenende berechnung sparen
+                        // if end of line spare calculation
                         if( 0 != c )
                         {
                             USHORT n = 0;
@@ -207,7 +195,7 @@ public:
                     {
                         SvToken * pRetToken = pCurToken;
                         if( NULL == (pCurToken = aTokList.Prev()) )
-                            // Current Zeiger nie Null
+                            // current pointer never null
                             pCurToken = pRetToken;
 
                         return pRetToken;
@@ -216,14 +204,14 @@ public:
                     {
                         SvToken * pRetToken = pCurToken;
                         if( NULL == (pCurToken = aTokList.Next()) )
-                            // Current Zeiger nie Null
+                            // current pointer never null
                             pCurToken = pRetToken;
                         SetMax();
                         return pRetToken;
                     }
     SvToken *       GetToken_Next()
                     {
-                        // Kommentare werden initial entfernt
+                        // comments get removed initially
                         return GetToken_NextAll();
                     }
     SvToken *       GetToken() const { return pCurToken; }
diff --git a/idl/inc/module.hxx b/idl/inc/module.hxx
index 060d5b3..af21d62 100644
--- a/idl/inc/module.hxx
+++ b/idl/inc/module.hxx
@@ -41,13 +41,12 @@ struct SvNamePos
         , nStmPos( nPos ) {}
 };
 
-/******************** class SvMetaModule *********************************/
 class SvMetaModule : public SvMetaExtern
 {
     SvMetaClassMemberList      aClassList;
     SvMetaTypeMemberList       aTypeList;
     SvMetaAttributeMemberList   aAttrList;
-// Browser
+// browser
     String                  aIdlFileName;
     SvString                aHelpFileName;
     SvString                aSlotIdFile;
diff --git a/idl/inc/object.hxx b/idl/inc/object.hxx
index 3f70af8..3204f09 100644
--- a/idl/inc/object.hxx
+++ b/idl/inc/object.hxx
@@ -56,7 +56,6 @@ public:
     ULONG   GetObject( ULONG nPos ){ return (ULONG) List::GetObject( nPos ); }
 };
 
-/******************** class SvClassElement *******************************/
 SV_DECL_REF(SvMetaClass)
 class SvClassElement : public SvPersistBase
 {
@@ -86,7 +85,6 @@ public:
 SV_DECL_IMPL_REF(SvClassElement)
 SV_DECL_IMPL_PERSIST_LIST(SvClassElement,SvClassElement *)
 
-/******************** class SvMetaClass *********************************/
 class SvMetaModule;
 SV_DECL_PERSIST_LIST(SvMetaClass,SvMetaClass *)
 class SvMetaClass : public SvMetaType
diff --git a/idl/inc/slot.hxx b/idl/inc/slot.hxx
index 2747f1b..931cbc4 100644
--- a/idl/inc/slot.hxx
+++ b/idl/inc/slot.hxx
@@ -32,8 +32,6 @@
 #include <types.hxx>
 #include <command.hxx>
 
-/******************** class SvMetaSlot **********************************/
-//class SbxObject;
 class SvMetaSlotMemberList;
 class SvMetaSlot : public SvMetaAttribute
 {
@@ -49,15 +47,15 @@ class SvMetaSlot : public SvMetaAttribute
     SvBOOL          aGet;
     SvBOOL          aSet;
 
-    SvBOOL          aCachable;  // exclusiv
+    SvBOOL          aCachable;  // exclusive
     SvBOOL          aVolatile;
     SvBOOL          aToggle;
     SvBOOL          aAutoUpdate;
 
-    SvBOOL          aSynchron;  // exclusiv
+    SvBOOL          aSynchron;  // exclusive
     SvBOOL          aAsynchron;
 
-    SvBOOL          aRecordPerItem;// exclusiv
+    SvBOOL          aRecordPerItem;// exclusive
     SvBOOL          aRecordPerSet;
     SvBOOL          aRecordManual;
     SvBOOL          aNoRecord;
@@ -202,10 +200,6 @@ public:
     const ByteString &      GetDefault() const;
     const ByteString &         GetDisableFlags() const;
     BOOL                GetPseudoSlots() const;
-    /*
-    BOOL                GetGet() const;
-    BOOL                GetSet() const;
-    */
     BOOL                GetCachable() const;
     BOOL                GetVolatile() const;
     BOOL                GetToggle() const;
@@ -242,7 +236,6 @@ public:
     void                               ResetSlotPointer()
                         { pNextSlot = pLinkedSlot = 0; }
 
-//    void                FillSbxObject( SvIdlDataBase & rBase, SbxObject *, BOOL bProp );
 #ifdef IDL_COMPILER
     SvMetaEnumValue*   GetEnumValue() const
                         { return pEnumValue; }
diff --git a/idl/inc/types.hxx b/idl/inc/types.hxx
index d5c27d7..ee32dd1 100644
--- a/idl/inc/types.hxx
+++ b/idl/inc/types.hxx
@@ -35,7 +35,6 @@
 class SvSlotElementList;
 struct SvSlotElement;
 
-/******************** class SvMetaAttribute *****************************/
 SV_DECL_REF(SvMetaType)
 SV_DECL_REF(SvMetaAttribute)
 SV_DECL_PERSIST_LIST(SvMetaAttribute,SvMetaAttribute *)
@@ -105,8 +104,6 @@ public:
     virtual BOOL               IsVariable() const;
     virtual ByteString         GetMangleName( BOOL bVariable ) const;
 
-//    void                FillSbxObject( SbxInfo * pInfo, USHORT nSbxFlags = 0 );
-//    virtual void        FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj, BOOL bVariable );
 
 #ifdef IDL_COMPILER
     virtual BOOL               Test( SvIdlDataBase &, SvTokenStream & rInStm );
@@ -135,14 +132,13 @@ SV_IMPL_REF(SvMetaAttribute)
 SV_IMPL_PERSIST_LIST(SvMetaAttribute,SvMetaAttribute *)
 
 
-/******************** class SvType *********************************/
 enum { CALL_VALUE, CALL_POINTER, CALL_REFERENCE };
 enum { TYPE_METHOD, TYPE_STRUCT, TYPE_BASE, TYPE_ENUM, TYPE_UNION,
       TYPE_CLASS, TYPE_POINTER };
 class SvMetaType : public SvMetaExtern
 {
-    SvBOOL                                     aIn;    // Eingangsparameter
-    SvBOOL                                             aOut;   // Returnparameter
+    SvBOOL                                     aIn;    // input parameter
+    SvBOOL                                             aOut;   // return parameter
     Svint                                              aCall0, aCall1;
     Svint                                              aSbxDataType;
     SvIdentifier                               aSvName;
@@ -186,7 +182,7 @@ public:
             SvMetaType( const ByteString & rTypeName, const ByteString & rSbxName,
                         const ByteString & rOdlName, char cParserChar,
                         const ByteString & rCName, const ByteString & rBasicName,
-                        const ByteString & rBasicPostfix/*, SbxDataType nT = SbxEMPTY */);
+                        const ByteString & rBasicPostfix );
 
     SvMetaAttributeMemberList &        GetAttrList() const;
     ULONG                              GetAttrCount() const
@@ -205,10 +201,6 @@ public:
     BOOL                               IsItem() const { return bIsItem; }
     BOOL                               IsShell() const { return bIsShell; }
 
-//    void                SetSbxDataType( SbxDataType nT )
-//                        { aSbxDataType = (int)nT; }
-//    SbxDataType         GetSbxDataType() const;
-
     void                SetIn( BOOL b ) { aIn = b; }
     BOOL                GetIn() const;
 
@@ -234,7 +226,6 @@ public:
 
     virtual BOOL        SetName( const ByteString & rName, SvIdlDataBase * = NULL );
 
-//    void                FillSbxObject( SbxVariable * pObj, BOOL bVariable );
 
 #ifdef IDL_COMPILER
     virtual BOOL        ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm );
@@ -249,7 +240,6 @@ public:
 
     ULONG                              MakeSfx( ByteString * pAtrrArray );
     virtual void               WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm );
-    //BOOL                             ReadTypePrefix( SvIdlDataBase &, SvTokenStream & rInStm );
     BOOL                               ReadMethodArgs( SvIdlDataBase & rBase,
                                              SvTokenStream & rInStm );
     void                WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab, 
WriteType );
@@ -265,7 +255,6 @@ DECLARE_LIST(SvMetaTypeList,SvMetaType *)
 SV_DECL_IMPL_PERSIST_LIST(SvMetaType,SvMetaType *)
 
 
-/******************** class SvTypeString *********************************/
 class SvMetaTypeString : public SvMetaType
 {
 public:
@@ -276,7 +265,6 @@ SV_DECL_IMPL_REF(SvMetaTypeString)
 SV_DECL_IMPL_PERSIST_LIST(SvMetaTypeString,SvMetaTypeString *)
 
 
-/******************** class SvMetaEnumValue **********************************/
 class SvMetaEnumValue : public SvMetaName
 {
     ByteString      aEnumValue;
@@ -295,7 +283,6 @@ SV_DECL_IMPL_REF(SvMetaEnumValue)
 SV_DECL_IMPL_PERSIST_LIST(SvMetaEnumValue,SvMetaEnumValue *)
 
 
-/******************** class SvTypeEnum *********************************/
 class SvMetaTypeEnum : public SvMetaType
 {
     SvMetaEnumValueMemberList   aEnumValueList;
@@ -331,7 +318,6 @@ SV_DECL_IMPL_REF(SvMetaTypeEnum)
 SV_DECL_IMPL_PERSIST_LIST(SvMetaTypeEnum,SvMetaTypeEnum *)
 
 
-/******************** class SvTypeVoid ***********************************/
 class SvMetaTypevoid : public SvMetaType
 {
 public:
diff --git a/idl/source/cmptools/char.cxx b/idl/source/cmptools/char.cxx
index e568c90..bd47aa5 100644
--- a/idl/source/cmptools/char.cxx
+++ b/idl/source/cmptools/char.cxx
@@ -29,7 +29,6 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_idl.hxx"
 
-/****************** I N C L U D E S **************************************/
 #include <ctype.h>
 #include <string.h>
 
@@ -37,7 +36,6 @@
 
 #include <char.hxx>
 
-/****************** D A T E N ********************************************/
 static unsigned char EqualTab[ 256 ] = {
   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,
diff --git a/idl/source/cmptools/hash.cxx b/idl/source/cmptools/hash.cxx
index b8a6d04..197999a 100644
--- a/idl/source/cmptools/hash.cxx
+++ b/idl/source/cmptools/hash.cxx
@@ -29,33 +29,17 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_idl.hxx"
 
-/****************** I N C L U D E S **************************************/
-// C and C++ Includes.
+// C and C++ includes
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 
-// Programmabh„ngige Includes.
+// program-sensitive includes
 #include <hash.hxx>
 #include <tools/debug.hxx>
 
-/****************** C O D E **********************************************/
-/*************************************************************************
-|*
-|*    SvStringHashEntry::~SvStringHashEntry()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvStringHashEntry::~SvStringHashEntry() { };
 
-/*************************************************************************
-|*
-|*    SvHashTable::SvHashTable()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvHashTable::SvHashTable( UINT32 nMaxEntries )
 {
     nMax = nMaxEntries;     // set max entries
@@ -64,13 +48,6 @@ SvHashTable::SvHashTable( UINT32 nMaxEntries )
     lAsk = 0;
 }
 
-/*************************************************************************
-|*
-|*    SvHashTable::~SvHashTable()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvHashTable::~SvHashTable()
 {
 #ifdef DOS_NIE
@@ -81,13 +58,6 @@ SvHashTable::~SvHashTable()
 #endif
 }
 
-/*************************************************************************
-|*
-|*    SvHashTable::Test_Insert()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
                                UINT32 * pInsertPos )
 {
@@ -128,14 +98,6 @@ BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
     return( FALSE );
 }
 
-/************************************************************************/
-/*************************************************************************
-|*
-|*    SvStringHashTable::SvStringHashTable()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
         : SvHashTable( nMaxEntries )
 {
@@ -145,7 +107,7 @@ SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
 #endif
     pEntries = new SvStringHashEntry[ nMaxEntries ];
 
-    // RefCount auf eins setzen
+    // set RefCount to one
     SvStringHashEntry * pPos, *pEnd;
     pPos    = pEntries;
     pEnd    = pEntries + nMaxEntries;
@@ -156,17 +118,10 @@ SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
     }
 }
 
-/*************************************************************************
-|*
-|*    ~SvStringHashTable::SvStringHashTable()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvStringHashTable::~SvStringHashTable()
 {
 #ifdef DBG_UTIL
-    // RefCount auf eins setzen
+    // set RefCount to one
     SvStringHashEntry * pPos, *pEnd;
     pPos    = pEntries;
     pEnd    = pEntries + GetMax();
@@ -180,13 +135,6 @@ SvStringHashTable::~SvStringHashTable()
     delete [] pEntries;
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::HashFunc()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 UINT32 SvStringHashTable::HashFunc( const void * pElement ) const
 {
     UINT32          nHash = 0;  // hash value
@@ -208,13 +156,6 @@ UINT32 SvStringHashTable::HashFunc( const void * pElement ) const
     return( nHash );
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::GetNearString()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 ByteString SvStringHashTable::GetNearString( const ByteString & rName ) const
 {
     for( UINT32 i = 0; i < GetMax(); i++ )
@@ -229,13 +170,6 @@ ByteString SvStringHashTable::GetNearString( const ByteString & rName ) const
     return ByteString();
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::IsEntry()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const
 {
     if( nIndex >= GetMax() )
@@ -243,13 +177,6 @@ BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const
     return pEntries[ nIndex ].HasId();
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::Insert()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvStringHashTable::Insert( const ByteString & rName, UINT32 * pIndex )
 {
     UINT32 nIndex;
@@ -264,26 +191,12 @@ BOOL SvStringHashTable::Insert( const ByteString & rName, UINT32 * pIndex )
     return TRUE;
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::Test()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvStringHashTable::Test( const ByteString & rName, UINT32 * pPos ) const
 {
     return ((SvStringHashTable *)this)->SvHashTable::
                 Test_Insert( &rName, FALSE, pPos );
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::Get()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvStringHashEntry * SvStringHashTable::Get( UINT32 nIndex ) const
 {
     if( IsEntry( nIndex ) )
@@ -291,26 +204,12 @@ SvStringHashEntry * SvStringHashTable::Get( UINT32 nIndex ) const
     return( NULL );
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::Get()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 StringCompare SvStringHashTable::Compare( const void * pElement,
                                           UINT32 nIndex ) const
 {
     return ((const ByteString *)pElement)->CompareTo( pEntries[ nIndex ].GetName() );
 }
 
-/*************************************************************************
-|*
-|*    SvStringHashTable::FillHashList()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 void SvStringHashTable::FillHashList( SvStringHashList * pList ) const
 {
     for( UINT32 n = 0; n < GetMax(); n++ )
@@ -318,7 +217,7 @@ void SvStringHashTable::FillHashList( SvStringHashList * pList ) const
         if( IsEntry( n ) )
             pList->push_back( Get( n ) );
     }
-    // Hash Reihenfolge, jetzt sortieren
+    // hash order, sort now
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/idl/source/cmptools/lex.cxx b/idl/source/cmptools/lex.cxx
index 8b98334..80f052a 100644
--- a/idl/source/cmptools/lex.cxx
+++ b/idl/source/cmptools/lex.cxx
@@ -39,14 +39,6 @@
 #include <globals.hxx>
 #include <tools/bigint.hxx>
 
-/****************** SvToken **********************************************/
-/*************************************************************************
-|*
-|*    SvToken::Print()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 ByteString SvToken::GetTokenAsString() const
 {
     ByteString aStr;
@@ -73,7 +65,7 @@ ByteString SvToken::GetTokenAsString() const
             aStr = cChar;
             break;
         case SVTOKEN_RTTIBASE:
-            aStr = "RTTIBASE";//(ULONG)pComplexObj;
+            aStr = "RTTIBASE";
             break;
         case SVTOKEN_EOF:
         case SVTOKEN_HASHID:
@@ -83,68 +75,28 @@ ByteString SvToken::GetTokenAsString() const
     return aStr;
 }
 
-/*************************************************************************
-|*
-|*    SvToken::SvToken()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvToken::SvToken( const SvToken & rObj )
 {
     nLine = rObj.nLine;
     nColumn = rObj.nColumn;
     nType = rObj.nType;
     aString = rObj.aString;
-/*
-    if( SVTOKEN_RTTIBASE = nType )
-    {
-        pComplexObj = rObj.pComplexObj;
-        pComplexObj->AddRef();
-    }
-    else
-*/
-        nLong = rObj.nLong;
+    nLong = rObj.nLong;
 }
 
-/*************************************************************************
-|*
-|*    SvToken::operator = ()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvToken & SvToken::operator = ( const SvToken & rObj )
 {
     if( this != &rObj )
     {
-/*
-        if( SVTOKEN_RTTIBASE = nType )
-            pComplexObj->ReleaseRef();
-*/
         nLine = rObj.nLine;
         nColumn = rObj.nColumn;
         nType = rObj.nType;
         aString = rObj.aString;
-/*
-        if( SVTOKEN_RTTIBASE = nType )
-        {
-            pComplexObj = rObj.pComplexObj;
-            pComplexObj->AddRef();
-        }
-        else
-*/
-            nLong = rObj.nLong;
+        nLong = rObj.nLong;
     }
     return *this;
 }
 
-/****************** SvTokenStream ****************************************/
-/*************************************************************************
-|*    SvTokenStream::InitCtor()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvTokenStream::InitCtor()
 {
 #ifdef DOS
@@ -163,11 +115,6 @@ void SvTokenStream::InitCtor()
     FillTokenList();
 }
 
-/*************************************************************************
-|*    SvTokenStream::SvTokenStream()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvTokenStream::SvTokenStream( const String & rFileName )
     : pInStream( new SvFileStream( rFileName, STREAM_STD_READ | STREAM_NOCREATE ) )
     , rInStream( *pInStream )
@@ -177,11 +124,6 @@ SvTokenStream::SvTokenStream( const String & rFileName )
     InitCtor();
 }
 
-/*************************************************************************
-|*    SvTokenStream::SvTokenStream()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName )
     : pInStream( NULL )
     , rInStream( rStream )
@@ -191,11 +133,6 @@ SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName )
     InitCtor();
 }
 
-/*************************************************************************
-|*    SvTokenStream::~SvTokenStream()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvTokenStream::~SvTokenStream()
 {
     delete pInStream;
@@ -207,11 +144,6 @@ SvTokenStream::~SvTokenStream()
     }
 }
 
-/*************************************************************************
-|*    SvTokenStream::FillTokenList()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvTokenStream::FillTokenList()
 {
     SvToken * pToken = new SvToken();
@@ -243,11 +175,6 @@ void SvTokenStream::FillTokenList()
     pCurToken = aTokList.First();
 }
 
-/*************************************************************************
-|*    SvTokenStrem::SetCharSet()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvTokenStream::SetCharSet( CharSet nSet )
 {
     nCharSet = nSet;
@@ -259,11 +186,6 @@ void SvTokenStream::SetCharSet( CharSet nSet )
 #endif
 }
 
-/*************************************************************************
-|*    SvTokeStream::GetNextChar()
-|*
-|*    Beschreibung
-*************************************************************************/
 int SvTokenStream::GetNextChar()
 {
     int nChar;
@@ -288,11 +210,6 @@ int SvTokenStream::GetNextChar()
     return nChar;
 }
 
-/*************************************************************************
-|*    SvTokenStrem::GetNumber()
-|*
-|*    Beschreibung
-*************************************************************************/
 ULONG SvTokenStream::GetNumber()
 {
     ULONG   l = 0;
@@ -331,18 +248,13 @@ ULONG SvTokenStream::GetNumber()
     return( l );
 }
 
-/*************************************************************************
-|*    SvTokenStream::MakeToken()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvTokenStream::MakeToken( SvToken & rToken )
 {
     do
     {
         if( 0 == c )
             c = GetNextChar();
-        // Leerzeichen ueberlesen
+        // skip whitespace
         while( isspace( c ) || 26 == c )
         {
             c = GetFastNextChar();
@@ -353,31 +265,26 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )
 
     ULONG nLastLine            = nLine;
     ULONG nLastColumn  = nColumn;
-    // Kommentar
+    // comment
     if( '/' == c )
     {
-        // Zeit Optimierung, keine Kommentare
-        //ByteString aComment( (char)c );
+        // time optimization, no comments
         int c1 = c;
         c = GetFastNextChar();
         if( '/' == c )
         {
             while( '\0' != c )
             {
-                //aComment += (char)c;
                 c = GetFastNextChar();
             }
             c = GetNextChar();
             rToken.nType       = SVTOKEN_COMMENT;
-            //rToken.aString   = aComment;
         }
         else if( '*' == c )
         {
-            //aComment += (char)c;
             c = GetFastNextChar();
             do
             {
-                //aComment += (char)c;
                 while( '*' != c )
                 {
                     if( '\0' == c )
@@ -388,17 +295,14 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )
                     }
                     else
                         c = GetFastNextChar();
-                    //aComment += (char)c;
                 }
                 c = GetFastNextChar();
             }
             while( '/' != c && !IsEof() && ( SVSTREAM_OK == rInStream.GetError() ) );
             if( IsEof() || ( SVSTREAM_OK != rInStream.GetError() ) )
                 return FALSE;
-            //aComment += (char)c;
             c = GetNextChar();
             rToken.nType = SVTOKEN_COMMENT;
-            //rToken.aString = aComment;
             CalcColumn();
         }
         else
@@ -416,7 +320,7 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )
             c = GetFastNextChar();
             if( '\0' == c )
             {
-                // Strings auch "uber das Zeilenende hinauslesen
+                // read strings beyond end of line
                 aStr += '\n';
                 c = GetNextChar();
                 if( IsEof() )
diff --git a/idl/source/objects/basobj.cxx b/idl/source/objects/basobj.cxx
index 46936b3..6f7a019 100644
--- a/idl/source/objects/basobj.cxx
+++ b/idl/source/objects/basobj.cxx
@@ -39,13 +39,7 @@
 #include <globals.hxx>
 #include <database.hxx>
 
-/****************** SvMetaObject *****************************************/
 SV_IMPL_META_FACTORY1( SvMetaObject, SvRttiBase )
-/*************************************************************************
-|*    SvMetaObject::SvMetaObject()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaObject::SvMetaObject()
 {
 }
@@ -58,24 +52,13 @@ void SvMetaObject::Save( SvPersistStream & )
 {
 }
 
-/*************************************************************************
-|*    SvMetaObject::WriteTab()
-|*
-|*    Beschreibung
-*************************************************************************/
 #ifdef IDL_COMPILER
 void SvMetaObject::WriteTab( SvStream & rOutStm, USHORT nTab )
 {
     while( nTab-- )
         rOutStm << "    ";
-//        rOutStm << '\t';
 }
 
-/*************************************************************************
-|*    SvMetaObject::WriteStart()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaObject::WriteStars( SvStream & rOutStm )
 {
     rOutStm << '/';
@@ -84,14 +67,9 @@ void SvMetaObject::WriteStars( SvStream & rOutStm )
     rOutStm << '/' << endl;
 }
 
-/*************************************************************************
-|*    SvMetaObject::TestAndSeekSpaceOnly()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaObject::TestAndSeekSpaceOnly( SvStream & rOutStm, ULONG nBegPos )
 {
-    // keine leeren Klammern schreiben
+    // write no empty brackets
     ULONG nPos = rOutStm.Tell();
     rOutStm.Seek( nBegPos );
     BOOL bOnlySpace = TRUE;
@@ -103,21 +81,16 @@ BOOL SvMetaObject::TestAndSeekSpaceOnly( SvStream & rOutStm, ULONG nBegPos )
             bOnlySpace = FALSE;
     }
     if( bOnlySpace )
-        // nichts geschrieben
+        // nothing written
         rOutStm.Seek( nBegPos );
     else
         rOutStm.Seek( nPos );
     return bOnlySpace;
 }
 
-/*************************************************************************
-|*    SvMetaObject::Back2Delemitter()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaObject::Back2Delemitter( SvStream & rOutStm )
 {
-    // keine leeren Klammern schreiben
+    // write no empty brackets
     ULONG nPos = rOutStm.Tell();
     rOutStm.SeekRel( -1 );
     char c = 0;
@@ -135,62 +108,31 @@ void SvMetaObject::Back2Delemitter( SvStream & rOutStm )
         rOutStm.Seek( nPos );
 }
 
-/*************************************************************************
-|*    SvMetaObject::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaObject::ReadSvIdl( SvIdlDataBase &, SvTokenStream & )
 {
     return FALSE;
 }
 
-/*************************************************************************
-|*    SvMetaObject::WriteSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaObject::WriteSvIdl( SvIdlDataBase &, SvStream &, USHORT /*nTab */ )
 {
 }
 
-/*************************************************************************
-|*    SvMetaObject::Write()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaObject::Write( SvIdlDataBase &, SvStream &, USHORT /*nTab */,
                              WriteType, WriteAttribute )
 {
 }
 
-/*************************************************************************
-|*    SvMetaObject::WriteCxx()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaObject::WriteCxx( SvIdlDataBase &, SvStream &, USHORT /*nTab */ )
 {
 }
 
-/*************************************************************************
-|*    SvMetaObject::WriteHxx()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaObject::WriteHxx( SvIdlDataBase &, SvStream &, USHORT /*nTab */ )
 {
 }
 
 #endif
 
-/****************** SvMetaName *****************************************/
 SV_IMPL_META_FACTORY1( SvMetaName, SvMetaObject );
-/*************************************************************************
-|*    SvMetaName::SvMetaName()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaName::SvMetaName()
 {
 }
@@ -239,18 +181,13 @@ BOOL SvMetaName::SetName( const ByteString & rName, SvIdlDataBase * )
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*    SvMetaName::ReadNameSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaName::ReadNameSvIdl( SvIdlDataBase & rBase,
                                 SvTokenStream & rInStm )
 {
     UINT32 nTokPos = rInStm.Tell();
     SvToken * pTok = rInStm.GetToken_Next();
 
-    // Modulnamen lesen
+    // read module name
     if( pTok->IsIdentifier() )
         if( SetName( pTok->GetString(), &rBase ) )
             return TRUE;
@@ -259,11 +196,6 @@ BOOL SvMetaName::ReadNameSvIdl( SvIdlDataBase & rBase,
     return FALSE;
 }
 
-/*************************************************************************
-|*    SvMetaName::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::ReadAttributesSvIdl( SvIdlDataBase & rBase,
                                       SvTokenStream & rInStm )
 {
@@ -277,21 +209,12 @@ void SvMetaName::ReadAttributesSvIdl( SvIdlDataBase & rBase,
     aHelpText.ReadSvIdl( rBase, rInStm );
     aConfigName.ReadSvIdl( SvHash_ConfigName(), rInStm );
     aDescription.ReadSvIdl( SvHash_Description(), rInStm );
-/*
-    aHelpContext.ReadSvIdl( GetModule()->GetInfo()->GetHelpContextContainer(),
-                          rInStm );
-*/
 }
 
-/*************************************************************************
-|*    SvMetaName::DoReadContextSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::DoReadContextSvIdl( SvIdlDataBase & rBase,
                                    SvTokenStream & rInStm, char cDel )
 {
-    UINT32 nBeginPos = 0; // kann mit Tell nicht vorkommen
+    UINT32 nBeginPos = 0; // can not happen with Tell
     while( nBeginPos != rInStm.Tell() )
     {
         nBeginPos = rInStm.Tell();
@@ -303,39 +226,19 @@ void SvMetaName::DoReadContextSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaName::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::ReadContextSvIdl( SvIdlDataBase &, SvTokenStream & )
 {
 }
 
-/*************************************************************************
-|*    SvMetaName::Test()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaName::Test( SvIdlDataBase &, SvTokenStream & )
 {
     return TRUE;
 }
 
-/*************************************************************************
-|*    SvMetaName::WriteContextSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::WriteContextSvIdl( SvIdlDataBase &, SvStream &, USHORT )
 {
 }
 
-/*************************************************************************
-|*    SvMetaName::WriteDescription()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::WriteDescription( SvStream & rOutStm )
 {
     rOutStm << "<DESCRIPTION>" << endl;
@@ -352,11 +255,6 @@ void SvMetaName::WriteDescription( SvStream & rOutStm )
     rOutStm << aDesc.GetBuffer() << endl << "</DESCRIPTION>" << endl;
 }
 
-/*************************************************************************
-|*    SvMetaName::WriteAttributesIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::WriteAttributesSvIdl( SvIdlDataBase & rBase,
                                        SvStream & rOutStm,
                                        USHORT nTab )
@@ -386,18 +284,13 @@ void SvMetaName::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaName::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaName::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 {
     UINT32 nTokPos = rInStm.Tell();
     BOOL bOk = TRUE;
     if( rInStm.Read( '[' ) )
     {
-        UINT32 nBeginPos = 0; // kann mit Tell nicht vorkommen
+        UINT32 nBeginPos = 0; // can not happen with Tell
         while( nBeginPos != rInStm.Tell() )
         {
             nBeginPos = rInStm.Tell();
@@ -421,11 +314,6 @@ BOOL SvMetaName::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     return bOk;
 }
 
-/*************************************************************************
-|*    SvMetaName::WriteSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
                              USHORT nTab )
 {
@@ -435,9 +323,9 @@ void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
     ULONG nOldPos = rOutStm.Tell();
     WriteAttributesSvIdl( rBase, rOutStm, nTab +1 );
 
-    // keine leeren Klammern schreiben
+    // write no empty brackets
     if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
-        // nichts geschrieben
+        // nothing written
         rOutStm.Seek( nBeginPos );
     else
     {
@@ -452,9 +340,9 @@ void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
     nOldPos = rOutStm.Tell();
     WriteContextSvIdl( rBase, rOutStm, nTab +1 );
 
-    // keine leeren Klammern schreiben
+    // write no empty brackets
     if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
-        // nichts geschrieben
+        // nothing written
         rOutStm.Seek( nBeginPos );
     else
     {
@@ -463,11 +351,6 @@ void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaName::Write()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                            USHORT nTab,
                          WriteType nT, WriteAttribute nA )
@@ -478,7 +361,7 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     ULONG nOldPos = rOutStm.Tell();
     WriteAttributes( rBase, rOutStm, nTab +1, nT, nA );
 
-    // keine leeren Klammern schreiben
+    // write no empty brackets
     ULONG nPos = rOutStm.Tell();
     rOutStm.Seek( nOldPos );
     BOOL bOnlySpace = TRUE;
@@ -490,7 +373,7 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
             bOnlySpace = FALSE;
     }
     if( bOnlySpace )
-        // nichts geschrieben
+        // nothing written
         rOutStm.Seek( nBeginPos );
     else
     {
@@ -500,11 +383,6 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaName::WriteAttributes()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::WriteAttributes( SvIdlDataBase &, SvStream & rOutStm,
                                 USHORT nTab,
                                  WriteType, WriteAttribute )
@@ -529,11 +407,6 @@ void SvMetaName::WriteAttributes( SvIdlDataBase &, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaName::WriteContext()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaName::WriteContext( SvIdlDataBase &, SvStream &,
                                 USHORT,
                                  WriteType, WriteAttribute )
@@ -541,14 +414,8 @@ void SvMetaName::WriteContext( SvIdlDataBase &, SvStream &,
 }
 #endif // IDL_COMPILER
 
-/****************** SvMetaReference *****************************************/
 SV_IMPL_META_FACTORY1( SvMetaReference, SvMetaName );
 
-/*************************************************************************
-|*    SvMetaReference::SvMetaReference()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaReference::SvMetaReference()
 {
 }
@@ -577,25 +444,18 @@ void SvMetaReference::Save( SvPersistStream & rStm )
 {
     SvMetaName::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     BYTE nMask = 0;
     if( aRef.Is() )
         nMask |= 0x01;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x01 ) rStm << aRef;
 }
 
-/**************************************************************************/
-/****************** SvMetaExtern ******************************************/
 SV_IMPL_META_FACTORY1( SvMetaExtern, SvMetaReference );
 
-/*************************************************************************
-|*    SvMetaExtern::SvMetaExtern()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaExtern::SvMetaExtern()
     : pModule( NULL )
     , bReadUUId( FALSE )
@@ -626,7 +486,7 @@ void SvMetaExtern::Save( SvPersistStream & rStm )
 {
     SvMetaReference::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     BYTE nMask = 0;
     if( pModule )                      nMask |= 0x01;
     if( aUUId != SvGlobalName() )      nMask |= 0x02;
@@ -634,29 +494,19 @@ void SvMetaExtern::Save( SvPersistStream & rStm )
     if( bReadUUId )                            nMask |= 0x08;
     if( bReadVersion )                         nMask |= 0x10;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x01 ) rStm << pModule;
     if( nMask & 0x02 ) rStm << aUUId;
     if( nMask & 0x04 ) rStm << aVersion;
 }
 
-/*************************************************************************
-|*    SvMetaExtern::GetModule()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaModule * SvMetaExtern::GetModule() const
 {
     DBG_ASSERT( pModule != NULL, "module not set" );
     return pModule;
 }
 
-/*************************************************************************
-|*    SvMetaExtern::GetUUId()
-|*
-|*    Beschreibung
-*************************************************************************/
 const SvGlobalName & SvMetaExtern::GetUUId() const
 {
 #ifdef IDL_COMPILER
@@ -667,21 +517,11 @@ const SvGlobalName & SvMetaExtern::GetUUId() const
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*    SvMetaExtern::SetModule()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaExtern::SetModule( SvIdlDataBase & rBase )
 {
     pModule = (SvMetaModule *)rBase.GetStack().Get( TYPE( SvMetaModule ) );
 }
 
-/*************************************************************************
-|*    SvMetaExtern::ReadAttributesSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataBase & rBase,
                                         SvTokenStream & rInStm )
 {
@@ -692,11 +532,6 @@ void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataBase & rBase,
         bReadVersion = TRUE;
 }
 
-/*************************************************************************
-|*    SvMetaExtern::WriteAttributesSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaExtern::WriteAttributesSvIdl( SvIdlDataBase & rBase,
                                          SvStream & rOutStm, USHORT nTab )
 {
@@ -721,34 +556,19 @@ void SvMetaExtern::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaExtern::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaExtern::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 {
     SetModule( rBase );
-    GetUUId(); // Id wird angelegt
+    GetUUId(); // id gets created
     return SvMetaReference::ReadSvIdl( rBase, rInStm );
 }
 
-/*************************************************************************
-|*    SvMetaExtern::WriteSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaExtern::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
                                USHORT nTab )
 {
     SvMetaReference::WriteSvIdl( rBase, rOutStm, nTab );
 }
 
-/*************************************************************************
-|*    SvMetaExtern::Write()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaExtern::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                         USHORT nTab,
                          WriteType nT, WriteAttribute nA )
@@ -756,11 +576,6 @@ void SvMetaExtern::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     SvMetaReference::Write( rBase, rOutStm, nTab, nT, nA );
 }
 
-/*************************************************************************
-|*    SvMetaExtern::WriteAttributes()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaExtern::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
                                      USHORT nTab,
                                      WriteType nT, WriteAttribute nA )
diff --git a/idl/source/objects/bastype.cxx b/idl/source/objects/bastype.cxx
index fff80cc..1c14469 100644
--- a/idl/source/objects/bastype.cxx
+++ b/idl/source/objects/bastype.cxx
@@ -40,7 +40,6 @@
 #include <database.hxx>
 
 #ifdef IDL_COMPILER
-/************************************************************************/
 static BOOL ReadRangeSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm,
                             ULONG nMin, ULONG nMax, ULONG* pValue )
 {
@@ -72,12 +71,6 @@ static BOOL ReadRangeSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm,
 }
 #endif
 
-/*************************************************************************
-|*
-|*    SvUINT32::Read()
-|*    SvUINT32::Write()
-|*
-*************************************************************************/
 UINT32 SvUINT32::Read( SvStream & rStm )
 {
     return SvPersistStream::ReadCompressed( rStm );
@@ -88,12 +81,6 @@ void SvUINT32::Write( SvStream & rStm, UINT32 nVal )
     SvPersistStream::WriteCompressed( rStm, nVal );
 }
 
-/*************************************************************************
-|*
-|*    SvStream& operator << ( SvBOOL )
-|*    SvStream& operator >> ( SvBOOL )
-|*
-*************************************************************************/
 SvStream& operator << (SvStream & rStm, const SvBOOL & rb )
 {
     BYTE n = rb.nVal;
@@ -116,19 +103,13 @@ SvStream& operator >> (SvStream & rStm, SvBOOL & rb )
     return rStm;
 }
 
-/*************************************************************************
-|*
-|*    SvStream& operator << ( SvVersion )
-|*    SvStream& operator >> ( SvVersion )
-|*
-*************************************************************************/
 SvStream& operator << (SvStream & rStm, const SvVersion & r )
 {
     if( (r.GetMajorVersion() || r.GetMinorVersion())
       && r.GetMajorVersion() <= 0x0F && r.GetMinorVersion() <= 0x0F )
-    { // Versionsnummer in 1 Byte komprimieren
-        // Format 4 Bit fuer Major, dann 4 Bit fuer Minor.
-        // 0.0 wird nicht komprimiert
+    { // compress version number in 1 byte
+        // format first 4 bit for major, then 4 bit for minor
+        // 0.0 gets not compressed
 
         int n = r.GetMajorVersion() << 4;
         n |= r.GetMinorVersion();
@@ -148,12 +129,12 @@ SvStream& operator >> (SvStream & rStm, SvVersion & r )
     BYTE n;
     rStm >> n;
     if( n == 0 )
-    { // nicht komprimiert
+    { // not compressed
         rStm >> r.nMajorVersion;
         rStm >> r.nMinorVersion;
     }
     else
-    { // komprimiert
+    { // compressed
         r.nMajorVersion = (n >> 4) & 0x0F;
         r.nMinorVersion = n & 0x0F;
     }
@@ -162,13 +143,6 @@ SvStream& operator >> (SvStream & rStm, SvVersion & r )
 
 
 #ifdef IDL_COMPILER
-/************************************************************************/
-
-/*************************************************************************
-|*
-|*    SvBOOL::ReadSvIdl()
-|*
-*************************************************************************/
 BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
 {
     UINT32 nTokPos = rInStm.Tell();
@@ -191,7 +165,7 @@ BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
                 bOk = rInStm.Read( ')' );
         }
         else
-            *this = TRUE; //Defaultaktion ist auf TRUE setzen
+            *this = TRUE; //default action set to TRUE
         if( bOk )
             return TRUE;
     }
@@ -199,13 +173,6 @@ BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvBOOL::WriteSvIdl()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvBOOL::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm )
 {
     if( nVal )
@@ -215,13 +182,6 @@ BOOL SvBOOL::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm )
     return TRUE;
 }
 
-/*************************************************************************
-|*
-|*    SvBOOL::WriteSvIdl()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 ByteString SvBOOL::GetSvIdlString( SvStringHashEntry * pName )
 {
     if( nVal )
@@ -235,14 +195,6 @@ ByteString SvBOOL::GetSvIdlString( SvStringHashEntry * pName )
 }
 
 
-/************************************************************************/
-/*************************************************************************
-|*
-|*    SvIdentifier::ReadSvIdl()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvIdentifier::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
 {
     UINT32 nTokPos = rInStm.Tell();
@@ -270,13 +222,6 @@ BOOL SvIdentifier::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvIdentifier::WriteSvIdl()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvIdentifier::WriteSvIdl( SvStringHashEntry * pName,
                                SvStream & rOutStm,
                                USHORT /*nTab */ )
@@ -299,14 +244,6 @@ SvStream& operator >> (SvStream & rStm, SvIdentifier & r )
 }
 
 
-/************************************************************************/
-/*************************************************************************
-|*
-|*    SvNumberIdentifier::ReadSvIdl()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
                                     SvStringHashEntry * pName,
                                     SvTokenStream & rInStm )
@@ -331,13 +268,6 @@ BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvNumberIdentifier::ReadSvIdl()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
                                     SvTokenStream & rInStm )
 {
@@ -366,12 +296,6 @@ BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvStream& operator << ( SvNumberIdentifier )
-|*    SvStream& operator >> ( SvNumberIdentifier )
-|*
-*************************************************************************/
 SvStream& operator << (SvStream & rStm, const SvNumberIdentifier & r )
 {
     rStm << (SvIdentifier &)r;
@@ -387,12 +311,6 @@ SvStream& operator >> (SvStream & rStm, SvNumberIdentifier & r )
 }
 
 
-/************************************************************************/
-/*************************************************************************
-|*
-|*    SvString::ReadSvIdl()
-|*
-*************************************************************************/
 BOOL SvString::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
 {
     UINT32 nTokPos = rInStm.Tell();
@@ -420,11 +338,6 @@ BOOL SvString::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvString::WriteSvIdl()
-|*
-*************************************************************************/
 BOOL SvString::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm,
                            USHORT /*nTab */ )
 {
@@ -446,32 +359,16 @@ SvStream& operator >> (SvStream & rStm, SvString & r )
 }
 
 
-/*************************************************************************
-|*
-|*    SvHelpText::ReadSvIdl()
-|*
-*************************************************************************/
 BOOL SvHelpText::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
 {
     return SvString::ReadSvIdl( SvHash_HelpText(), rInStm );
 }
 
-/*************************************************************************
-|*
-|*    SvHelpText::WriteSvIdl()
-|*
-*************************************************************************/
 BOOL SvHelpText::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, USHORT nTab )
 {
     return SvString::WriteSvIdl( SvHash_HelpText(), rOutStm, nTab );
 }
 
-/************************************************************************/
-/*************************************************************************
-|*
-|*    SvUUId::ReadSvIdl()
-|*
-*************************************************************************/
 BOOL SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
 {
     UINT32 nTokPos = rInStm.Tell();
@@ -499,26 +396,15 @@ BOOL SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvMetaObject::WriteSvIdl()
-|*
-*************************************************************************/
 BOOL SvUUId::WriteSvIdl( SvStream & rOutStm )
 {
-    // Global Id schreiben
+    // write global id
     rOutStm << SvHash_uuid()->GetName().GetBuffer() << "(\"";
     rOutStm << ByteString( GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << "\")";
     return TRUE;
 }
 
 
-/************************************************************************/
-/*************************************************************************
-|*
-|*    SvVersion::ReadSvIdl()
-|*
-*************************************************************************/
 BOOL SvVersion::ReadSvIdl( SvTokenStream & rInStm )
 {
     ULONG n = 0;
@@ -543,11 +429,6 @@ BOOL SvVersion::ReadSvIdl( SvTokenStream & rInStm )
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvVersion::WriteSvIdl()
-|*
-*************************************************************************/
 BOOL SvVersion::WriteSvIdl( SvStream & rOutStm )
 {
     rOutStm << SvHash_Version()->GetName().GetBuffer() << '('
diff --git a/idl/source/objects/module.cxx b/idl/source/objects/module.cxx
index 19c6e51..6b7cdcf 100644
--- a/idl/source/objects/module.cxx
+++ b/idl/source/objects/module.cxx
@@ -38,12 +38,8 @@
 #include <tools/fsys.hxx>
 #include <tools/debug.hxx>
 
-/****************** SvMetaModule ******************************************/
 SV_IMPL_META_FACTORY1( SvMetaModule, SvMetaExtern );
 
-/*************************************************************************
-|*    SvMetaModule::SvMetaModule()
-*************************************************************************/
 SvMetaModule::SvMetaModule()
 #ifdef IDL_COMPILER
     : bImported( FALSE )
@@ -60,30 +56,27 @@ SvMetaModule::SvMetaModule( const String & rIdlFileName, BOOL bImp )
 }
 #endif
 
-/*************************************************************************
-|*    SvMetaModule::Load()
-*************************************************************************/
 #define MODULE_VER      0x0001
 void SvMetaModule::Load( SvPersistStream & rStm )
 {
-    bImported = TRUE; // immer importiert
+    bImported = TRUE; // import always
     SvMetaExtern::Load( rStm );
 
     USHORT nVer;
 
-    rStm >> nVer; // Version
+    rStm >> nVer; // version
     DBG_ASSERT( (nVer & ~IDL_WRITE_MASK) == MODULE_VER, "false version" );
 
     rStm >> aClassList;
     rStm >> aTypeList;
     rStm >> aAttrList;
-    // Browser
+    // browser
     rStm.ReadByteString( aIdlFileName );
     rStm.ReadByteString( aHelpFileName );
     rStm.ReadByteString( aSlotIdFile );
     rStm.ReadByteString( aModulePrefix );
 
-    // Compiler Daten lesen
+    // read compiler data
     USHORT nCmpLen;
     rStm >> nCmpLen;
 #ifdef IDL_COMPILER
@@ -97,25 +90,22 @@ void SvMetaModule::Load( SvPersistStream & rStm )
 #endif
 }
 
-/*************************************************************************
-|*    SvMetaModule::Save()
-*************************************************************************/
 void SvMetaModule::Save( SvPersistStream & rStm )
 {
     SvMetaExtern::Save( rStm );
 
-    rStm << (USHORT)(MODULE_VER | IDL_WRITE_COMPILER); // Version
+    rStm << (USHORT)(MODULE_VER | IDL_WRITE_COMPILER); // version
 
     rStm << aClassList;
     rStm << aTypeList;
     rStm << aAttrList;
-    // Browser
+    // browser
     rStm.WriteByteString( aIdlFileName );
     rStm.WriteByteString( aHelpFileName );
     rStm.WriteByteString( aSlotIdFile );
     rStm.WriteByteString( aModulePrefix );
 
-    // Compiler Daten schreiben
+    // write compiler data
     USHORT nCmpLen = 0;
     ULONG nLenPos = rStm.Tell();
     rStm << nCmpLen;
@@ -123,7 +113,7 @@ void SvMetaModule::Save( SvPersistStream & rStm )
     rStm << aBeginName;
     rStm << aEndName;
     rStm << aNextName;
-    // Laenge der Compiler Daten schreiben
+    // write length of compiler data
     ULONG nPos = rStm.Tell();
     rStm.Seek( nLenPos );
     rStm << (USHORT)( nPos - nLenPos - sizeof( USHORT ) );
@@ -131,9 +121,6 @@ void SvMetaModule::Save( SvPersistStream & rStm )
 #endif
 }
 
-/*************************************************************************
-|*    SvMetaModule::SetName()
-*************************************************************************/
 BOOL SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * pBase )
 {
     if( pBase )
@@ -145,9 +132,6 @@ BOOL SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * pBase )
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*    SvMetaModule::GetNextName()
-*************************************************************************/
 BOOL SvMetaModule::FillNextName( SvGlobalName * pName )
 {
     *pName = aNextName;
@@ -161,9 +145,6 @@ BOOL SvMetaModule::FillNextName( SvGlobalName * pName )
     return FALSE;
 }
 
-/*************************************************************************
-|*    SvMetaModule::ReadSvIdl()
-*************************************************************************/
 void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase,
                                         SvTokenStream & rInStm )
 {
@@ -187,9 +168,6 @@ void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase,
     aModulePrefix.ReadSvIdl( SvHash_ModulePrefix(), rInStm );
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteAttributesSvIdl()
-*************************************************************************/
 void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase,
                                          SvStream & rOutStm,
                                          USHORT nTab )
@@ -218,9 +196,6 @@ void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::ReadContextSvIdl()
-*************************************************************************/
 void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
                                      SvTokenStream & rInStm )
 {
@@ -232,7 +207,7 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
         if( aClass->ReadSvIdl( rBase, rInStm ) )
         {
             aClassList.Append( aClass );
-            // Global bekanntgeben
+            // announce globally
             rBase.GetClassList().Append( aClass );
         }
     }
@@ -242,9 +217,9 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
 
         if( aEnum->ReadSvIdl( rBase, rInStm ) )
         {
-            // Im Modul deklariert
+            // declared in module
             aTypeList.Append( aEnum );
-            // Global bekanntgeben
+            // announce globally
             rBase.GetTypeList().Append( aEnum );
         }
     }
@@ -256,9 +231,9 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
 
         if( xItem->ReadSvIdl( rBase, rInStm ) )
         {
-            // Im Modul deklariert
+            // declared in module
             aTypeList.Append( xItem );
-            // Global bekanntgeben
+            // announce globally
             rBase.GetTypeList().Append( xItem );
         }
     }
@@ -276,12 +251,12 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
                 SvTokenStream aTokStm( aFullName.GetFull() );
                 if( SVSTREAM_OK == aTokStm.GetStream().GetError() )
                 {
-                    // Fehler aus alter Datei retten
+                    // rescue error from old file
                     SvIdlError aOldErr = rBase.GetError();
-                    // Fehler zuruecksetzen
+                    // reset error
                     rBase.SetError( SvIdlError() );
 
-                    UINT32 nBeginPos = 0xFFFFFFFF; // kann mit Tell nicht vorkommen
+                    UINT32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
                     while( nBeginPos != aTokStm.Tell() )
                     {
                         nBeginPos = aTokStm.Tell();
@@ -293,7 +268,7 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
                     {
                         rBase.WriteError( aTokStm );
                     }
-                    // Fehler aus alter Datei wieder herstellen
+                    // recover error from old file
                     rBase.SetError( aOldErr );
                 }
                 else
@@ -321,18 +296,15 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
         {
             if( xSlot->Test( rBase, rInStm ) )
             {
-                // Im Modul deklariert
+                // declared in module
                 aAttrList.Append( xSlot );
-                // Global bekanntgeben
+                // announce globally
                 rBase.AppendAttr( xSlot );
             }
         }
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteContextSvIdl()
-*************************************************************************/
 void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase,
                                       SvStream & rOutStm,
                                       USHORT nTab )
@@ -358,12 +330,9 @@ void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::ReadSvIdl()
-*************************************************************************/
 BOOL SvMetaModule::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 {
-    bIsModified = TRUE; // bisher immer wenn Compiler laueft
+    bIsModified = TRUE; // up to now always when compiler running
 
     UINT32  nTokPos = rInStm.Tell();
     SvToken * pTok  = rInStm.GetToken_Next();
@@ -387,24 +356,21 @@ BOOL SvMetaModule::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     {
         aNextName = aBeginName;
 
-        rBase.Push( this ); // auf den Context Stack
+        rBase.Push( this ); // onto the context stack
 
         if( ReadNameSvIdl( rBase, rInStm ) )
         {
-            // Zeiger auf sich selbst setzen
+            // set pointer to itself
             SetModule( rBase );
             bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
         }
-        rBase.GetStack().Pop(); // und runter
+        rBase.GetStack().Pop(); // remove from stack
     }
     if( !bOk )
         rInStm.Seek( nTokPos );
     return bOk;
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteSvIdl()
-*************************************************************************/
 void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
                                USHORT nTab )
 {
@@ -417,9 +383,6 @@ void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
     SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteSfx()
-*************************************************************************/
 void SvMetaModule::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
 {
     for( ULONG n = 0; n < aClassList.Count(); n++ )
@@ -439,9 +402,6 @@ void SvMetaModule::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteAttributes()
-*************************************************************************/
 void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase,
                                     SvStream & rOutStm,
                                      USHORT nTab,
@@ -457,9 +417,6 @@ void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::Write()
-*************************************************************************/
 void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                               USHORT nTab,
                              WriteType nT, WriteAttribute nA )
@@ -516,7 +473,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                 if( pSC )
                     rOutStm << " : " << pSC->GetName().GetBuffer();
 
-                // Importierte Klassen
+                // imported classes
                 const SvClassElementMemberList& rClassList = pClass->GetClassList();
                 if ( rClassList.Count() )
                 {
@@ -538,7 +495,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
             }
         }
         rOutStm << "</CLASSES>" << endl << endl;
-        // kein Break!
+        // no break!
     }
 
     case WRITE_C_SOURCE:
@@ -547,7 +504,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
         for( ULONG n = 0; n < aClassList.Count(); n++ )
         {
             SvMetaClass * pClass = aClassList.GetObject( n );
-            if( !pClass->IsShell() /* && pClass->GetAutomation() */ )
+            if( !pClass->IsShell() )
                 pClass->Write( rBase, rOutStm, nTab, nT, nA );
         }
     }
@@ -558,9 +515,6 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteSrc()
-*************************************************************************/
 void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
                              Table * pTable )
 {
@@ -572,9 +526,6 @@ void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteHxx()
-*************************************************************************/
 void SvMetaModule::WriteHxx( SvIdlDataBase & rBase, SvStream & rOutStm,
                              USHORT nTab )
 {
@@ -585,9 +536,6 @@ void SvMetaModule::WriteHxx( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaModule::WriteCxx()
-*************************************************************************/
 void SvMetaModule::WriteCxx( SvIdlDataBase & rBase, SvStream & rOutStm,
                              USHORT nTab )
 {
diff --git a/idl/source/objects/object.cxx b/idl/source/objects/object.cxx
index 11f4f7e..60e76c6 100644
--- a/idl/source/objects/object.cxx
+++ b/idl/source/objects/object.cxx
@@ -38,23 +38,12 @@
 #include <globals.hxx>
 #include <database.hxx>
 
-/******************** class SvClassElement *******************************/
 SV_IMPL_PERSIST1( SvClassElement, SvPersistBase );
 
-/*************************************************************************
-|*    SvClassElement::SvClassElement()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvClassElement::SvClassElement()
 {
 };
 
-/*************************************************************************
-|*    SvClassElement::Load()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvClassElement::Load( SvPersistStream & rStm )
 {
     BYTE nMask;
@@ -75,43 +64,27 @@ void SvClassElement::Load( SvPersistStream & rStm )
     }
 }
 
-/*************************************************************************
-|*    SvClassElement::Save()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvClassElement::Save( SvPersistStream & rStm )
 {
-    // Maske erstellen
+    // create mask
     BYTE nMask = 0;
     if( aAutomation.IsSet() )          nMask |= 0x1;
     if( aPrefix.Len() )                                nMask |= 0x2;
     if( xClass.Is() )                          nMask |= 0x4;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x01 ) rStm << aAutomation;
     if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
     if( nMask & 0x04 ) rStm << xClass;
 }
 
-/****************** SvMetaClass ******************************************/
 SV_IMPL_META_FACTORY1( SvMetaClass, SvMetaType );
-/*************************************************************************
-|*    SvMetaClass::SvMetaClass()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaClass::SvMetaClass()
     : aAutomation( TRUE, FALSE )
 {
 }
 
-/*************************************************************************
-|*    SvMetaClass::Load()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::Load( SvPersistStream & rStm )
 {
     SvMetaType::Load( rStm );
@@ -141,16 +114,11 @@ void SvMetaClass::Load( SvPersistStream & rStm )
     if( nMask & 0x10 ) rStm >> aAutomation;
 }
 
-/*************************************************************************
-|*    SvMetaClass::Save()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::Save( SvPersistStream & rStm )
 {
     SvMetaType::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     BYTE nMask = 0;
     if( aAttrList.Count() )            nMask |= 0x1;
     if( aSuperClass.Is() )             nMask |= 0x2;
@@ -158,7 +126,7 @@ void SvMetaClass::Save( SvPersistStream & rStm )
     if( xAutomationInterface.Is() ) nMask |= 0x8;
     if( aAutomation.IsSet() )          nMask |= 0x10;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x01 ) rStm << aAttrList;
     if( nMask & 0x02 ) rStm << aSuperClass;
@@ -168,11 +136,6 @@ void SvMetaClass::Save( SvPersistStream & rStm )
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*    SvMetaClass::ReadAttributesSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBase & rBase,
                                         SvTokenStream & rInStm )
 {
@@ -180,11 +143,6 @@ void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBase & rBase,
     aAutomation.ReadSvIdl( SvHash_Automation(), rInStm );
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteAttributesSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::WriteAttributesSvIdl( SvIdlDataBase & rBase,
                                  SvStream & rOutStm, USHORT nTab )
 {
@@ -203,11 +161,6 @@ void SvMetaClass::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaClass::ReadContextSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
                                     SvTokenStream & rInStm )
 {
@@ -232,7 +185,7 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
                     {
                         if( xAutomationInterface.Is() )
                         {
-                            // Fehler setzen
+                            // set error
                             rBase.SetError( "Automation allready set",
                                             rInStm.GetToken() );
                             rBase.WriteError( rInStm );
@@ -242,14 +195,14 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
                     }
                     else
                     {
-                        // Fehler setzen
+                        // set error
                         rBase.SetError( "missing ]", rInStm.GetToken() );
                         rBase.WriteError( rInStm );
                     }
                 }
                 else
                 {
-                    // Fehler setzen
+                    // set error
                     rBase.SetError( "only attribute Automation allowed",
                                     rInStm.GetToken() );
                     rBase.WriteError( rInStm );
@@ -265,7 +218,7 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
         }
         else
         {
-            // Fehler setzen
+            // set error
             rBase.SetError( "unknown imported interface", rInStm.GetToken() );
             rBase.WriteError( rInStm );
         }
@@ -307,11 +260,6 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
     rInStm.Seek( nTokPos );
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteContextSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::WriteContextSvIdl
 (
     SvIdlDataBase & rBase,
@@ -319,7 +267,6 @@ void SvMetaClass::WriteContextSvIdl
     USHORT nTab
 )
 {
-    //SvMetaType::WriteContextSvIdl( rBase, rOutStm, nTab );
     ULONG n;
     for( n = 0; n < aAttrList.Count(); n++ )
     {
@@ -342,11 +289,6 @@ void SvMetaClass::WriteContextSvIdl
     }
 }
 
-/*************************************************************************
-|*    SvMetaClass::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 {
     ULONG nTokPos = rInStm.Tell();
@@ -359,7 +301,7 @@ BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
             bOk = aSuperClass.Is();
             if( !bOk )
             {
-                // Fehler setzen
+                // set error
                 rBase.SetError( "unknown super class",
                                 rInStm.GetToken() );
                 rBase.WriteError( rInStm );
@@ -377,11 +319,6 @@ BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     return FALSE;
 }
 
-/*************************************************************************
-|*    SvMetaClass::TestAttribute()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
                                  SvMetaAttribute & rAttr ) const
 {
@@ -396,7 +333,7 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
         SvMetaAttribute * pS = aAttrList.GetObject( n );
         if( pS->GetName() == rAttr.GetName() )
         {
-            // Werte muessen uebereinstimmen
+            // values have to match
             if( pS->GetSlotId().GetValue() != rAttr.GetSlotId().GetValue() )
             {
                 DBG_ERROR( "Gleicher Name in MetaClass : " );
@@ -416,7 +353,7 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
         {
             UINT32 nId1 = pS->GetSlotId().GetValue();
             UINT32 nId2 = rAttr.GetSlotId().GetValue();
-            if( nId1 == nId2 && nId1 != 0 /*&& nId2 != 0 ist ueberfluessig*/ )
+            if( nId1 == nId2 && nId1 != 0 )
             {
                 DBG_ERROR( "Gleiche Id in MetaClass : " );
                 DBG_ERROR( ByteString::CreateFromInt32( pS->GetSlotId().GetValue() ).GetBuffer() );
@@ -440,11 +377,6 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
     return TRUE;
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
                               USHORT nTab )
 {
@@ -456,11 +388,6 @@ void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
     rOutStm << endl;
 }
 
-/*************************************************************************
-|*    SvMetaClass::Write()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                         USHORT nTab,
                          WriteType nT, WriteAttribute )
@@ -489,7 +416,7 @@ void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
             WriteDescription( rOutStm );
             rOutStm    << "</INTERFACE>" << endl << endl;
 
-            // alle Attribute schreiben
+            // write all attributes
             ULONG n;
             for( n = 0; n < aAttrList.Count(); n++ )
             {
@@ -511,11 +438,6 @@ void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteSlotParamArray()
-|*
-|*    Beschreibung
-*************************************************************************/
 USHORT SvMetaClass::WriteSlotParamArray( SvIdlDataBase & rBase,
                                         SvSlotElementList & rSlotList,
                                         SvStream & rOutStm )
@@ -531,11 +453,6 @@ USHORT SvMetaClass::WriteSlotParamArray( SvIdlDataBase & rBase,
     return nCount;
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteSlots()
-|*
-|*    Beschreibung
-*************************************************************************/
 USHORT SvMetaClass::WriteSlots( const ByteString & rShellName,
                                 USHORT nCount, SvSlotElementList & rSlotList,
                                 SvIdlDataBase & rBase,
@@ -555,23 +472,18 @@ USHORT SvMetaClass::WriteSlots( const ByteString & rShellName,
     return nSCount;
 }
 
-/*************************************************************************
-|*    SvMetaClass::InsertSlots()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList,
                             SvMetaClassList &rClassList,
                             const ByteString & rPrefix, SvIdlDataBase& rBase)
 {
-    // Wurde diese Klasse schon geschrieben ?
+    // was this class already written?
     for ( size_t i = 0, n = rClassList.size(); i < n ; ++i )
         if ( rClassList[ i ] == this )
             return;
 
     rClassList.push_back( this );
 
-    // alle direkten Attribute schreiben
+    // write all direct attributes
     ULONG n;
     for( n = 0; n < aAttrList.Count(); n++ )
     {
@@ -587,22 +499,22 @@ void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList,
 
         if( nPos == rSuperList.Count() )
         {
-            // nur schreiben, wenn nicht schon bei SubClass oder
-            // importiertem Interface geschrieben
+            // Write only if not already written by subclass or
+            // imported interface.
             rSuperList.Insert( nId, nPos );
             pAttr->Insert(rList, rPrefix, rBase);
         }
     }
 
-    // Alle schon von SuperShells importierten Interfaces sollen nicht
-    // mehr geschrieben werden
-    // Es ist also verboten, da\s Shell und SuperShell die gleiche Klasse
-    // direkt importieren !
+    // All Interfaces already imported by SuperShells should not be
+    // written any more.
+    // It is prohibited that Shell and SuperShell directly import the same
+    //class.
     if( IsShell() && aSuperClass.Is() )
         aSuperClass->FillClasses( rClassList );
 
-    // alle Attribute der importierten Klassen schreiben, sofern diese nicht
-    // schon von der Superklasse importiert wurden
+    // Write all attributes of the imported classes, as long as they have
+    // not already been imported by the superclass.
     for( n = 0; n < aClassList.Count(); n++ )
     {
         SvClassElement * pEle = aClassList.GetObject( n );
@@ -612,32 +524,27 @@ void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList,
             rPre += '.';
         rPre += pEle->GetPrefix();
 
-        // Zun"achst die direkt importierten Interfaces schreiben
+        // first of all write direct imported interfaces
         pCl->InsertSlots( rList, rSuperList, rClassList, rPre, rBase );
     }
 
-    // Superklassen nur schreiben, wenn keine Shell und nicht in der Liste
+    // only write superclass if no shell and not in the list
     if( !IsShell() && aSuperClass.Is() )
     {
         aSuperClass->InsertSlots( rList, rSuperList, rClassList, rPrefix, rBase );
     }
 }
 
-/*************************************************************************
-|*    SvMetaClass::FillClasses()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::FillClasses( SvMetaClassList & rList )
 {
-    // Bin ich noch nicht drin ?
+    // Am I not yet in?
     for ( size_t i = 0, n = rList.size(); i < n; ++i )
         if ( rList[ i ] == this )
             return;
 
     rList.push_back( this );
 
-    // Meine Imports
+    // my imports
     for( ULONG n = 0; n < aClassList.Count(); n++ )
     {
         SvClassElement * pEle = aClassList.GetObject( n );
@@ -645,23 +552,18 @@ void SvMetaClass::FillClasses( SvMetaClassList & rList )
         pCl->FillClasses( rList );
     }
 
-    // Meine Superklasse
+    // my superclass
     if( aSuperClass.Is() )
         aSuperClass->FillClasses( rList );
 }
 
 
-/*************************************************************************
-|*    SvMetaClass::WriteSlotStubs()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::WriteSlotStubs( const ByteString & rShellName,
                                 SvSlotElementList & rSlotList,
                                 ByteStringList & rList,
                                 SvStream & rOutStm )
 {
-    // alle Attribute schreiben
+    // write all attributes
     for( ULONG n = 0; n < rSlotList.Count(); n++ )
     {
         SvSlotElement *pEle = rSlotList.GetObject( n );
@@ -670,27 +572,22 @@ void SvMetaClass::WriteSlotStubs( const ByteString & rShellName,
     }
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteSfx()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
 {
     WriteStars( rOutStm );
-    // Klasse definieren
+    // define class
     rOutStm << "#ifdef " << GetName().GetBuffer() << endl;
     rOutStm << "#undef ShellClass" << endl;
     rOutStm << "#undef " << GetName().GetBuffer() << endl;
     rOutStm << "#define ShellClass " << GetName().GetBuffer() << endl;
 
-    // Fuer Interfaces werden kein Slotmaps geschrieben
+    // no slotmaps get written for interfaces
     if( !IsShell() )
     {
         rOutStm << "#endif" << endl << endl;
         return;
     }
-    // Parameter Array schreiben
+    // write parameter array
     rOutStm << "SFX_ARGUMENTMAP(" << GetName().GetBuffer() << ')' << endl
         << '{' << endl;
 
@@ -707,13 +604,13 @@ void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
 
     ULONG nSlotCount = aSlotList.Count();
 
-    // alle Attribute schreiben
+    // write all attributes
     USHORT nArgCount = WriteSlotParamArray( rBase, aSlotList, rOutStm );
     if( nArgCount )
         Back2Delemitter( rOutStm );
     else
     {
-        // mindestens einen dummy
+        // at leaast one dummy
         WriteTab( rOutStm, 1 );
         rOutStm << "SFX_ARGUMENT( 0, 0, SfxVoidItem )" << endl;
     }
@@ -727,17 +624,17 @@ void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
 
     rOutStm << endl;
 
-    // Slotmap schreiben
+    // write slotmap
     rOutStm << "SFX_SLOTMAP_ARG(" << GetName().GetBuffer() << ')' << endl
         << '{' << endl;
 
-    // alle Attribute schreiben
+    // write all attributes
     WriteSlots( GetName(), 0, aSlotList, rBase, rOutStm );
     if( nSlotCount )
         Back2Delemitter( rOutStm );
     else
     {
-        // mindestens einen dummy
+        // at least one dummy
         WriteTab( rOutStm, 1 );
         rOutStm << "SFX_SLOT_ARG(" << GetName().GetBuffer()
                 << ", 0, 0, "
@@ -769,9 +666,6 @@ void SvMetaClass::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaShell::WriteSrc()
-*************************************************************************/
 void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
                              Table * pTable )
 {
@@ -782,11 +676,6 @@ void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteHxx()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, USHORT )
 {
     ByteString aSuperName( "SvDispatch" );
@@ -812,11 +701,6 @@ void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, USHORT )
     << "};" << endl;
 }
 
-/*************************************************************************
-|*    SvMetaClass::WriteCxx()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaClass::WriteCxx( SvIdlDataBase &, SvStream & rOutStm, USHORT )
 {
     ByteString aSuperName( "SvDispatch" );
diff --git a/idl/source/objects/slot.cxx b/idl/source/objects/slot.cxx
index bff0efa..837d770 100644
--- a/idl/source/objects/slot.cxx
+++ b/idl/source/objects/slot.cxx
@@ -36,7 +36,6 @@
 #include <globals.hxx>
 #include <database.hxx>
 
-/****************** SvMetaSlot *****************************************/
 SV_IMPL_META_FACTORY1( SvMetaSlot, SvMetaAttribute );
 
 SvMetaObject *SvMetaSlot::MakeClone() const
@@ -44,12 +43,6 @@ SvMetaObject *SvMetaSlot::MakeClone() const
         return new SvMetaSlot( *this );
 }
 
-/*************************************************************************
-|*       SvMetaSlot::SvMetaSlot()
-|*
-|*       Beschreibung          Zweites FALSE bei den SvBOOL-Objekten bedeutet,
-|*                                             IsSet() liefert FALSE (Defaultinitialisierung).
-*************************************************************************/
 SvMetaSlot::SvMetaSlot()
     : aCachable( TRUE, FALSE )
     , aSynchron( TRUE, FALSE )
@@ -73,17 +66,6 @@ SvMetaSlot::SvMetaSlot( SvMetaType * pType )
 {
 }
 
-/*
-#define TEST_READ                                                                                  
            \
-{                                                                                                  
                            \
-    UINT32     nPos;                                                                               
            \
-    rStm >> nPos;                                                                                  
            \
-    DBG_ASSERT( nPos +4 == rStm.Tell(), "stream pos error" );   \
-}
-
-#define TEST_WRITE                                                                                 
            \
-    rStm << (UINT32)rStm.Tell();
-*/
 #define TEST_READ
 #define TEST_WRITE
 
@@ -188,7 +170,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
 {
     SvMetaAttribute::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     USHORT nMask = 0;
     if( aMethod.Is() )                 nMask |= 0x0001;
     if( aGroupId.Len() )               nMask |= 0x0002;
@@ -207,7 +189,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
     if( aSynchron.IsSet() )    nMask |= 0x4000;
     if( aAsynchron.IsSet() )   nMask |= 0x8000;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     TEST_WRITE
     if( nMask & 0x0001 ) rStm << aMethod;
@@ -242,8 +224,8 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
     TEST_WRITE
     if( nMask & 0x8000 ) rStm << aAsynchron;
 
-    // naechste Fuhre schreiben
-    // Maske erstellen
+    // write next bunch
+    // create mask
     nMask = 0;
     if( aRecordPerItem.IsSet() )  nMask |= 0x0001;
     if( aRecordManual.IsSet() )   nMask |= 0x0002;
@@ -262,7 +244,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
     if( aRecordAbsolute.IsSet() ) nMask |= 0x4000;
     if( aImageRotation.IsSet() )       nMask |= 0x8000;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     TEST_WRITE
     if( nMask & 0x0001 ) rStm << aRecordPerItem;
@@ -307,21 +289,11 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
     if( nMask & 0x0002 ) rStm << aImageReflection;
 }
 
-/*************************************************************************
-|*       SvMetaSlot::IsVariable()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaSlot::IsVariable() const
 {
     return SvMetaAttribute::IsVariable();
 }
 
-/*************************************************************************
-|*       SvMetaSlot::IsMethod()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaSlot::IsMethod() const
 {
     BOOL b = SvMetaAttribute::IsMethod();
@@ -329,11 +301,6 @@ BOOL SvMetaSlot::IsMethod() const
     return b;
 }
 
-/*************************************************************************
-|*       SvMetaSlot::HasMethods()
-|*
-|*       Beschreibung
-*************************************************************************/
 ByteString SvMetaSlot::GetMangleName( BOOL bVariable ) const
 {
     if( !bVariable )
@@ -346,12 +313,12 @@ ByteString SvMetaSlot::GetMangleName( BOOL bVariable ) const
 }
 
 /*************************************************************************
-|*       Referenz
+|*       reference
 |*
-|*       Beschreibung          Zweites FALSE bei den SvBOOL-Objekten bedeutet,
-|*                                             IsSet() liefert FALSE (Defaultinitialisierung).
+|*       description           Second FALSE in the SvBOOL-Objects means
+|*                                             IsSet() provides FALSE (default initialization).
 *************************************************************************/
-/** Referenz Aufloesung **/
+/** reference disbandment **/
 SvMetaType * SvMetaSlot::GetSlotType() const
 {
     if( aSlotType.Is() || !GetRef() ) return aSlotType;
@@ -402,28 +369,16 @@ BOOL SvMetaSlot::GetPseudoSlots() const
     if( aPseudoSlots.IsSet() || !GetRef() ) return aPseudoSlots;
     return ((SvMetaSlot *)GetRef())->GetPseudoSlots();
 }
-/*
-BOOL SvMetaSlot::GetGet() const
-{
-    if( aGet.IsSet() || !GetRef() ) return aGet;
-    return ((SvMetaSlot *)GetRef())->GetGet();
-}
-BOOL SvMetaSlot::GetSet() const
-{
-    if( aSet.IsSet() || !GetRef() ) return aSet;
-    return ((SvMetaSlot *)GetRef())->GetSet();
-}
-*/
 BOOL SvMetaSlot::GetCachable() const
 {
-    // Cachable und Volatile sind exclusiv
+    // Cachable and Volatile are exclusive
     if( !GetRef() || aCachable.IsSet() || aVolatile.IsSet() )
          return aCachable;
     return ((SvMetaSlot *)GetRef())->GetCachable();
 }
 BOOL SvMetaSlot::GetVolatile() const
 {
-    // Cachable und Volatile sind exclusiv
+    // Cachable and Volatile are exclusive
     if( !GetRef() || aVolatile.IsSet() || aCachable.IsSet() )
         return aVolatile;
     return ((SvMetaSlot *)GetRef())->GetVolatile();
@@ -440,21 +395,21 @@ BOOL SvMetaSlot::GetAutoUpdate() const
 }
 BOOL SvMetaSlot::GetSynchron() const
 {
-    // Synchron und Asynchron sind exclusiv
+    // Synchron and Asynchron are exclusive
     if( !GetRef() || aSynchron.IsSet() || aAsynchron.IsSet() )
         return aSynchron;
     return ((SvMetaSlot *)GetRef())->GetSynchron();
 }
 BOOL SvMetaSlot::GetAsynchron() const
 {
-    // Synchron und Asynchron sind exclusiv
+    // Synchron and Asynchron are exclusive
     if( !GetRef() || aAsynchron.IsSet() || aSynchron.IsSet() )
         return aAsynchron;
     return ((SvMetaSlot *)GetRef())->GetAsynchron();
 }
 BOOL SvMetaSlot::GetRecordPerItem() const
 {
-    // Record- PerItem, No, PerSet und Manual sind exclusiv
+    // Record- PerItem, No, PerSet and Manual are exclusive
     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
         return aRecordPerItem;
@@ -462,7 +417,7 @@ BOOL SvMetaSlot::GetRecordPerItem() const
 }
 BOOL SvMetaSlot::GetRecordPerSet() const
 {
-    // Record- PerItem, No, PerSet und Manual sind exclusiv
+    // Record- PerItem, No, PerSet and Manual are exclusive
     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
         return aRecordPerSet;
@@ -470,7 +425,7 @@ BOOL SvMetaSlot::GetRecordPerSet() const
 }
 BOOL SvMetaSlot::GetRecordManual() const
 {
-    // Record- PerItem, No, PerSet und Manual sind exclusiv
+    // Record- PerItem, No, PerSet and Manual are exclusive
     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
         return aRecordManual;
@@ -478,7 +433,7 @@ BOOL SvMetaSlot::GetRecordManual() const
 }
 BOOL SvMetaSlot::GetNoRecord() const
 {
-    // Record- PerItem, No, PerSet und Manual sind exclusiv
+    // Record- PerItem, No, PerSet and Manual are exclusive
     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
       || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
         return aNoRecord;
@@ -549,48 +504,7 @@ const ByteString& SvMetaSlot::GetUnoName() const
     return ((SvMetaSlot *)GetRef())->GetUnoName();
 }
 
-/*************************************************************************
-|*       SvMetaSlot::FillSbxObject()
-|*
-|*       Beschreibung
-*************************************************************************/
-/*
-void SvMetaSlot::FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj,
-                                BOOL bVariable )
-{
-    // keine Attribut fuer Automation
-    if( !GetAutomation() || !GetExport() )
-        return;
-
-    if( !bVariable )
-    {
-        SvMetaAttributeRef xM = GetMethod();
-        if( xM.Is() )
-        {
-            SvMetaType *       pType = xM->GetType();
-            SvMetaType *       pRetBaseType = pType->GetReturnType()->GetBaseType();
-            ByteString                 aName = xM->GetName();
-
-            SbxMethodRef xMeth = new SbxMethod( aName,
-                                    pRetBaseType->GetSbxDataType() );
-            pType->FillSbxObject( xMeth, bVariable );
-            xMeth->SetUserData( MakeSlotValue(rBase, FALSE) );
-
-            pObj->Insert( &xMeth );
-            return;
-        }
-    }
-
-    SvMetaAttribute::FillSbxObject( rBase, pObj, bVariable );
-}
- */
-
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*       SvMetaSlot::ReadAttributesSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
                                     SvTokenStream & rInStm )
 {
@@ -717,11 +631,6 @@ void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*       SvMetaSlot::WriteAttributesSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
                        SvStream & rOutStm,
                        USHORT nTab )
@@ -800,7 +709,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     if( aVolatile )
         aOut += aVolatile.GetSvIdlString( SvHash_Volatile() );
     else if( !aCachable )
-        // wegen Default == TRUE, nur wenn kein anderer gesetzt
+        // because of Default == TRUE, only when no other is set
         aOut += aCachable.GetSvIdlString( SvHash_Cachable() );
     else
         aDel.Erase();
@@ -820,7 +729,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     if( aAsynchron )
         ( aOut += aDel ) += aAsynchron.GetSvIdlString( SvHash_Asynchron() );
     else if( !aSynchron )
-        // wegen Default == TRUE, nur wenn kein anderer gesetzt
+        // because of Default == TRUE, only when no other is set
         ( aOut += aDel ) += aSynchron.GetSvIdlString( SvHash_Synchron() );
     else
         aDel1 = aDel;
@@ -831,7 +740,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     else if( aNoRecord )
         ( aOut += aDel1 ) += aNoRecord.GetSvIdlString( SvHash_NoRecord() );
     else if( !aRecordPerSet )
-        // wegen Default == TRUE, nur wenn kein anderer gesetzt
+        // because of Default == TRUE, only when no other is set
         ( aOut += aDel1 ) += aRecordPerSet.GetSvIdlString( SvHash_RecordPerSet() );
     else if( aRecordPerItem )
         ( aOut += aDel1 ) += aRecordPerItem.GetSvIdlString( SvHash_RecordPerItem() );
@@ -898,11 +807,6 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
 }
 
 
-/*************************************************************************
-|*       SvMetaSlot::Test()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 {
     BOOL bOk = SvMetaAttribute::Test( rBase, rInStm );
@@ -922,11 +826,6 @@ BOOL SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     return bOk;
 }
 
-/*************************************************************************
-|*       SvMetaSlot::ReadSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 {
     UINT32     nTokPos         = rInStm.Tell();
@@ -935,7 +834,7 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, GetType() );
     if( pAttr )
     {
-        // F"ur Testzwecke: Referenz bei Kurz-Syntax
+        // c
         SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr );
         if( pKnownSlot )
         {
@@ -960,13 +859,13 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
         SvMetaAttribute *pAttr2 = rBase.SearchKnownAttr( GetSlotId() );
         if( pAttr2 )
         {
-            // F"ur Testzwecke: Referenz bei kompletter Definition
+            // for testing purposes: reference in case of complete definition
             SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr2 );
             if( pKnownSlot )
             {
                 SetRef( pKnownSlot );
 
-                  // Namen d"urfen abweichen, da mit angegeben
+                  // names may differ, because explicitly given
                 if ( pKnownSlot->GetName() != GetName() )
                 {
                     DBG_ERROR("Illegal definition!");
@@ -994,22 +893,12 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
     return bOk;
 }
 
-/*************************************************************************
-|*       SvMetaSlot::WriteSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaSlot::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
                             USHORT nTab )
 {
     SvMetaAttribute::WriteSvIdl( rBase, rOutStm, nTab );
 }
 
-/*************************************************************************
-|*       SvMetaSlot::Write()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaSlot::Write( SvIdlDataBase & rBase,
                         SvStream & rOutStm, USHORT nTab,
                         WriteType nT, WriteAttribute nA )
@@ -1021,7 +910,7 @@ void SvMetaSlot::Write( SvIdlDataBase & rBase,
     }
     else
     {
-        // keine Attribut fuer Automation
+        // no attribute for Automation
         if( !GetAutomation() || !GetExport() )
             return;
     }
@@ -1045,7 +934,7 @@ void SvMetaSlot::Write( SvIdlDataBase & rBase,
 void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix,
                         SvIdlDataBase& rBase)
 {
-    // Einf"ugeposition durch bin"are Suche in der SlotListe ermitteln
+    // get insert position through binary search in slotlist
     USHORT nId = (USHORT) GetSlotId().GetValue();
     USHORT nListCount = (USHORT) rList.Count();
     USHORT nPos;
@@ -1099,18 +988,18 @@ void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & 
rPrefix,
 
     rList.Insert( new SvSlotElement( this, rPrefix ), nPos );
 
-    // EnumSlots plattklopfen
+    // iron out EnumSlots
     SvMetaTypeEnum * pEnum = NULL;
     SvMetaType * pBType = GetType()->GetBaseType();
     pEnum = PTR_CAST( SvMetaTypeEnum, pBType );
     if( GetPseudoSlots() && pEnum && pEnum->Count() )
     {
-        // Den MasterSlot clonen
+        // clone the MasterSlot
         SvMetaSlotRef xEnumSlot;
         SvMetaSlot *pFirstEnumSlot = NULL;
         for( ULONG n = 0; n < pEnum->Count(); n++ )
         {
-            // Die SlotId erzeugen
+            // create SlotId
             SvMetaEnumValue *enumValue = pEnum->GetObject(n);
             ByteString aValName = enumValue->GetName();
             ByteString aSId( GetSlotId() );
@@ -1145,24 +1034,24 @@ void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & 
rPrefix,
                 }
             }
 
-            // Die Slaves sind kein Master !
+            // The slaves are no master!
             xEnumSlot->aPseudoSlots = FALSE;
             xEnumSlot->SetEnumValue(enumValue);
 
             if ( !pFirstEnumSlot || xEnumSlot->GetSlotId().GetValue() < 
pFirstEnumSlot->GetSlotId().GetValue() )
                 pFirstEnumSlot = xEnumSlot;
 
-            // Den erzeugten Slave ebenfalls einf"ugen
+            // insert the created slave as well
             xEnumSlot->Insert( rList, rPrefix, rBase);
 
-            // Die EnumSlots mit dem Master verketten
+            // concatenate the EnumSlots with the master
             xEnumSlot->pLinkedSlot = this;
         }
 
-        // Master zeigt auf den ersten Slave
+        // master points to the first slave
         pLinkedSlot = pFirstEnumSlot;
 
-        // Slaves untereinander verketten
+        // concatenate slaves among themselves
         rList.Seek((ULONG)0);
         xEnumSlot = pFirstEnumSlot;
         SvSlotElement *pEle;
@@ -1181,11 +1070,6 @@ void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & 
rPrefix,
 }
 
 
-/*************************************************************************
-|*       SvMetaSlot::WriteSlotMap()
-|*
-|*       Beschreibung
-*************************************************************************/
 static ByteString MakeSlotName( SvStringHashEntry * pEntry )
 {
     ByteString aName( "SFX_SLOT_" );
@@ -1258,7 +1142,6 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
     if ( !GetExport() && !GetHidden() )
         return;
 
-//     BOOL bIsEnumSlot = 0 != rValueName.Len();
     BOOL bIsEnumSlot = 0 != pEnumValue;
 
     rOutStm << "// Slot Nr. " << ByteString::CreateFromInt32(nListPos).GetBuffer() << " : ";
@@ -1307,8 +1190,8 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
     }
     else
     {
-        // Den n"achsten Slot suchen, der die gleiche StateMethod hat wie ich
-        // Die SlotList ist auf den aktuellen Slot geseekt
+        // look for the next slot with the same StateMethod like me
+        // the slotlist is set to the current slot
         SvSlotElement * pEle = rSlotList.Next();
         pNextSlot = pEle ? &pEle->xSlot : NULL;
         while ( pNextSlot )
@@ -1322,9 +1205,8 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
 
         if ( !pNextSlot )
         {
-            // Es gibt nach mir keinen Slot mehr, der die gleiche ExecMethode
-            // hat. Also suche ich den ersten Slot, der diese hatte (das
-            // k"onnte auch ich selbst sein)
+            // There is no slot behind me that has the same ExecMethod.
+            // So I search for the first slot with it (could be myself).
             pEle = rSlotList.First();
             pNextSlot = pEle ? &pEle->xSlot : NULL;
             while ( pNextSlot != this )
@@ -1355,7 +1237,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
 
         WriteTab( rOutStm, 4 );
 
-        // ExecMethod schreiben, wenn nicht angegeben, standard Namen
+        // write ExecMethod, with standard name if not specified
         if( GetExecMethod().Len() && GetExecMethod() != "NoExec")
             rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ','
                     << GetExecMethod().GetBuffer() << ')';
@@ -1363,7 +1245,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
             rOutStm << "SFX_STUB_PTR_EXEC_NONE";
         rOutStm << ',';
 
-        // StateMethod schreiben, wenn nicht angegeben, standard Namen
+        // write StateMethod, with standard name if not specified
         if( GetStateMethod().Len() && GetStateMethod() != "NoState")
             rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ','
                     << GetStateMethod().GetBuffer() << ')';
@@ -1373,7 +1255,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
     rOutStm << ',' << endl;
     WriteTab( rOutStm, 4 );
 
-    // Flags schreiben
+    // write flags
     if( GetHasCoreId() )
         rOutStm << MakeSlotName( SvHash_HasCoreId() ).GetBuffer() << '|';
     if( GetCachable() )
@@ -1427,7 +1309,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
     else
         rOutStm << GetDisableFlags().GetBuffer();
 
-    // Attribut Typ schreiben
+    // write attribute type
     if( !bIsEnumSlot )
     {
         rOutStm << ',' << endl;
@@ -1477,7 +1359,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
         else
             rOutStm << '0';
 
-        // Name f"urs Recording
+        // name for recording
         if ( GetExport() )
         {
             rOutStm << ",\"";
@@ -1492,7 +1374,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
         else
             rOutStm << ", 0, ";
 
-        // Method/Property Flags
+        // Method/Property flags
         if( IsMethod() )
             rOutStm << "SFX_SLOT_METHOD|";
         if( IsVariable() )
@@ -1505,15 +1387,11 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
         rOutStm << '0';
     }
 
-//    if ( GetUnoName().Len() )
     {
         rOutStm << ",\"";
         rOutStm << GetMangleName( FALSE ).GetBuffer();
-        //rOutStm << GetUnoName().GetBuffer();
         rOutStm << "\"";
     }
-//    else
-//        rOutStm << ", 0";
 
     rOutStm << " )," << endl;
 }
@@ -1544,9 +1422,9 @@ USHORT SvMetaSlot::WriteSlotParamArray( SvIdlDataBase & rBase, SvStream & 
rOutSt
             WriteTab( rOutStm, 1 );
             rOutStm << "SFX_ARGUMENT("
                 << pPar->GetSlotId().GetBuffer() << ',' // SlodId
-                // Parameter Name
+                // parameter name
                 << "\"" << pPar->GetName().GetBuffer() << "\","
-                // Item Name
+                // item name
                 << pPType->GetName().GetBuffer() << ")," << endl;
             if( !rBase.FindType( pPType, rBase.aUsedTypes ) )
                 rBase.aUsedTypes.Append( pPType );
@@ -1562,7 +1440,7 @@ USHORT SvMetaSlot::WriteSlotMap( const ByteString & rShellName, USHORT nCount,
                                 SvIdlDataBase & rBase,
                                 SvStream & rOutStm )
 {
-    // SlotId, wenn nicht angegeben, aus Namen generieren
+    // SlotId, if not specified generate from name
     ByteString slotId = GetSlotId();
 
     USHORT nSCount = 0;
@@ -1582,9 +1460,6 @@ USHORT SvMetaSlot::WriteSlotMap( const ByteString & rShellName, USHORT nCount,
     return nSCount;
 }
 
-/*************************************************************************
-|*       SvMetaSlot::WriteSrc()
-*************************************************************************/
 void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
                              Table * pTable )
 {
@@ -1635,7 +1510,7 @@ void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
                 bIdOk = TRUE;
             }
 
-            // wenn Id nicht gefunden, immer schreiben
+            // if id not found, write always
             if( !bIdOk || !pTable->IsKeyValid( nSId2 ) )
             {
                 pTable->Insert( nSId2, this );
@@ -1687,7 +1562,7 @@ void SvMetaSlot::WriteHelpId( SvIdlDataBase & rBase, SvStream & rOutStm,
                 bIdOk = TRUE;
             }
 
-            // wenn Id nicht gefunden, immer schreiben
+            // if id not found, write always
             if( !bIdOk || !pTable->IsKeyValid( nSId2 ) )
             {
                 pTable->Insert( nSId2, this );
diff --git a/idl/source/objects/types.cxx b/idl/source/objects/types.cxx
index e57a418..b0a9730 100644
--- a/idl/source/objects/types.cxx
+++ b/idl/source/objects/types.cxx
@@ -38,14 +38,7 @@
 #include <globals.hxx>
 #include <database.hxx>
 
-/****************** SvMetaAttribute *************************************/
-/************************************************************************/
 SV_IMPL_META_FACTORY1( SvMetaAttribute, SvMetaReference );
-/*************************************************************************
-|*    SvMetaAttribute::SvMetaAttribute()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaAttribute::SvMetaAttribute()
     : aAutomation( TRUE, FALSE )
     , aExport( TRUE, FALSE )
@@ -67,12 +60,6 @@ SvMetaAttribute::SvMetaAttribute( SvMetaType * pType )
 {
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::Load()
-|*    SvMetaAttribute::Save()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::Load( SvPersistStream & rStm )
 {
     SvMetaReference::Load( rStm );
@@ -98,7 +85,7 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
 {
     SvMetaReference::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     BYTE nMask = 0;
     if( aType.Is() )                   nMask |= 0x1;
     if( aSlotId.IsSet() )              nMask |= 0x2;
@@ -109,7 +96,7 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
     if( aReadOnlyDoc.IsSet() )  nMask |= 0x40;
     if( aHidden.IsSet() )              nMask |= 0x80;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x1 )  rStm << aType;
     if( nMask & 0x2 )  rStm << aSlotId;
@@ -121,59 +108,33 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
     if( nMask & 0x80 )  rStm << aHidden;
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::GetType()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaType * SvMetaAttribute::GetType() const
 {
     if( aType.Is() || !GetRef() ) return aType;
     return ((SvMetaAttribute *)GetRef())->GetType();
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::GetSlotId()
-|*
-|*    Beschreibung
-*************************************************************************/
 const SvNumberIdentifier & SvMetaAttribute::GetSlotId() const
 {
     if( aSlotId.IsSet() || !GetRef() ) return aSlotId;
     return ((SvMetaAttribute *)GetRef())->GetSlotId();
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::GetReadonly()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaAttribute::GetReadonly() const
 {
     if( aReadonly.IsSet() || !GetRef() ) return aReadonly;
     return ((SvMetaAttribute *)GetRef())->GetReadonly();
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::GetExport()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaAttribute::GetExport() const
 {
     if( aExport.IsSet() || !GetRef() ) return aExport;
     return ((SvMetaAttribute *)GetRef())->GetExport();
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::GetHidden()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaAttribute::GetHidden() const
 {
-    // Wenn Export gesetzt wurde, aber Hidden nicht, gilt der Default
-    // aHidden = !aExport
+    // when export is set, but hidden is not the default is used
     if ( aExport.IsSet() && !aHidden.IsSet() )
         return !aExport;
     else if( aHidden.IsSet() || !GetRef() )
@@ -182,11 +143,6 @@ BOOL SvMetaAttribute::GetHidden() const
         return ((SvMetaAttribute *)GetRef())->GetHidden();
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::GetAutomation()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaAttribute::GetAutomation() const
 {
     if( aAutomation.IsSet() || !GetRef() ) return aAutomation;
@@ -216,13 +172,6 @@ BOOL SvMetaAttribute::GetReadOnlyDoc() const
     return ((SvMetaSlot *)GetRef())->GetReadOnlyDoc();
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::IsMethod()
-|*    SvMetaAttribute::IsVariable()
-|*       SvMetaAttribute::GetMangleName()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaAttribute::IsMethod() const
 {
     SvMetaType * pType = GetType();
@@ -242,11 +191,6 @@ ByteString SvMetaAttribute::GetMangleName( BOOL ) const
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*    SvMetaAttribute::Test()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase,
                             SvTokenStream & rInStm )
 {
@@ -260,17 +204,12 @@ BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase,
     return bOk;
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
                                      SvTokenStream & rInStm )
 {
     UINT32  nTokPos     = rInStm.Tell();
     if( !GetType() )
-        // Es wurde kein Typ im ctor mitgegeben
+        // no type in ctor passed on
         aType = rBase.ReadKnownType( rInStm );
     BOOL bOk = FALSE;
     if( GetType() )
@@ -298,11 +237,6 @@ BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
     return bOk;
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::WriteSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::WriteSvIdl
 (
     SvIdlDataBase & rBase,
@@ -323,11 +257,6 @@ void SvMetaAttribute::WriteSvIdl
     TestAndSeekSpaceOnly( rOutStm, nPos );
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::ReadAttributesSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
                                              SvTokenStream & rInStm )
 {
@@ -342,18 +271,13 @@ void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
     {
         if( GetType()->GetType() == TYPE_METHOD )
         {
-            // Fehler setzen
+            // set error
             rBase.SetError( "Readonly in function attribute", rInStm.GetToken() );
             rBase.WriteError( rInStm );
         }
     }
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::WriteAttributesSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::WriteAttributesSvIdl
 (
     SvIdlDataBase & rBase,
@@ -363,7 +287,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
 {
     SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab );
 
-    //aSlotId.WriteSvIdl( SvHash_SlotId(), rOutStm, nTab );
     if( !aExport || !aAutomation || aReadonly )
     {
         WriteTab( rOutStm, nTab );
@@ -407,11 +330,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
     }
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::WriteParam()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
                                     SvStream & rOutStm,
                                     USHORT nTab,
@@ -434,10 +352,7 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
                 rList.GetObject( i )->WriteParam( rBase, rOutStm, nTab, nT );
                 if( i+1<nCount )
                 {
-//                                     if ( nT == WRITE_DOCU )
                         rOutStm << ',';
-//                                     else
-//                                             rOutStm << ',' << endl;
                 }
             }
         }
@@ -470,11 +385,6 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*    SvMetaSlot::WriteSlotId()
-|*
-|*    Beschreibung
-*************************************************************************/
 ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, BOOL bVar ) const
 {
      const SvNumberIdentifier & rId = GetSlotId();
@@ -493,11 +403,6 @@ ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, BOOL bVar ) const
     return n;
 }
 
-/*************************************************************************
-|*    SvMetaSlot::WriteAttributes()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
                                       USHORT nTab,
                                       WriteType nT, WriteAttribute nA )
@@ -532,11 +437,6 @@ void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & 
rOutStm
     }
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::WriteCSource()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
                                     BOOL bSet )
 {
@@ -544,12 +444,12 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
     SvMetaType * pType = GetType();
     SvMetaType * pBaseType = pType->GetBaseType();
 
-    // Bei Set ist der Return immer void
+    // for Set the return is always void
     BOOL bVoid = bSet;
     if( pBaseType->GetType() == TYPE_METHOD )
         bVoid = pBaseType->GetReturnType()->GetBaseType()->GetName() == "void";
 
-    // Methoden/Funktions-Body ausgeben
+    // emit methods/functions body
     rOutStm << '{' << endl;
     WriteTab( rOutStm, 1 );
 
@@ -603,7 +503,6 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
     {
         rOutStm << ", ";
         if( IsMethod() )
-            // void SetPosSize( C_Object *, C_Rectangle * pRect );
             pBaseType->WriteParamNames( rBase, rOutStm, ByteString() );
         else if( bSet )
             pBaseType->WriteParamNames( rBase, rOutStm, GetName() );
@@ -613,11 +512,6 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
     rOutStm << '}' << endl;
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::WriteRecursiv_Impl()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
                             SvStream & rOutStm, USHORT nTab,
                              WriteType nT, WriteAttribute nA )
@@ -629,8 +523,7 @@ void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
     if ( GetSlotId().Len() )
         rBase.aStructSlotId = GetSlotId();
 
-    // Offizielle Hack-Schnittstelle von MM: spezielle Schalter werden "uber
-    // die WriteAttribute "ubergeben
+    // offial hack interface by MM: special controls get passed with the WriteAttribute
     if ( GetReadonly() )
         nA |= WA_READONLY;
 
@@ -647,16 +540,11 @@ void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
     rBase.aStructSlotId = slotId;
 }
 
-/*************************************************************************
-|*    SvMetaAttribute::Write()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                             USHORT nTab,
                              WriteType nT, WriteAttribute nA )
 {
-    // keine Attribut fuer Automation
+    // no attributes for automation
     if( nT == WRITE_DOCU )
     {
         if ( GetHidden() )
@@ -705,15 +593,12 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     {
         if( !bVariable && IsMethod() )
         {
-            ByteString name; // (rBase.GetActModulePrefix());
+            ByteString name;
             name += rBase.aIFaceName;
             name += GetName();
             const char * pName = name.GetBuffer();
-            // Beispiel
-            // void SetPosSize( C_Object *, C_Rectangle * );
             WriteTab( rOutStm, nTab );
             pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
-//                     rOutStm << " SYSCALL";
             rOutStm << ' ' << pName;
             pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
             if( nT == WRITE_C_HEADER )
@@ -725,21 +610,19 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
         {
               if( nBType == TYPE_STRUCT )
             {
-                // Zur Hilfe den Namen des Properties als Kommentar ausgeben
+                // for assistance emit the name of the property as acomment
                 rOutStm << "/* " << GetName().GetBuffer() << " */" << endl;
 
                 WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
             }
             else
             {
-                // Beispiel
-                // void SetValue( C_Object *, USHORT n );
                 ByteString name = GetName();
 
                 BOOL bReadonly = GetReadonly() || ( nA & WA_READONLY );
                 if ( !bReadonly && !IsMethod() )
                 {
-                    // Zuweisung
+                    // allocation
                     WriteTab( rOutStm, nTab );
                     rOutStm << "void ";
                     rOutStm << rBase.aIFaceName.GetBuffer()
@@ -754,7 +637,7 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                         WriteCSource( rBase, rOutStm, TRUE );
                 }
 
-                // Zugriff
+                // access
                 WriteTab( rOutStm, nTab );
                 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
                 rOutStm << ' ';
@@ -777,7 +660,7 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                     << GetName().GetBuffer() << endl
                     << endl;   // readonly
 
-            // Returntype
+            // return type
             SvMetaType* pType2 = GetType();
             SvMetaType* pBaseType2 = pType2->GetBaseType();
             rOutStm << pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().GetBuffer() << 
endl;
@@ -785,20 +668,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
             DBG_ASSERT( pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().Len(),
                 "Leerer BasicName" );
 
-            // Syntax
+            // syntax
             rOutStm << GetName().GetBuffer();
             pType2->WriteMethodArgs( rBase, rOutStm, nTab, nT );
 
-            // C-Returntype
+            // C return type
             pBaseType2->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
             rOutStm << endl;
 
-            // Bei Methoden auch C-Syntax
+            // for methods also C syntax
             rOutStm << "<C-SYNTAX>" << endl;
             Write( rBase, rOutStm, 0, WRITE_C_HEADER, nA );
             rOutStm << "</C-SYNTAX>" << endl;
 
-            // Description
+            // description
             WriteDescription( rOutStm );
             rOutStm << "</METHOD>" << endl << endl;
         }
@@ -818,20 +701,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                 else
                     rOutStm << endl;
 
-                // Bei properties Type anstelle des return value
+                // for properties type instead of the return value
                 rOutStm << pBaseType->GetBasicName().GetBuffer() << endl;
 
                 DBG_ASSERT( pBaseType->GetBasicName().Len(),
                     "Leerer BasicName" );
 
-                // Bei properties keine Syntax
+                // for properties no syntax
                 rOutStm << endl;
 
-                // C-Returntype
+                // C return type
                 pBaseType->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
                 rOutStm << endl;
 
-                // Description
+                // description
                 WriteDescription( rOutStm );
                 rOutStm        << "</PROPERTY>" << endl << endl;
             }
@@ -839,11 +722,6 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*       SvMetaAttribute::MakeSfx()
-|*
-|*       Beschreibung
-*************************************************************************/
 ULONG SvMetaAttribute::MakeSfx( ByteString * pAttrArray )
 {
     SvMetaType * pType = GetType();
@@ -867,11 +745,6 @@ void SvMetaAttribute::Insert (SvSlotElementList&, const ByteString &, 
SvIdlDataB
 {
 }
 
-/*************************************************************************
-|*       SvMetaAttribute::WriteSrc()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaAttribute::WriteSrc( SvIdlDataBase &, SvStream &, Table * )
 {
 }
@@ -882,14 +755,7 @@ void SvMetaAttribute::WriteHelpId( SvIdlDataBase &, SvStream &, Table * )
 
 #endif // IDL_COMPILER
 
-/****************** SvMetaType *************************************/
-/************************************************************************/
 SV_IMPL_META_FACTORY1( SvMetaType, SvMetaExtern );
-/*************************************************************************
-|*       SvMetaType::SvMetaType()
-|*
-|*       Beschreibung
-*************************************************************************/
 #define CTOR                                                   \
     : aCall0( CALL_VALUE, FALSE )       \
     , aCall1( CALL_VALUE, FALSE )       \
@@ -923,7 +789,6 @@ SvMetaType::SvMetaType( const ByteString & rName,
                         const ByteString & rBasicPostfix )
     CTOR
 {
-//    aSbxDataType = (int)nT;
     SetName( rName );
     aSbxName   = rSbxName;
     aOdlName   = rOdlName;
@@ -966,7 +831,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
 {
     SvMetaExtern::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     USHORT nMask = 0;
     if( aIn.IsSet() )                          nMask |= 0x0001;
     if( aOut.IsSet() )                         nMask |= 0x0002;
@@ -985,7 +850,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
     if( aBasicName.IsSet() )           nMask |= 0x4000;
     if( aBasicPostfix.IsSet() )        nMask |= 0x8000;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x0001 ) rStm << aIn;
     if( nMask & 0x0002 ) rStm << aOut;
@@ -1003,11 +868,6 @@ void SvMetaType::Save( SvPersistStream & rStm )
     if( nMask & 0x8000 ) rStm << aBasicPostfix;
 }
 
-/*************************************************************************
-|*       SvMetaType::GetAttrList()
-|*
-|*       Beschreibung
-*************************************************************************/
 SvMetaAttributeMemberList &    SvMetaType::GetAttrList() const
 {
     if( !pAttrList )
@@ -1015,18 +875,12 @@ SvMetaAttributeMemberList &      SvMetaType::GetAttrList() const
     return *pAttrList;
 }
 
-/*************************************************************************
-|*       SvMetaType::SetType()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::SetType( int nT )
 {
     nType = nT;
     if( nType == TYPE_ENUM )
     {
         aOdlName = "short";
-//        aSbxDataType = SbxINTEGER;
     }
     else if( nType == TYPE_CLASS )
     {
@@ -1035,11 +889,6 @@ void SvMetaType::SetType( int nT )
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::GetBaseType()
-|*
-|*       Beschreibung
-*************************************************************************/
 SvMetaType * SvMetaType::GetBaseType() const
 {
     if( GetRef() && GetType() == TYPE_BASE )
@@ -1047,11 +896,6 @@ SvMetaType * SvMetaType::GetBaseType() const
     return (SvMetaType *)this;
 }
 
-/*************************************************************************
-|*       SvMetaType::GetReturnType()
-|*
-|*       Beschreibung
-*************************************************************************/
 SvMetaType * SvMetaType::GetReturnType() const
 {
     DBG_ASSERT( GetType() == TYPE_METHOD, "no method" );
@@ -1059,25 +903,6 @@ SvMetaType * SvMetaType::GetReturnType() const
     return (SvMetaType *)GetRef();
 }
 
-/*************************************************************************
-|*       SvMetaType::GetSbxDataType()
-|*
-|*       Beschreibung
-*************************************************************************/
-/*
-SbxDataType SvMetaType::GetSbxDataType() const
-{
-    if( aSbxDataType.IsSet() || !GetRef() )
-        return (SbxDataType)(int)aSbxDataType;
-    else
-        return ((SvMetaType *)GetRef())->GetSbxDataType();
-}
-*/
-/*************************************************************************
-|*       SvMetaType::GetBasicName()
-|*
-|*       Beschreibung
-*************************************************************************/
 const ByteString& SvMetaType::GetBasicName() const
 {
     if( aBasicName.IsSet() || !GetRef() )
@@ -1086,17 +911,12 @@ const ByteString& SvMetaType::GetBasicName() const
         return ((SvMetaType*)GetRef())->GetBasicName();
 }
 
-/*************************************************************************
-|*       SvMetaType::GetBasicPostfix()
-|*
-|*       Beschreibung
-*************************************************************************/
 ByteString SvMetaType::GetBasicPostfix() const
 {
 
     ByteString aRet;
 
-    // MBN und Co wollen immer "As xxx"
+    // MBN and Co always want "As xxx"
     {
 
         aRet = " As ";
@@ -1106,11 +926,6 @@ ByteString SvMetaType::GetBasicPostfix() const
     return aRet;
 }
 
-/*************************************************************************
-|*       SvMetaType::GetIn()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaType::GetIn() const
 {
     if( aIn.IsSet() || !GetRef() )
@@ -1119,11 +934,6 @@ BOOL SvMetaType::GetIn() const
         return ((SvMetaType *)GetRef())->GetIn();
 }
 
-/*************************************************************************
-|*       SvMetaType::GetOut()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaType::GetOut() const
 {
     if( aOut.IsSet() || !GetRef() )
@@ -1132,11 +942,6 @@ BOOL SvMetaType::GetOut() const
         return ((SvMetaType *)GetRef())->GetOut();
 }
 
-/*************************************************************************
-|*       SvMetaType::SetCall0()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::SetCall0( int e )
 {
     aCall0 = (int)e;
@@ -1153,11 +958,6 @@ void SvMetaType::SetCall0( int e )
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::GetCall0()
-|*
-|*       Beschreibung
-*************************************************************************/
 int SvMetaType::GetCall0() const
 {
     if( aCall0.IsSet() || !GetRef() )
@@ -1166,11 +966,6 @@ int SvMetaType::GetCall0() const
         return ((SvMetaType *)GetRef())->GetCall0();
 }
 
-/*************************************************************************
-|*       SvMetaType::SetCall1()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::SetCall1( int e )
 {
     aCall1 = (int)e;
@@ -1187,11 +982,6 @@ void SvMetaType::SetCall1( int e )
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::GetCall1()
-|*
-|*       Beschreibung
-*************************************************************************/
 int SvMetaType::GetCall1() const
 {
     if( aCall1.IsSet() || !GetRef() )
@@ -1200,11 +990,6 @@ int SvMetaType::GetCall1() const
         return ((SvMetaType *)GetRef())->GetCall1();
 }
 
-/*************************************************************************
-|*       SvMetaType::GetSvName()
-|*
-|*       Beschreibung
-*************************************************************************/
 const ByteString & SvMetaType::GetSvName() const
 {
     if( aSvName.IsSet() || !GetRef() )
@@ -1213,11 +998,6 @@ const ByteString & SvMetaType::GetSvName() const
         return ((SvMetaType *)GetRef())->GetSvName();
 }
 
-/*************************************************************************
-|*       SvMetaType::GetSbxName()
-|*
-|*       Beschreibung
-*************************************************************************/
 const ByteString & SvMetaType::GetSbxName() const
 {
     if( aSbxName.IsSet() || !GetRef() )
@@ -1226,11 +1006,6 @@ const ByteString & SvMetaType::GetSbxName() const
         return ((SvMetaType *)GetRef())->GetSbxName();
 }
 
-/*************************************************************************
-|*       SvMetaType::GetOdlName()
-|*
-|*       Beschreibung
-*************************************************************************/
 const ByteString & SvMetaType::GetOdlName() const
 {
     if( aOdlName.IsSet() || !GetRef() )
@@ -1239,11 +1014,6 @@ const ByteString & SvMetaType::GetOdlName() const
         return ((SvMetaType *)GetRef())->GetOdlName();
 }
 
-/*************************************************************************
-|*       SvMetaType::GetCName()
-|*
-|*       Beschreibung
-*************************************************************************/
 const ByteString & SvMetaType::GetCName() const
 {
     if( aCName.IsSet() || !GetRef() )
@@ -1252,11 +1022,6 @@ const ByteString & SvMetaType::GetCName() const
         return ((SvMetaType *)GetRef())->GetCName();
 }
 
-/*************************************************************************
-|*       SvMetaType::SetName()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pBase )
 {
     aSvName    = rName;
@@ -1268,11 +1033,6 @@ BOOL SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pBase )
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*       SvMetaType::GetString()
-|*
-|*       Beschreibung
-*************************************************************************/
 ByteString SvMetaType::GetCString() const
 {
     ByteString out( GetSvName() );
@@ -1287,11 +1047,6 @@ ByteString SvMetaType::GetCString() const
     return out;
 }
 
-/*************************************************************************
-|*       SvMetaType::ReadHeaderSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
                                      SvTokenStream & rInStm )
 {
@@ -1336,12 +1091,8 @@ BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
             SetRef( pType );
             if( ReadNameSvIdl( rBase, rInStm ) )
             {
-                /*     // um aufwaertskompatibel zu bleiben
-                        aOdlName = pType->GetOdlName();
-                */
                 if( rInStm.Read( '(' ) )
                 {
-                    //DoReadContextSvIdl( rBase, rInStm, ',' );
                     DoReadContextSvIdl( rBase, rInStm );
                     if( rInStm.Read( ')' ) )
                     {
@@ -1369,11 +1120,6 @@ BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
     return bOk;
 }
 
-/*************************************************************************
-|*       SvMetaType::ReadSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
                              SvTokenStream & rInStm )
 {
@@ -1385,11 +1131,6 @@ BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
     return FALSE;
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteSvIdl
 (
     SvIdlDataBase & rBase,
@@ -1405,16 +1146,11 @@ void SvMetaType::WriteSvIdl
     rOutStm << endl;
     SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
     if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
-        // nichts geschrieben
+        // nothin written
         rOutStm.Seek( nOldPos );
     rOutStm << ';' << endl;
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteContext()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
                                  USHORT nTab,
                              WriteType nT, WriteAttribute nA )
@@ -1434,17 +1170,12 @@ void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::Write()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                           USHORT nTab,
                          WriteType nT, WriteAttribute nA )
 {
     if( nT == WRITE_C_HEADER && nType != TYPE_ENUM )
-        // nur enum schreiben
+        // write only enum
         return;
 
     ByteString name = GetName();
@@ -1519,11 +1250,6 @@ void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::ReadNamesSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
                                      SvTokenStream & rInStm )
 {
@@ -1532,11 +1258,6 @@ BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
     return bOk;
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteHeaderSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
                                    SvStream & rOutStm,
                                    USHORT nTab )
@@ -1597,11 +1318,6 @@ void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::ReadAttributesSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
                                       SvTokenStream & rInStm )
 {
@@ -1611,11 +1327,6 @@ void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
     aOdlName.ReadSvIdl( SvHash_OdlName(), rInStm );
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteAttributesSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
                                        SvStream & rOutStm,
                                        USHORT nTab )
@@ -1647,11 +1358,6 @@ void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::ReadContextSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
                                       SvTokenStream & rInStm )
 {
@@ -1663,11 +1369,6 @@ void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteContextSvIdl()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteContextSvIdl
 (
     SvIdlDataBase & rBase,
@@ -1691,11 +1392,6 @@ void SvMetaType::WriteContextSvIdl
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteAttributes()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
                                    USHORT nTab,
                                  WriteType nT, WriteAttribute nA )
@@ -1703,11 +1399,6 @@ void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
     SvMetaExtern::WriteAttributes( rBase, rOutStm, nTab, nT, nA );
 }
 
-/*************************************************************************
-|*       SvMetaType::MakeSfx()
-|*
-|*       Beschreibung
-*************************************************************************/
 ULONG SvMetaType::MakeSfx( ByteString * pAttrArray )
 {
     ULONG nC = 0;
@@ -1715,7 +1406,7 @@ ULONG SvMetaType::MakeSfx( ByteString * pAttrArray )
     if( GetBaseType()->GetType() == TYPE_STRUCT )
     {
         ULONG nAttrCount = GetAttrCount();
-        // Die einzelnen Attribute schreiben
+        // write the single attributes
         for( ULONG n = 0; n < nAttrCount; n++ )
         {
             nC += pAttrList->GetObject( n )->MakeSfx( pAttrArray );
@@ -1737,14 +1428,13 @@ void SvMetaType::WriteSfxItem(
     ByteString aTypeName = "SfxType";
     ByteString  aAttrArray;
     ULONG      nAttrCount = MakeSfx( &aAttrArray );
-    //ULONG    nAttrCount = GetAttrCount();
     ByteString  aAttrCount( ByteString::CreateFromInt32( nAttrCount ) );
     aTypeName += aAttrCount;
 
     rOutStm << "extern " << aTypeName.GetBuffer()
             << aVarName.GetBuffer() << ';' << endl;
 
-    // Den Implementationsteil schreiben
+    // write the implementation part
     rOutStm << "#ifdef SFX_TYPEMAP" << endl
             << aTypeName.GetBuffer() << aVarName.GetBuffer()
             << " = " << endl;
@@ -1754,7 +1444,7 @@ void SvMetaType::WriteSfxItem(
     if( nAttrCount )
     {
         rOutStm << ", { ";
-        // Die einzelnen Attribute schreiben
+        // write the single attributes
         rOutStm << aAttrArray.GetBuffer();
         rOutStm << " }";
     }
@@ -1762,11 +1452,6 @@ void SvMetaType::WriteSfxItem(
             << "#endif" << endl << endl;
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteSfx()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
 {
     if( IsItem() )
@@ -1778,18 +1463,12 @@ void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::ReadMethodArgs()
-|*
-|*       Beschreibung
-*************************************************************************/
 BOOL SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
                                       SvTokenStream & rInStm )
 {
     UINT32  nTokPos = rInStm.Tell();
     if( rInStm.Read( '(' ) )
     {
-        //DoReadContextSvIdl( rBase, rInStm, ',' );
         DoReadContextSvIdl( rBase, rInStm );
         if( rInStm.Read( ')' ) )
         {
@@ -1801,11 +1480,6 @@ BOOL SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
     return FALSE;
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteMethodArgs()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteMethodArgs
 (
     SvIdlDataBase & rBase,
@@ -1904,11 +1578,6 @@ void SvMetaType::WriteMethodArgs
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteTypePrefix()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
                                  USHORT nTab, WriteType nT )
 {
@@ -2021,11 +1690,6 @@ void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
     }
 }
 
-/*************************************************************************
-|*       SvMetaType::WriteTheType()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
                              USHORT nTab, WriteType nT )
 {
@@ -2034,11 +1698,6 @@ void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
         WriteMethodArgs( rBase, rOutStm, nTab +2, nT );
 }
 
-/*************************************************************************
-|*       SvMetaType::GetParserString()
-|*
-|*       Beschreibung
-*************************************************************************/
 ByteString SvMetaType::GetParserString() const
 {
     SvMetaType * pBT = GetBaseType();
@@ -2051,7 +1710,7 @@ ByteString SvMetaType::GetParserString() const
     if( TYPE_METHOD == type || TYPE_STRUCT == type )
     {
         ULONG nAttrCount = GetAttrCount();
-        // Die einzelnen Attribute schreiben
+        // write the single attributes
         for( ULONG n = 0; n < nAttrCount; n++ )
         {
             SvMetaAttribute * pT = pAttrList->GetObject( n );
@@ -2063,11 +1722,6 @@ ByteString SvMetaType::GetParserString() const
     return aPStr;
 }
 
-/*************************************************************************
-|*    SvMetaType::WriteParamNames()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
                                    SvStream & rOutStm,
                                    const ByteString & rChief )
@@ -2083,15 +1737,11 @@ void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
         if( TYPE_METHOD == type || TYPE_STRUCT == type )
         {
             ULONG nAttrCount = GetAttrCount();
-            // Die einzelnen Attribute schreiben
+            // write the single attributes
             for( ULONG n = 0; n < nAttrCount; n++ )
             {
                 SvMetaAttribute * pA = pAttrList->GetObject( n );
-                // Fuer Methoden ist rChief immer ""
-                ByteString aStr = /*rChief;
-                if( aStr.Len() )
-                    aStr += "->";
-                aStr += */pA->GetName();
+                ByteString aStr = pA->GetName();
                 pA->GetType()->WriteParamNames( rBase, rOutStm, aStr );
                 if( n +1 < nAttrCount )
                     rOutStm << ", ";
@@ -2104,16 +1754,7 @@ void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
 
 #endif // IDL_COMPILER
 
-/************************************************************************/
-/************************************************************************/
 SV_IMPL_META_FACTORY1( SvMetaTypeString, SvMetaType );
-/*************************************************************************
-|*
-|*       SvMetaTypeString::SvMetaTypeString()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 SvMetaTypeString::SvMetaTypeString()
     : SvMetaType( "String", "SbxSTRING", "BSTR", 's', "char *", "String", "$" )
 {
@@ -2129,16 +1770,7 @@ void SvMetaTypeString::Save( SvPersistStream & rStm )
     SvMetaType::Save( rStm );
 }
 
-/************************************************************************/
-/************************************************************************/
 SV_IMPL_META_FACTORY1( SvMetaEnumValue, SvMetaName );
-/*************************************************************************
-|*
-|*       SvMetaEnumValue::SvMetaEnumValue()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 SvMetaEnumValue::SvMetaEnumValue()
 {
 }
@@ -2162,23 +1794,16 @@ void SvMetaEnumValue::Save( SvPersistStream & rStm )
 {
     SvMetaName::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     BYTE nMask = 0;
     if( aEnumValue.Len() ) nMask |= 0x01;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x01 ) rStm.WriteByteString( aEnumValue );
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|*       SvMetaEnumValue::ReadSvIdl()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
                                  SvTokenStream & rInStm )
 {
@@ -2187,25 +1812,11 @@ BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
     return TRUE;
 }
 
-/*************************************************************************
-|*
-|*       SvMetaEnumValue::WriteSvIdl()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 void SvMetaEnumValue::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, USHORT )
 {
     rOutStm << GetName().GetBuffer();
 }
 
-/*************************************************************************
-|*
-|*       SvMetaEnumValue::Write()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, USHORT,
                              WriteType nT, WriteAttribute )
 {
@@ -2216,16 +1827,7 @@ void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, USHORT,
 }
 #endif // IDL_COMPILER
 
-/************************************************************************/
-/************************************************************************/
 SV_IMPL_META_FACTORY1( SvMetaTypeEnum, SvMetaType );
-/*************************************************************************
-|*
-|*       SvMetaTypeEnum::SvMetaTypeEnum()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 SvMetaTypeEnum::SvMetaTypeEnum()
 {
     SetBasicName( "Integer" );
@@ -2251,25 +1853,18 @@ void SvMetaTypeEnum::Save( SvPersistStream & rStm )
 {
     SvMetaType::Save( rStm );
 
-    // Maske erstellen
+    // create mask
     BYTE nMask = 0;
     if( aEnumValueList.Count() )       nMask |= 0x01;
     if( aPrefix.Len() )                        nMask |= 0x02;
 
-    // Daten schreiben
+    // write data
     rStm << nMask;
     if( nMask & 0x01 ) rStm << aEnumValueList;
     if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|*       SvMetaTypeEnum::ReadContextSvIdl()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
                                        SvTokenStream & rInStm )
 {
@@ -2280,7 +1875,7 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
     if( bOk )
     {
         if( 0 == aEnumValueList.Count() )
-           // der Erste
+           // the first
            aPrefix = aEnumVal->GetName();
         else
         {
@@ -2294,13 +1889,6 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
         rInStm.Seek( nTokPos );
 }
 
-/*************************************************************************
-|*
-|*       SvMetaTypeEnum::WriteSvIdl()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
                                         SvStream & rOutStm,
                                         USHORT nTab )
@@ -2316,13 +1904,6 @@ void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
     }
 }
 
-/*************************************************************************
-|*
-|*       SvMetaTypeEnum::ReadSvIdl()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
                                 SvTokenStream & rInStm )
 {
@@ -2337,13 +1918,6 @@ BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*       SvMetaTypeEnum::WriteSvIdl()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
                                    USHORT nTab )
 {
@@ -2353,13 +1927,6 @@ void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
     rOutStm << endl;
 }
 
-/*************************************************************************
-|*
-|*       SvMetaTypeEnum::Write()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
                             USHORT nTab,
                              WriteType nT, WriteAttribute nA )
@@ -2367,11 +1934,6 @@ void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
     SvMetaType::Write( rBase, rOutStm, nTab, nT, nA );
 }
 
-/*************************************************************************
-|*       SvMetaTypeEnum::WriteContext()
-|*
-|*       Beschreibung
-*************************************************************************/
 void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
                                    USHORT nTab,
                                  WriteType nT, WriteAttribute nA )
@@ -2399,16 +1961,7 @@ void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
 
 #endif // IDL_COMPILER
 
-/************************************************************************/
-/************************************************************************/
 SV_IMPL_META_FACTORY1( SvMetaTypevoid, SvMetaType );
-/*************************************************************************
-|*
-|*       SvMetaTypevoid::SvMetaTypevoid()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 SvMetaTypevoid::SvMetaTypevoid()
     : SvMetaType( "void", "SbxVOID", "void", 'v', "void", "", "" )
 {
@@ -2432,8 +1985,7 @@ ByteString SvMetaAttribute::Compare( SvMetaAttribute* pAttr )
     {
         if ( aType->GetType() == TYPE_METHOD )
         {
-            // Nur testen, wenn das Attribut eine Methode ist, nicht wenn es
-            // eine hat !!
+            // Test only when the attribute is a method not if it has one!
             if ( !pAttr->GetType()->GetType() == TYPE_METHOD )
                 aStr += "    IsMethod\n";
             else if ( aType->GetReturnType() &&
diff --git a/idl/source/prj/command.cxx b/idl/source/prj/command.cxx
index c39b6d6..6f859e9 100644
--- a/idl/source/prj/command.cxx
+++ b/idl/source/prj/command.cxx
@@ -39,11 +39,6 @@
 #include <database.hxx>
 #include <tools/fsys.hxx>
 
-/*************************************************************************
-|*
-|*       Syntaxbeschreibung
-|*
-*************************************************************************/
 char const * SyntaxStrings[] = {
 "basic-type:",
 "\tvoid|        char|       int|        float|      double|",
@@ -91,7 +86,6 @@ char const * SyntaxStrings[] = {
 "\t\tAccelConfig, MenuConfig, StatusBarConfig, ToolbarConfig",
 "\t\tAutomation*",
 "\t\tAutoUpdate",
-// "\t\tCachable*, Volatile",
 "\t\tContainer",
 "\t\tDefault        = Identifier",
 "\t\tExecMethod     = Identifier",
@@ -134,11 +128,6 @@ char CommandLineSyntax[] =
 "-help, ?                   @<file> response file\n"
 " <filenames>\n";
 
-/*************************************************************************
-|*
-|*       Init()
-|*
-*************************************************************************/
 void Init()
 {
     if( !IDLAPP->pHashTable )
@@ -147,25 +136,11 @@ void Init()
         IDLAPP->pGlobalNames   = new SvGlobalHashNames();
 }
 
-/*************************************************************************
-|*
-|*       DeInit()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 void DeInit()
 {
     delete IDLAPP;
 }
 
-/*************************************************************************
-|*
-|*       DeInit()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 BOOL ReadIdl( SvIdlWorkingBase * pDataBase, const SvCommand & rCommand )
 {
     for( size_t n = 0; n < rCommand.aInFileList.size(); ++n )
@@ -204,21 +179,14 @@ BOOL ReadIdl( SvIdlWorkingBase * pDataBase, const SvCommand & rCommand )
     return TRUE;
 }
 
-/*************************************************************************
-|*
-|*       SvCommand::SvCommand()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 static BOOL ResponseFile( StringList * pList, int argc, char ** argv )
 {
-    // Programmname
+    // program name
     pList->push_back( new String( String::CreateFromAscii(*argv) ) );
     for( int i = 1; i < argc; i++ )
     {
         if( '@' == **(argv +i) )
-        { // wenn @, dann Response-Datei
+        { // when @, then response file
             SvFileStream aStm( String::CreateFromAscii((*(argv +i)) +1), STREAM_STD_READ | 
STREAM_NOCREATE );
             if( aStm.GetError() != SVSTREAM_OK )
                 return FALSE;
@@ -246,11 +214,6 @@ static BOOL ResponseFile( StringList * pList, int argc, char ** argv )
     return TRUE;
 }
 
-/*************************************************************************
-|*       SvCommand::SvCommand()
-|*
-|*       Beschreibung
-*************************************************************************/
 SvCommand::SvCommand( int argc, char ** argv )
     : nVerbosity(1), nFlags( 0 )
 {
@@ -271,67 +234,58 @@ SvCommand::SvCommand( int argc, char ** argv )
                 aFirstChar = aParam.GetChar(0);
                 String aName( aParam.Copy( 1 ) );
                 if( 's' == aFirstChar )
-                { // Name der Slot-Ausgabe
+                { // name of slot output
                     aSlotMapFile = aName;
                 }
                 else if( 'l' == aFirstChar )
-                { // Name der Listing
+                { // name of listing
                     aListFile = aName;
                 }
                 else if( 'i' == aFirstChar )
-                { // Name der Item-Datei
-//                    aSfxItemFile = aName;
+                {
                 }
                 else if( 'o' == aFirstChar )
-                { // Name der ODL-Datei
-//                    aODLFile = aName;
+                {
                 }
                 else if( 'd' == aFirstChar )
-                { // Name der Datenbasis-Datei
+                { // name of data set file
                     aDataBaseFile = aName;
                 }
                 else if( 'D' == aFirstChar )
-                { // Name der Docu-Datei f"ur das API
-//                    aDocuFile = aName;
+                {
                 }
                 else if( 'C' == aFirstChar )
-                { // Name der cxx-Datei
-//                    aCxxFile = aName;
+                {
                 }
                 else if( 'H' == aFirstChar )
-                { // Name der hxx-Datei
-//                    aHxxFile = aName;
+                {
                 }
                 else if( 'c' == aFirstChar )
-                { // Name der C-Header-Datei
-//                    aCSourceFile = aName;
+                {
                 }
                 else if( 'h' == aFirstChar )
-                { // Name der C-Header-Datei
-//                    aCHeaderFile = aName;
+                {
                 }
                 else if( 't' == aFirstChar )
-                { // Name der Info-Datei
-//                    aCallingFile = aName;
+                {
                 }
                 else if( 'm' == aFirstChar )
-                { // Name der Info-Datei
+                { // name of info file
                     aTargetFile = aName;
                 }
                 else if( 'r' == aFirstChar )
-                { // Name der Resource-Datei
-//                    aSrcFile = aName;
+                {
                 }
                 else if( 'z' == aFirstChar )
-                { // Name der HelpId-Datei
+                { // name of HelpId file
                     aHelpIdFile = aName;
                 }
                 else if( 'y' == aFirstChar )
-                { // Name der CSV-Datei
+                { // name of CSV file
                     aCSVFile = aName;
                 }
                 else if( 'x' == aFirstChar )
-                { // Name der IDL-Datei fuer die CSV-Datei
+                { // name of IDL file for the CSV file
                     aExportFile = aName;
                 }
                 else
@@ -344,7 +298,7 @@ SvCommand::SvCommand( int argc, char ** argv )
                 }
             }
             else if( aParam.EqualsIgnoreCaseAscii( "help" ) || aParam.EqualsIgnoreCaseAscii( "?" ) 
)
-            { // Hilfe
+            { // help
                 printf( "%s", CommandLineSyntax );
             }
             else if( aParam.EqualsIgnoreCaseAscii( "quiet" ) )
@@ -356,20 +310,20 @@ SvCommand::SvCommand( int argc, char ** argv )
                 nVerbosity = 2;
             }
             else if( aParam.EqualsIgnoreCaseAscii( "syntax" ) )
-            { // Hilfe
+            { // help
                 int j = 0;
                 while(SyntaxStrings[j])
                     printf("%s\n",SyntaxStrings[j++]);
             }
             else if( aParam.EqualsIgnoreCaseAscii( "i", 0, 1 ) )
-            { // Include-Pfade definieren
+            { // define include paths
                 String aName( aParam.Copy( 1 ) );
                 if( aPath.Len() )
                     aPath += DirEntry::GetSearchDelimiter();
                 aPath += aName;
             }
             else if( aParam.EqualsIgnoreCaseAscii( "rsc", 0, 3 ) )
-            { // erste Zeile im *.srs File
+            { // first line in *.srs file
                 if( aList[ i + 1 ] )
                 {
                     aSrsLine = ByteString( *aList[ i +1 ], RTL_TEXTENCODING_UTF8 );
@@ -401,7 +355,7 @@ SvCommand::SvCommand( int argc, char ** argv )
     aList.clear();
 
     ByteString aInc( getenv( "INCLUDE" ) );
-    // Include Environmentvariable anhaengen
+    // append include environment variable
     if( aInc.Len() )
     {
         if( aPath.Len() )
@@ -410,16 +364,9 @@ SvCommand::SvCommand( int argc, char ** argv )
     }
 }
 
-/*************************************************************************
-|*
-|*       SvCommand::~SvCommand()
-|*
-|*       Beschreibung
-|*
-*************************************************************************/
 SvCommand::~SvCommand()
 {
-    // ByteString Liste freigeben
+    // release ByteString list
     for ( size_t i = 0, n = aInFileList.size(); i < n; ++i )
         delete aInFileList[ i ];
     aInFileList.clear();
diff --git a/idl/source/prj/database.cxx b/idl/source/prj/database.cxx
index 0576fa5..ecd44dc 100644
--- a/idl/source/prj/database.cxx
+++ b/idl/source/prj/database.cxx
@@ -37,12 +37,6 @@
 #include <database.hxx>
 #include <globals.hxx>
 
-/****************** SvIdlDataBase ****************************************/
-/*************************************************************************
-|*    SvIdlDataBase::SvIdlDataBase()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
     : bExport( FALSE )
     , nUniqueId( 0 )
@@ -53,11 +47,6 @@ SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
 {
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::~SvIdlDataBase()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvIdlDataBase::~SvIdlDataBase()
 {
     for ( size_t i = 0, n = aIdFileList.size(); i < n; ++i )
@@ -67,11 +56,6 @@ SvIdlDataBase::~SvIdlDataBase()
     delete pIdTable;
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::GetTypeList()
-|*
-|*    Beschreibung
-*************************************************************************/
 #define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost )            \
     aTypeList.Append( new SvMetaType( SvHash_##Name()->GetName(),      \
                      BasName, OdlName, ParserChar, CName, BasName, BasPost ) );
@@ -79,11 +63,11 @@ SvIdlDataBase::~SvIdlDataBase()
 SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
 {
     if( aTypeList.Count() == 0 )
-    { // Initial fuellen
+    { // fill initially 
         aTypeList.Append( new SvMetaTypeString() );
         aTypeList.Append( new SvMetaTypevoid() );
 
-        // MI: IDispatch::Invoke kann keine unsigned
+        // MI: IDispatch::Invoke can not unsigned
         ADD_TYPE( UINT16,    "long", 'h', "unsigned short", "Long", "&" );
         ADD_TYPE( INT16,     "short", 'h', "short", "Integer", "%" );
         ADD_TYPE( UINT32,    "long", 'l', "unsigned long", "Long", "&" );
@@ -96,27 +80,12 @@ SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
         ADD_TYPE( double,    "double", 'F', "double", "Double", "#" );
         ADD_TYPE( SbxObject, "VARIANT", 'o', "C_Object", "Object", "" );
 
-        // A c h t u n g !!!, bei hinzufuegen von Typen werden alle
-        // bin„ren Datenbasen inkompatibel
-
-    /*
-        // So tun als ob die Init-Daten auf einem Stream gelesen wurden
-        SvMemoryStream aStm;
-        aPersStream.SetStream( &aStm );
-        // Alle Init-Daten Streamen
-        aPersStream << aTypeList;
-        // Nur die Id-Zuordnung merken
-        aPersStream.SetStream( NULL );
-    */
+        // Attention! When adding types all binary data bases get incompatible 
+
     }
     return aTypeList;
 }
 
-/*************************************************************************
-|*
-|*    SvIdlDataBase::GetModuleInfo()
-|*
-*************************************************************************/
 SvMetaModule * SvIdlDataBase::GetModule( const ByteString & rName )
 {
     for( ULONG n = 0; n < aModuleList.Count(); n++ )
@@ -125,13 +94,6 @@ SvMetaModule * SvIdlDataBase::GetModule( const ByteString & rName )
     return NULL;
 }
 
-/*************************************************************************
-|*
-|*    SvIdlDataBase::IsBinaryFormat()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 #define DATABASE_SIGNATURE  (UINT32)0x13B799F2
 #define DATABASE_VER 0x0006
 BOOL SvIdlDataBase::IsBinaryFormat( SvStream & rStm )
@@ -144,13 +106,6 @@ BOOL SvIdlDataBase::IsBinaryFormat( SvStream & rStm )
     return nSig == DATABASE_SIGNATURE;
 }
 
-/*************************************************************************
-|*
-|*    SvIdlDataBase::Load()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 void SvIdlDataBase::Load( SvStream & rStm )
 {
     DBG_ASSERT( aTypeList.Count() == 0, "type list already initialized" );
@@ -181,11 +136,6 @@ void SvIdlDataBase::Load( SvStream & rStm )
         aPStm.SetError( SVSTREAM_GENERALERROR );
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::Save()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvIdlDataBase::Save( SvStream & rStm, UINT32 nFlags )
 {
     SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
@@ -212,18 +162,12 @@ void SvIdlDataBase::Save( SvStream & rStm, UINT32 nFlags )
     else
         aPStm << aClassList;
 
-    //aClassList.WriteObjects( aPStm, bOnlyStreamedObjs );
     aTypeList.WriteObjects( aPStm, bOnlyStreamedObjs );
     aAttrList.WriteObjects( aPStm, bOnlyStreamedObjs );
     aModuleList.WriteObjects( aPStm, bOnlyStreamedObjs );
     aPStm << nUniqueId;
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::SetError()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvIdlDataBase::SetError( const ByteString & rError, SvToken * pTok )
 {
     if( pTok->GetLine() > 10000 )
@@ -237,24 +181,12 @@ void SvIdlDataBase::SetError( const ByteString & rError, SvToken * pTok )
     }
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::Push()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvIdlDataBase::Push( SvMetaObject * pObj )
 {
     GetStack().Push( pObj );
 }
 
 #ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|*    SvIdlDataBase::FindId()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvIdlDataBase::FindId( const ByteString & rIdName, ULONG * pVal )
 {
     if( pIdTable )
@@ -269,13 +201,6 @@ BOOL SvIdlDataBase::FindId( const ByteString & rIdName, ULONG * pVal )
     return FALSE;
 }
 
-/*************************************************************************
-|*
-|*    SvIdlDataBase::InsertId()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 BOOL SvIdlDataBase::InsertId( const ByteString & rIdName, ULONG nVal )
 {
     if( !pIdTable )
@@ -290,11 +215,6 @@ BOOL SvIdlDataBase::InsertId( const ByteString & rIdName, ULONG nVal )
     return FALSE;
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::ReadIdFile()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
 {
     DirEntry aFullName( rFileName );
@@ -325,7 +245,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
                     else
                     {
                         ByteString aStr( "unexpected token after define" );
-                        // Fehler setzen
+                        // set error
                         SetError( aStr, pTok );
                         WriteError( aTokStm );
                         return FALSE;
@@ -357,7 +277,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
                                 ByteString aStr( "unknown operator '" );
                                 aStr += pTok->GetChar();
                                 aStr += "'in define";
-                                // Fehler setzen
+                                // set error
                                 SetError( aStr, pTok );
                                 WriteError( aTokStm );
                                 return FALSE;
@@ -365,8 +285,8 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
                             if( pTok->GetChar() != '+'
                               && pTok->GetChar() != '('
                               && pTok->GetChar() != ')' )
-                                // nur + erlaubt, Klammern spielen kein Rolle,
-                                // da + komutativ ist
+                                // only + is allowed, parentheses are immaterial
+                                // because + is commutative
                                 break;
                         }
                         else if( pTok->IsInteger() )
@@ -405,7 +325,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
                         if( pTok->IsEof() )
                         {
                             ByteString aStr( "unexpected eof in #include" );
-                            // Fehler setzen
+                            // set error
                             SetError( aStr, pTok );
                             WriteError( aTokStm );
                             return FALSE;
@@ -430,11 +350,6 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
     return TRUE;
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::FindType()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
                                     SvMetaTypeMemberList & rList )
 {
@@ -452,25 +367,20 @@ SvMetaType * SvIdlDataBase::FindType( const ByteString & rName )
     return pType;
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::ReadKnownType()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
 {
     BOOL bIn   = FALSE;
     BOOL bOut  = FALSE;
     int nCall0 = CALL_VALUE;
     int nCall1 = CALL_VALUE;
-    BOOL bSet   = FALSE; //irgent ein Attribut gesetzt
+    BOOL bSet   = FALSE; // any attribute set
 
     UINT32  nTokPos = rInStm.Tell();
     SvToken * pTok = rInStm.GetToken_Next();
 
     if( pTok->HasHash() )
     {
-        UINT32 nBeginPos = 0; // kann mit Tell nicht vorkommen
+        UINT32 nBeginPos = 0; // can not happen with Tell
         while( nBeginPos != rInStm.Tell() )
         {
             nBeginPos = rInStm.Tell();
@@ -529,7 +439,7 @@ SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
             }
 
             if( !bSet )
-                // Ist genau dieser Typ
+                // is exactly this type
                 return pType;
 
             DBG_ASSERT( aTmpTypeList.First(), "mindestens ein Element" );
@@ -548,18 +458,11 @@ SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
     return NULL;
 }
 
-/*************************************************************************
-|*
-|*    SvIdlDataBase::ReadKnownAttr()
-|*
-|*    Beschreibung
-|*
-*************************************************************************/
 SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
 (
     SvTokenStream & rInStm,
-    SvMetaType *       pType   /* Wenn der pType == NULL, dann muss der Typ
-                               noch gelesen werden. */
+    SvMetaType *       pType   /* If pType == NULL, then the type has
+                               still to be read. */
 )
 {
     UINT32  nTokPos = rInStm.Tell();
@@ -569,7 +472,7 @@ SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
 
     if( !pType )
     {
-        // sonst SlotId?
+        // otherwise SlotId?
         SvToken * pTok = rInStm.GetToken_Next();
         if( pTok->IsIdentifier() )
         {
@@ -613,11 +516,6 @@ SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
     return NULL;
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::ReadKnownClass()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
 {
     UINT32  nTokPos = rInStm.Tell();
@@ -635,11 +533,6 @@ SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
     return NULL;
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::Write()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvIdlDataBase::Write( const ByteString & rText )
 {
 #ifndef W31
@@ -648,36 +541,26 @@ void SvIdlDataBase::Write( const ByteString & rText )
 #endif
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::WriteError()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvIdlDataBase::WriteError( const ByteString & rErrWrn,
                                 const ByteString & rFileName,
                                 const ByteString & rErrorText,
                                 ULONG nRow, ULONG nColumn ) const
 {
-    //Fehlerbehandlung
+    // error treatment
 #ifndef W31
     fprintf( stderr, "\n%s --- %s: ( %ld, %ld )\n",
              rFileName.GetBuffer(), rErrWrn.GetBuffer(), nRow, nColumn );
 
     if( rErrorText.Len() )
-    { // Fehler gesetzt
+    { // error set
         fprintf( stderr, "\t%s\n", rErrorText.GetBuffer() );
     }
 #endif
 }
 
-/*************************************************************************
-|*    SvIdlDataBase::WriteError()
-|*
-|*    Beschreibung
-*************************************************************************/
 void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
 {
-    //Fehlerbehandlung
+    // error treatment
 #ifndef W31
     String aFileName( rInStm.GetFileName() );
     ByteString aErrorText;
@@ -686,14 +569,14 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
     rInStm.SeekEnd();
     SvToken *pTok = rInStm.GetToken();
 
-    // Fehlerposition
+    // error position
     nRow       = pTok->GetLine();
     nColumn = pTok->GetColumn();
 
     if( aError.IsError() )
-    { // Fehler gesetzt
-        // Fehler Token suchen
-        // Fehlertext
+    { // error set
+        // search error token
+        // error text
         if( aError.GetText().Len() )
         {
             aErrorText = "may be <";
@@ -709,14 +592,14 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
             pTok = rInStm.GetToken_PrevAll();
         }
 
-        // Fehlerposition
+        // error position
         aErrorText += "> at ( ";
         aErrorText += ByteString::CreateFromInt64(aError.nLine);
         aErrorText += ", ";
         aErrorText += ByteString::CreateFromInt64(aError.nColumn);
         aErrorText += " )";
 
-        // Fehler zuruecksetzen
+        // reset error
         aError = SvIdlError();
     }
 
@@ -726,7 +609,7 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
     if( !pTok )
         return;
 
-    // Identifier in der Naehe suchen
+    // look for identifier close by
     if( !pTok->IsIdentifier() )
     {
         rInStm.GetToken_PrevAll();
@@ -741,28 +624,17 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
 #endif
 }
 
-/****************** SvIdlWorkingBase ****************************************/
-/*************************************************************************
-|*    SvIdlWorkingBase::SvIdlWorkingBase()
-|*
-|*    Beschreibung
-*************************************************************************/
 SvIdlWorkingBase::SvIdlWorkingBase(const SvCommand& rCmd) : SvIdlDataBase(rCmd)
 {
 }
 
-/*************************************************************************
-|*    SvIdlWorkingBase::ReadSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const String & rPath )
 {
-    aPath = rPath; // nur fuer den durchlauf gueltig
+    aPath = rPath; // only valid for this iteration
     SvToken * pTok;
     BOOL bOk = TRUE;
         pTok = rInStm.GetToken();
-        // nur ein import ganz am Anfang
+        // only one import at the very beginning
         if( pTok->Is( SvHash_import() ) )
         {
             rInStm.GetToken_Next();
@@ -802,7 +674,7 @@ BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const
                 bOk = FALSE;
         }
 
-    UINT32 nBeginPos = 0xFFFFFFFF; // kann mit Tell nicht vorkommen
+    UINT32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
 
     while( bOk && nBeginPos != rInStm.Tell() )
     {
@@ -813,8 +685,8 @@ BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const
         if( pTok->IsEmpty() )
             bOk = FALSE;
 
-        // nur ein import ganz am Anfang
-        /*else */if( pTok->Is( SvHash_module() ) )
+        // only one import at the very beginning
+        if( pTok->Is( SvHash_module() ) )
         {
             SvMetaModuleRef aModule = new SvMetaModule( rInStm.GetFileName(), bImported );
             if( aModule->ReadSvIdl( *this, rInStm ) )
@@ -827,18 +699,13 @@ BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, 
const
     }
     if( !bOk || !pTok->IsEof() )
     {
-         //Fehlerbehandlung
+         // error treatment
          WriteError( rInStm );
          return FALSE;
     }
     return TRUE;
 }
 
-/*************************************************************************
-|*    SvIdlWorkingBase::WriteSvIdl()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
 {
     if( rOutStm.GetError() != SVSTREAM_OK )
@@ -862,23 +729,17 @@ BOOL SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
     for( ULONG n = 0; n < GetModuleList().Count(); n++ )
     {
         SvMetaModule * pModule = GetModuleList().GetObject( n );
-        //if( !pModule->IsImported() )
-            pModule->WriteSvIdl( *this, rOutStm, 0 );
+        pModule->WriteSvIdl( *this, rOutStm, 0 );
     }
     return TRUE;
 }
 
-/*************************************************************************
-|*    SvIdlWorkingBase::WriteSfx()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
 {
     if( rOutStm.GetError() != SVSTREAM_OK )
         return FALSE;
 
-    // alle Tmp-Variablen fuer das Schreiben zuruecksetzen
+    // reset all tmp variables for writing
     WriteReset();
     SvMemoryStream aTmpStm( 256000, 256000 );
     ULONG n;
@@ -909,8 +770,7 @@ BOOL SvIdlWorkingBase::WriteHelpIds( SvStream& rOutStm )
     for( n = 0; n < GetModuleList().Count(); n++ )
     {
         SvMetaModule * pModule = GetModuleList().GetObject( n );
-        //if( !pModule->IsImported() )
-            pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
+        pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
     }
 
     const SvMetaAttributeMemberList & rAttrList = GetAttrList();
@@ -923,11 +783,6 @@ BOOL SvIdlWorkingBase::WriteHelpIds( SvStream& rOutStm )
     return TRUE;
 }
 
-/*************************************************************************
-|*    SvIdlWorkingBase::WriteSfxItem()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvIdlWorkingBase::WriteSfxItem( SvStream & )
 {
     return FALSE;
@@ -963,11 +818,6 @@ BOOL SvIdlWorkingBase::WriteCSV( SvStream& rStrm )
         return TRUE;
 }
 
-/*************************************************************************
-|*    SvIdlWorkingBase::WriteDocumentation()
-|*
-|*    Beschreibung
-*************************************************************************/
 BOOL SvIdlWorkingBase::WriteDocumentation( SvStream & rOutStm )
 {
     if( rOutStm.GetError() != SVSTREAM_OK )
diff --git a/idl/source/prj/globals.cxx b/idl/source/prj/globals.cxx
index 472b799..425a35d 100644
--- a/idl/source/prj/globals.cxx
+++ b/idl/source/prj/globals.cxx
@@ -29,13 +29,11 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_idl.hxx"
 
-/****************** I N C L U D E S **************************************/
 #include <tools/shl.hxx>
 
 #include <globals.hxx>
 #include <database.hxx>
 
-/****************** G L O B A L S ****************************************/
 #ifdef DOS
 static IdlDll * pApp = NULL;
 IdlDll * GetIdlApp()
@@ -50,9 +48,6 @@ IdlDll * GetIdlApp()
     if( !(*(IdlDll**)GetAppData(SHL_IDL)) )
     {
         (*(IdlDll**)GetAppData(SHL_IDL)) = new IdlDll();
-        // Temporaer, sonst nur wenn Compiler
-        //GetIdlApp()->pHashTable      = new SvStringHashTable( 2801 );
-        //GetIdlApp()->pGlobalNames    = new SvGlobalHashNames();
     }
     return (*(IdlDll**)GetAppData(SHL_IDL));
 }
@@ -93,11 +88,6 @@ IdlDll::~IdlDll()
     delete pHashTable;
 }
 
-/*************************************************************************
-|*
-|*    SvGlobalHashNames::SvGlobalHashNames()
-|*
-*************************************************************************/
 inline SvStringHashEntry * INS( const ByteString & rName )
 {
     UINT32  nIdx;
@@ -126,7 +116,6 @@ SvGlobalHashNames::SvGlobalHashNames()
     , MM_SlotId( INS( "SlotId" ) )
     , MM_HasCoreId( INS( "HasCoreId" ) )
     , MM_Cachable( INS( "Cachable" ) )
-//    , MM_Volatile( INS( "Volatile" ) )
     , MM_Toggle( INS( "Toggle" ) )
     , MM_AutoUpdate( INS( "AutoUpdate" ) )
     , MM_Synchron( INS( "Synchron" ) )
diff --git a/idl/source/prj/idldll.cxx b/idl/source/prj/idldll.cxx
index ba19adc..790c001 100644
--- a/idl/source/prj/idldll.cxx
+++ b/idl/source/prj/idldll.cxx
@@ -34,15 +34,15 @@
 
 #include <sysdep.hxx>
 
-// Statische DLL-Verwaltungs-Variablen
-static HINSTANCE hDLLInst = 0;      // HANDLE der DLL
+// static  DLL handle
+static HINSTANCE hDLLInst = 0;      // HANDLE of the DLL
 
 
 /***************************************************************************
 |*
 |*    LibMain()
 |*
-|*    Beschreibung       Initialisierungsfunktion der DLL
+|*    description       initializing function of the DLL
 |*
 ***************************************************************************/
 
@@ -62,7 +62,7 @@ extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 |*
 |*    WEP()
 |*
-|*    Beschreibung      DLL-Deinitialisierung
+|*    description      DLL de-initializing
 |*
 ***************************************************************************/
 
diff --git a/idl/source/prj/svidl.cxx b/idl/source/prj/svidl.cxx
index 70c6cd3..8260bab 100644
--- a/idl/source/prj/svidl.cxx
+++ b/idl/source/prj/svidl.cxx
@@ -74,13 +74,13 @@ BOOL FileMove_Impl( const String & rFile1, const String & rFile2, BOOL bImmerVer
     }
     DirEntry aF2( rFile2 );
     if( nC1 != nC2 )
-    {// es hat sich etwas geaendert
+    {// something has changed
         DirEntry aF1( rFile1 );
         aF1.Kill();
-        // Datei verschieben
+        // move file
         if( aF2.MoveTo( aF1 ) )
         {
-            // Beide Dateien loeschen
+            // delete both files
             aF1.Kill();
             aF2.Kill();
             return FALSE;
@@ -90,11 +90,6 @@ BOOL FileMove_Impl( const String & rFile1, const String & rFile2, BOOL bImmerVer
     return 0 == aF2.Kill();
 }
 
-/*************************************************************************
-|*       main()
-|*
-|*       Beschreibung
-*************************************************************************/
 #if defined( UNX ) || (defined( PM2 ) && defined( CSET )) || defined (WTC) || defined (MTW) || 
defined (__MINGW32__) || defined( OS2 )
 int main ( int argc, char ** argv)
 {
@@ -338,7 +333,7 @@ int cdecl main ( int argc, char ** argv)
                 DirEntry aT(aCommand.aTargetFile);
                 aT.Kill();
 #endif
-                // Datei stempeln, da idl korrekt durchlaufen wurde
+                // stamp file, because idl passed through correctly
                 SvFileStream aOutStm( aCommand.aTargetFile,
                                 STREAM_READWRITE | STREAM_TRUNC );
             }
-- 
1.7.4


Context


Privacy Policy | Impressum (Legal Info) | Copyright information: Unless otherwise specified, all text and images on this website are licensed under the Creative Commons Attribution-Share Alike 3.0 License. This does not include the source code of LibreOffice, which is licensed under the Mozilla Public License (MPLv2). "LibreOffice" and "The Document Foundation" are registered trademarks of their corresponding registered owners or are in actual use as trademarks in one or more countries. Their respective logos and icons are also subject to international copyright laws. Use thereof is explained in our trademark policy.