[Libreoffice-commits] .: idl/inc idl/source
Thomas Arnhold
tarnhold at kemper.freedesktop.org
Sun Feb 13 09:06:50 PST 2011
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(-)
New commits:
commit fdba64b10f4b9628e32802dcaf6ad1978c20e801
Author: Michael Münch <michael at codingmicha.de>
Date: Sun Feb 13 18:06:10 2011 +0100
Easy hack: idl removed and translated comments
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 fe8d29e..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,
... etc. - the rest is truncated
More information about the Libreoffice-commits
mailing list