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>
-// Programmabhngige 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
- // binren 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
- [Libreoffice] [Patch] Easy hack: idl removed and translated comments · Michael Münch
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.