[PATCH] idl removed and translated comments
Michael Muench
michael at codingmicha.de
Sat Feb 12 16:17:15 PST 2011
---
idl/inc/basobj.hxx | 7 +-
idl/inc/bastype.hxx | 15 +-
idl/inc/char.hxx | 1 -
idl/inc/command.hxx | 1 -
idl/inc/database.hxx | 10 +-
idl/inc/hash.hxx | 7 +-
idl/inc/lex.hxx | 26 +--
idl/inc/module.hxx | 3 +-
idl/inc/object.hxx | 2 -
idl/inc/slot.hxx | 13 +-
idl/inc/types.hxx | 20 +--
idl/source/cmptools/char.cxx | 2 -
idl/source/cmptools/hash.cxx | 111 +--------
idl/source/cmptools/lex.cxx | 110 +--------
idl/source/objects/basobj.cxx | 219 ++---------------
idl/source/objects/bastype.cxx | 133 +----------
idl/source/objects/module.cxx | 104 ++------
idl/source/objects/object.cxx | 188 +++------------
idl/source/objects/slot.cxx | 221 ++++-------------
idl/source/objects/types.cxx | 526 +++-----------------------------=
--------
idl/source/prj/command.cxx | 101 ++------
idl/source/prj/database.cxx | 218 +++--------------
idl/source/prj/globals.cxx | 11 -
idl/source/prj/idldll.cxx | 8 +-
idl/source/prj/svidl.cxx | 13 +-
25 files changed, 272 insertions(+), 1798 deletions(-)
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;
=20
-/******************** Meta Factory ***********************************=
***/
#define SV_DECL_META_FACTORY( Class, CLASS_ID ) =
\
SV_DECL_PERSIST( Class, CLASS_ID )
=20
@@ -74,7 +73,6 @@ typedef int WriteAttribute;
#define SV_IMPL_META_FACTORY1( Class, Super1 ) =
\
SV_IMPL_PERSIST1( Class, Super1 )
=20
-/******************** class SvMetaObject *****************************=
***/
class SvMetaObject : public SvPersistBase
{
public:
@@ -128,7 +126,6 @@ public:
}
};
=20
-/******************** class SvMetaName *******************************=
***/
class SvMetaName : public SvMetaObject
{
SvString aName;
@@ -180,7 +177,6 @@ SV_DECL_IMPL_REF(SvMetaName)
SV_DECL_IMPL_PERSIST_LIST(SvMetaName,SvMetaName *)
=20
=20
-/******************** 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 *)
=20
=20
-/******************** class SvMetaExtern *****************************=
****/
class SvMetaModule;
class SvMetaExtern : public SvMetaReference
{
- SvMetaModule * pModule; // in welchem Modul enthalten
+ SvMetaModule * pModule; // included in which module
=20
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;
=20
-/******************** class SvUINT32 *********************************=
*/
class SvUINT32
{
UINT32 nVal;
@@ -61,7 +60,6 @@ public:
};
=20
=20
-/******************** class SvINT16 **********************************=
/
class SvINT16
{
short nVal;
@@ -79,7 +77,6 @@ public:
};
=20
=20
-/******************** class SvUINT16 *********************************=
*/
class SvUINT16
{
USHORT nVal;
@@ -97,7 +94,6 @@ public:
};
=20
=20
-/******************** class SvINT32 **********************************=
/
class SvINT32
{
INT32 nVal;
@@ -115,7 +111,6 @@ public:
};
=20
=20
-/******************** class Svint **********************************/
class Svint
{
int =09nVal;
@@ -136,7 +131,6 @@ public:
};
=20
=20
-/******************** class SvBOOL **********************************/=
class SvBOOL
{
BOOL nVal:1,
@@ -165,7 +159,6 @@ public:
};
=20
=20
-/******************** class SvIdentifier *****************************=
*****/
class SvIdentifier : public ByteString
{
public:
@@ -184,11 +177,10 @@ public:
};
=20
=20
-/******************** class SvIdentifier *****************************=
*****/
class SvNumberIdentifier : public SvIdentifier
{
UINT32 nValue;
- // darf nicht benutzt werden
+ // must not be used
BOOL ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInS=
tm );
public:
SvNumberIdentifier() : nValue( 0 ) {};
@@ -209,7 +201,6 @@ public:
};
=20
=20
-/******************** class SvString *********************************=
*/
class SvString : public ByteString
{
public:
@@ -228,7 +219,6 @@ public:
};
=20
=20
-/******************** class SvHelpText *******************************=
***/
class SvHelpText : public SvString
{
public:
@@ -241,12 +231,10 @@ public:
};
=20
=20
-/******************** class SvHelpContext ****************************=
***/
class SvHelpContext : public SvNumberIdentifier
{
};
=20
-/******************** class SvUUId ***********************************=
**/
class SvUUId : public SvGlobalName
{
public:
@@ -258,7 +246,6 @@ public:
};
=20
=20
-/******************** 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 @@
=20
#include <tools/string.hxx>
=20
-/******************* 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;
=20
typedef ::std::vector< ByteString* > ByteStringList;
=20
-/******************** 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>
=20
-/*********************************************************************=
****
-**********************************************************************=
***/
-
class SvCommand;
=20
#ifdef IDL_COMPILER
-/******************** class SvIdlError *******************************=
****/
+
class SvIdlError
{
ByteString aText;
@@ -64,7 +61,6 @@ public:
};
#endif
=20
-/******************** class SvIdlDataBase ****************************=
****/
class SvIdlDataBase
{
BOOL =09=09=09=09=09=09bExport;
@@ -82,7 +78,7 @@ class SvIdlDataBase
SvMetaClassMemberList aClassList;
SvMetaModuleMemberList aModuleList;
SvMetaAttributeMemberList=09aAttrList;
- SvMetaTypeMemberList aTmpTypeList; // nicht Persistent
+ SvMetaTypeMemberList aTmpTypeList; // not persistent
=20
protected:
#ifdef IDL_COMPILER
@@ -111,7 +107,7 @@ public:
SvMetaModuleMemberList & GetModuleList() { return aModuleList; }
SvMetaModule * GetModule( const ByteString & rName );
=20
- // Liste der benutzten Typen beim Schreiben
+ // list of used types while writing
SvMetaTypeMemberList=09aUsedTypes;
ByteString=09=09=09=09=09aIFaceName;
SvNumberIdentifier=09=09aStructSlotId;
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>
=20
-/****************** 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 * pIns=
ertPos );
=20
@@ -56,7 +55,6 @@ public:
virtual BOOL IsEntry( UINT32 ) const =3D 0;
};
=20
-/************** 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:
=20
SV_DECL_IMPL_REF(SvStringHashEntry)
=20
-/****************** S t r i n g H a s h T a b l e ********************=
****/
typedef ::std::vector< SvStringHashEntry* > SvStringHashList;
=20
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>
=20
-/******************** enum *******************************************=
****/
enum SVTOKEN_ENUM { SVTOKEN_EMPTY, SVTOKEN_COMMENT,
SVTOKEN_INTEGER, SVTOKEN_STRING,
SVTOKEN_BOOL, SVTOKEN_IDENTIFIER,
SVTOKEN_CHAR, SVTOKEN_RTTIBASE,
SVTOKEN_EOF,=09=09SVTOKEN_HASHID };
=20
-/******************** class SvToken **********************************=
****/
class BigInt;
class SvToken
{
@@ -53,7 +51,6 @@ friend class SvTokenStream;
ULONG =09nLong;
BOOL =09bBool;
char =09cChar;
-//=09 SvRttiBase * =09pComplexObj;
SvStringHashEntry *=09pHash;
};
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 );
=20
SvToken & operator =3D ( 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; }
=20
void SetHash( SvStringHashEntry * pHashP )
{ pHash =3D pHashP; nType =3D SVTOKEN_HASHID; }
@@ -128,26 +123,19 @@ inline SvToken::SvToken( char c )
inline SvToken::SvToken( SVTOKEN_ENUM nTypeP, const ByteString & rStr =
)
: nType( nTypeP ), aString( rStr ) {}
=20
-/*
-inline SvToken::SvToken( SvRttiBase * pObj )
- : nType( SVTOKEN_RTTIBASE ), pComplexObj( pObj )
- { pObj->AddRef(); }
-*/
-
inline SvToken::SvToken( SVTOKEN_ENUM nTypeP )
: nType( nTypeP ) {}
=20
DECLARE_LIST( SvTokenList, SvToken * )
=20
-/******************** class SvTokenStream ****************************=
****/
class SvTokenStream
{
ULONG nLine, nColumn;
int=09=09=09nBufPos;
- 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=09=09aStrTrue;
ByteString=09=09aStrFalse;
ULONG=09=09nMaxPos;
@@ -179,7 +167,7 @@ class SvTokenStream
}
void=09=09=09CalcColumn()
{
- // wenn Zeilenende berechnung sparen
+ // if end of line spare calculation
if( 0 !=3D c )
{
USHORT n =3D 0;
@@ -207,7 +195,7 @@ public:
{
SvToken * pRetToken =3D pCurToken;
if( NULL =3D=3D (pCurToken =3D aTokList.Prev()=
) )
- // Current Zeiger nie Null
+ // current pointer never null
pCurToken =3D pRetToken;
=20
return pRetToken;
@@ -216,14 +204,14 @@ public:
{
SvToken * pRetToken =3D pCurToken;
if( NULL =3D=3D (pCurToken =3D aTokList.Next()=
) )
- // Current Zeiger nie Null
+ // current pointer never null
pCurToken =3D 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 ) {}
};
=20
-/******************** class SvMetaModule *****************************=
****/
class SvMetaModule : public SvMetaExtern
{
SvMetaClassMemberList =09aClassList;
SvMetaTypeMemberList =09aTypeList;
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( n=
Pos ); }
};
=20
-/******************** 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 *)
=20
-/******************** 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>
=20
-/******************** class SvMetaSlot *******************************=
***/
-//class SbxObject;
class SvMetaSlotMemberList;
class SvMetaSlot : public SvMetaAttribute
{
@@ -49,15 +47,15 @@ class SvMetaSlot : public SvMetaAttribute
SvBOOL aGet;
SvBOOL aSet;
=20
- SvBOOL aCachable; // exclusiv
+ SvBOOL aCachable; // exclusive
SvBOOL aVolatile;
SvBOOL aToggle;
SvBOOL aAutoUpdate;
=20
- SvBOOL aSynchron; // exclusiv
+ SvBOOL aSynchron; // exclusive
SvBOOL aAsynchron;
=20
- SvBOOL aRecordPerItem;// exclusiv
+ SvBOOL aRecordPerItem;// exclusive
SvBOOL aRecordPerSet;
SvBOOL aRecordManual;
SvBOOL aNoRecord;
@@ -202,10 +200,6 @@ public:
const ByteString & GetDefault() const;
const ByteString &=09=09GetDisableFlags() 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=09=09=09=09ResetSlotPointer()
{ pNextSlot =3D pLinkedSlot =3D 0; }
=20
-// void FillSbxObject( SvIdlDataBase & rBase, SbxObj=
ect *, BOOL bProp );
#ifdef IDL_COMPILER
SvMetaEnumValue*=09GetEnumValue() 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;
=20
-/******************** class SvMetaAttribute **************************=
***/
SV_DECL_REF(SvMetaType)
SV_DECL_REF(SvMetaAttribute)
SV_DECL_PERSIST_LIST(SvMetaAttribute,SvMetaAttribute *)
@@ -105,8 +104,6 @@ public:
virtual BOOL=09=09IsVariable() const;
virtual ByteString =09GetMangleName( BOOL bVariable ) const;
=20
-// void FillSbxObject( SbxInfo * pInfo, USHORT nSbxF=
lags =3D 0 );
-// virtual void FillSbxObject( SvIdlDataBase & rBase, SbxObj=
ect * pObj, BOOL bVariable );
=20
#ifdef IDL_COMPILER
virtual BOOL=09=09Test( SvIdlDataBase &, SvTokenStream & rInStm );=
@@ -135,14 +132,13 @@ SV_IMPL_REF(SvMetaAttribute)
SV_IMPL_PERSIST_LIST(SvMetaAttribute,SvMetaAttribute *)
=20
=20
-/******************** 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 =09=09=09=09=09aIn; // Eingangsparameter
- SvBOOL=09=09=09=09=09=09aOut; // Returnparameter
+ SvBOOL =09=09=09=09=09aIn; // input parameter
+ SvBOOL=09=09=09=09=09=09aOut; // return parameter
Svint=09=09=09=09=09=09aCall0, aCall1;
Svint=09=09=09=09=09=09aSbxDataType;
SvIdentifier=09=09=09=09aSvName;
@@ -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/*, SbxDataTyp=
e nT =3D SbxEMPTY */);
+ const ByteString & rBasicPostfix );
=20
SvMetaAttributeMemberList &=09GetAttrList() const;
ULONG=09=09=09=09GetAttrCount() const
@@ -205,10 +201,6 @@ public:
BOOL=09=09=09=09IsItem() const { return bIsItem; }
BOOL=09=09=09=09IsShell() const { return bIsShell; }
=20
-// void SetSbxDataType( SbxDataType nT )
-// { aSbxDataType =3D (int)nT; }
-// SbxDataType GetSbxDataType() const;
-
void SetIn( BOOL b ) { aIn =3D b; }
BOOL GetIn() const;
=20
@@ -234,7 +226,6 @@ public:
=20
virtual BOOL SetName( const ByteString & rName, SvIdlDataBa=
se * =3D NULL );
=20
-// void FillSbxObject( SbxVariable * pObj, BOOL bVar=
iable );
=20
#ifdef IDL_COMPILER
virtual BOOL ReadSvIdl( SvIdlDataBase &, SvTokenStream & rI=
nStm );
@@ -249,7 +240,6 @@ public:
=20
ULONG=09=09=09=09MakeSfx( ByteString * pAtrrArray );
virtual void =09=09WriteSfx( SvIdlDataBase & rBase, SvStream & rOu=
tStm );
- //BOOL=09=09=09=09ReadTypePrefix( SvIdlDataBase &, SvTokenStream &=
rInStm );
BOOL =09=09=09=09ReadMethodArgs( SvIdlDataBase & rBase,
SvTokenStream & rInStm );=
void WriteTypePrefix( SvIdlDataBase & rBase, SvStre=
am & rOutStm, USHORT nTab, WriteType );
@@ -265,7 +255,6 @@ DECLARE_LIST(SvMetaTypeList,SvMetaType *)
SV_DECL_IMPL_PERSIST_LIST(SvMetaType,SvMetaType *)
=20
=20
-/******************** class SvTypeString *****************************=
****/
class SvMetaTypeString : public SvMetaType
{
public:
@@ -276,7 +265,6 @@ SV_DECL_IMPL_REF(SvMetaTypeString)
SV_DECL_IMPL_PERSIST_LIST(SvMetaTypeString,SvMetaTypeString *)
=20
=20
-/******************** class SvMetaEnumValue **************************=
********/
class SvMetaEnumValue : public SvMetaName
{
ByteString aEnumValue;
@@ -295,7 +283,6 @@ SV_DECL_IMPL_REF(SvMetaEnumValue)
SV_DECL_IMPL_PERSIST_LIST(SvMetaEnumValue,SvMetaEnumValue *)
=20
=20
-/******************** class SvTypeEnum *******************************=
**/
class SvMetaTypeEnum : public SvMetaType
{
SvMetaEnumValueMemberList aEnumValueList;
@@ -331,7 +318,6 @@ SV_DECL_IMPL_REF(SvMetaTypeEnum)
SV_DECL_IMPL_PERSIST_LIST(SvMetaTypeEnum,SvMetaTypeEnum *)
=20
=20
-/******************** class SvTypeVoid *******************************=
****/
class SvMetaTypevoid : public SvMetaType
{
public:
diff --git a/idl/source/cmptools/char.cxx b/idl/source/cmptools/char.cx=
x
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"
=20
-/****************** I N C L U D E S **********************************=
****/
#include <ctype.h>
#include <string.h>
=20
@@ -37,7 +36,6 @@
=20
#include <char.hxx>
=20
-/****************** D A T E N ****************************************=
****/
static unsigned char EqualTab[ 256 ] =3D {
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.cx=
x
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"
=20
-/****************** 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>
=20
-// Programmabh=84ngige Includes.
+// program-sensitive includes
#include <hash.hxx>
#include <tools/debug.hxx>
=20
-/****************** C O D E ******************************************=
****/
-/*********************************************************************=
****
-|*
-|* SvStringHashEntry::~SvStringHashEntry()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvStringHashEntry::~SvStringHashEntry() { };
=20
-/*********************************************************************=
****
-|*
-|* SvHashTable::SvHashTable()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvHashTable::SvHashTable( UINT32 nMaxEntries )
{
nMax =3D nMaxEntries; // set max entries
@@ -64,13 +48,6 @@ SvHashTable::SvHashTable( UINT32 nMaxEntries )
lAsk =3D 0;
}
=20
-/*********************************************************************=
****
-|*
-|* SvHashTable::~SvHashTable()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvHashTable::~SvHashTable()
{
#ifdef DOS_NIE
@@ -81,13 +58,6 @@ SvHashTable::~SvHashTable()
#endif
}
=20
-/*********************************************************************=
****
-|*
-|* 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 * pElemen=
t, BOOL bInsert,
return( FALSE );
}
=20
-/*********************************************************************=
***/
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::SvStringHashTable()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
: SvHashTable( nMaxEntries )
{
@@ -145,7 +107,7 @@ SvStringHashTable::SvStringHashTable( UINT32 nMaxEn=
tries )
#endif
pEntries =3D new SvStringHashEntry[ nMaxEntries ];
=20
- // RefCount auf eins setzen
+ // set RefCount to one
SvStringHashEntry * pPos, *pEnd;
pPos =3D pEntries;
pEnd =3D pEntries + nMaxEntries;
@@ -156,17 +118,10 @@ SvStringHashTable::SvStringHashTable( UINT32 nMax=
Entries )
}
}
=20
-/*********************************************************************=
****
-|*
-|* ~SvStringHashTable::SvStringHashTable()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvStringHashTable::~SvStringHashTable()
{
#ifdef DBG_UTIL
- // RefCount auf eins setzen
+ // set RefCount to one
SvStringHashEntry * pPos, *pEnd;
pPos =3D pEntries;
pEnd =3D pEntries + GetMax();
@@ -180,13 +135,6 @@ SvStringHashTable::~SvStringHashTable()
delete [] pEntries;
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::HashFunc()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
UINT32 SvStringHashTable::HashFunc( const void * pElement ) const
{
UINT32 nHash =3D 0; // hash value
@@ -208,13 +156,6 @@ UINT32 SvStringHashTable::HashFunc( const void * p=
Element ) const
return( nHash );
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::GetNearString()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
ByteString SvStringHashTable::GetNearString( const ByteString & rName =
) const
{
for( UINT32 i =3D 0; i < GetMax(); i++ )
@@ -229,13 +170,6 @@ ByteString SvStringHashTable::GetNearString( const=
ByteString & rName ) const
return ByteString();
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::IsEntry()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const
{
if( nIndex >=3D GetMax() )
@@ -243,13 +177,6 @@ BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) c=
onst
return pEntries[ nIndex ].HasId();
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::Insert()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvStringHashTable::Insert( const ByteString & rName, UINT32 * pIn=
dex )
{
UINT32 nIndex;
@@ -264,26 +191,12 @@ BOOL SvStringHashTable::Insert( const ByteString =
& rName, UINT32 * pIndex )
return TRUE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::Test()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvStringHashTable::Test( const ByteString & rName, UINT32 * pPos =
) const
{
return ((SvStringHashTable *)this)->SvHashTable::
Test_Insert( &rName, FALSE, pPos );
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::Get()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvStringHashEntry * SvStringHashTable::Get( UINT32 nIndex ) const
{
if( IsEntry( nIndex ) )
@@ -291,26 +204,12 @@ SvStringHashEntry * SvStringHashTable::Get( UINT3=
2 nIndex ) const
return( NULL );
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::Get()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
StringCompare SvStringHashTable::Compare( const void * pElement,
UINT32 nIndex ) const
{
return ((const ByteString *)pElement)->CompareTo( pEntries[ nIndex=
].GetName() );
}
=20
-/*********************************************************************=
****
-|*
-|* SvStringHashTable::FillHashList()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
void SvStringHashTable::FillHashList( SvStringHashList * pList ) const=
{
for( UINT32 n =3D 0; n < GetMax(); n++ )
@@ -318,7 +217,7 @@ void SvStringHashTable::FillHashList( SvStringHashL=
ist * pList ) const
if( IsEntry( n ) )
pList->push_back( Get( n ) );
}
- // Hash Reihenfolge, jetzt sortieren
+ // hash order, sort now
}
=20
/* vim:set shiftwidth=3D4 softtabstop=3D4 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>
=20
-/****************** SvToken ******************************************=
****/
-/*********************************************************************=
****
-|*
-|* SvToken::Print()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
ByteString SvToken::GetTokenAsString() const
{
ByteString aStr;
@@ -73,7 +65,7 @@ ByteString SvToken::GetTokenAsString() const
aStr =3D cChar;
break;
case SVTOKEN_RTTIBASE:
- aStr =3D "RTTIBASE";//(ULONG)pComplexObj;
+ aStr =3D "RTTIBASE";
break;
case SVTOKEN_EOF:
case SVTOKEN_HASHID:
@@ -83,68 +75,28 @@ ByteString SvToken::GetTokenAsString() const
return aStr;
}
=20
-/*********************************************************************=
****
-|*
-|* SvToken::SvToken()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvToken::SvToken( const SvToken & rObj )
{
nLine =3D rObj.nLine;
nColumn =3D rObj.nColumn;
nType =3D rObj.nType;
aString =3D rObj.aString;
-/*
- if( SVTOKEN_RTTIBASE =3D nType )
- {
- pComplexObj =3D rObj.pComplexObj;
- pComplexObj->AddRef();
- }
- else
-*/
- nLong =3D rObj.nLong;
+ nLong =3D rObj.nLong;
}
=20
-/*********************************************************************=
****
-|*
-|* SvToken::operator =3D ()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvToken & SvToken::operator =3D ( const SvToken & rObj )
{
if( this !=3D &rObj )
{
-/*
- if( SVTOKEN_RTTIBASE =3D nType )
- pComplexObj->ReleaseRef();
-*/
nLine =3D rObj.nLine;
nColumn =3D rObj.nColumn;
nType =3D rObj.nType;
aString =3D rObj.aString;
-/*
- if( SVTOKEN_RTTIBASE =3D nType )
- {
- pComplexObj =3D rObj.pComplexObj;
- pComplexObj->AddRef();
- }
- else
-*/
- nLong =3D rObj.nLong;
+ nLong =3D rObj.nLong;
}
return *this;
}
=20
-/****************** SvTokenStream ************************************=
****/
-/*********************************************************************=
****
-|* SvTokenStream::InitCtor()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvTokenStream::InitCtor()
{
#ifdef DOS
@@ -163,11 +115,6 @@ void SvTokenStream::InitCtor()
FillTokenList();
}
=20
-/*********************************************************************=
****
-|* 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 & rFile=
Name )
InitCtor();
}
=20
-/*********************************************************************=
****
-|* SvTokenStream::SvTokenStream()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFile=
Name )
: pInStream( NULL )
, rInStream( rStream )
@@ -191,11 +133,6 @@ SvTokenStream::SvTokenStream( SvStream & rStream, =
const String & rFileName )
InitCtor();
}
=20
-/*********************************************************************=
****
-|* SvTokenStream::~SvTokenStream()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvTokenStream::~SvTokenStream()
{
delete pInStream;
@@ -207,11 +144,6 @@ SvTokenStream::~SvTokenStream()
}
}
=20
-/*********************************************************************=
****
-|* SvTokenStream::FillTokenList()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvTokenStream::FillTokenList()
{
SvToken * pToken =3D new SvToken();
@@ -243,11 +175,6 @@ void SvTokenStream::FillTokenList()
pCurToken =3D aTokList.First();
}
=20
-/*********************************************************************=
****
-|* SvTokenStrem::SetCharSet()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvTokenStream::SetCharSet( CharSet nSet )
{
nCharSet =3D nSet;
@@ -259,11 +186,6 @@ void SvTokenStream::SetCharSet( CharSet nSet )
#endif
}
=20
-/*********************************************************************=
****
-|* SvTokeStream::GetNextChar()
-|*
-|* Beschreibung
-**********************************************************************=
***/
int SvTokenStream::GetNextChar()
{
int nChar;
@@ -288,11 +210,6 @@ int SvTokenStream::GetNextChar()
return nChar;
}
=20
-/*********************************************************************=
****
-|* SvTokenStrem::GetNumber()
-|*
-|* Beschreibung
-**********************************************************************=
***/
ULONG SvTokenStream::GetNumber()
{
ULONG l =3D 0;
@@ -331,18 +248,13 @@ ULONG SvTokenStream::GetNumber()
return( l );
}
=20
-/*********************************************************************=
****
-|* SvTokenStream::MakeToken()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvTokenStream::MakeToken( SvToken & rToken )
{
do
{
if( 0 =3D=3D c )
c =3D GetNextChar();
- // Leerzeichen ueberlesen
+ // skip whitespace
while( isspace( c ) || 26 =3D=3D c )
{
c =3D GetFastNextChar();
@@ -353,31 +265,26 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )=
=20
ULONG nLastLine=09=09=3D nLine;
ULONG nLastColumn=09=3D nColumn;
- // Kommentar
+ // comment
if( '/' =3D=3D c )
{
- // Zeit Optimierung, keine Kommentare
- //ByteString aComment( (char)c );
+ // time optimization, no comments
int c1 =3D c;
c =3D GetFastNextChar();
if( '/' =3D=3D c )
{
while( '\0' !=3D c )
{
- //aComment +=3D (char)c;
c =3D GetFastNextChar();
}
c =3D GetNextChar();
rToken.nType =09=3D SVTOKEN_COMMENT;
- //rToken.aString=09=3D aComment;
}
else if( '*' =3D=3D c )
{
- //aComment +=3D (char)c;
c =3D GetFastNextChar();
do
{
- //aComment +=3D (char)c;
while( '*' !=3D c )
{
if( '\0' =3D=3D c )
@@ -388,17 +295,14 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )=
}
else
c =3D GetFastNextChar();
- //aComment +=3D (char)c;
}
c =3D GetFastNextChar();
}
while( '/' !=3D c && !IsEof() && ( SVSTREAM_OK =3D=3D rInS=
tream.GetError() ) );
if( IsEof() || ( SVSTREAM_OK !=3D rInStream.GetError() ) )=
return FALSE;
- //aComment +=3D (char)c;
c =3D GetNextChar();
rToken.nType =3D SVTOKEN_COMMENT;
- //rToken.aString =3D aComment;
CalcColumn();
}
else
@@ -416,7 +320,7 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )
c =3D GetFastNextChar();
if( '\0' =3D=3D c )
{
- // Strings auch "uber das Zeilenende hinauslesen
+ // read strings beyond end of line
aStr +=3D '\n';
c =3D 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>
=20
-/****************** SvMetaObject *************************************=
****/
SV_IMPL_META_FACTORY1( SvMetaObject, SvRttiBase )
-/*********************************************************************=
****
-|* SvMetaObject::SvMetaObject()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaObject::SvMetaObject()
{
}
@@ -58,24 +52,13 @@ void SvMetaObject::Save( SvPersistStream & )
{
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::WriteTab()
-|*
-|* Beschreibung
-**********************************************************************=
***/
#ifdef IDL_COMPILER
void SvMetaObject::WriteTab( SvStream & rOutStm, USHORT nTab )
{
while( nTab-- )
rOutStm << " ";
-// rOutStm << '\t';
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::WriteStart()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaObject::WriteStars( SvStream & rOutStm )
{
rOutStm << '/';
@@ -84,14 +67,9 @@ void SvMetaObject::WriteStars( SvStream & rOutStm )
rOutStm << '/' << endl;
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::TestAndSeekSpaceOnly()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaObject::TestAndSeekSpaceOnly( SvStream & rOutStm, ULONG nBe=
gPos )
{
- // keine leeren Klammern schreiben
+ // write no empty brackets
ULONG nPos =3D rOutStm.Tell();
rOutStm.Seek( nBegPos );
BOOL bOnlySpace =3D TRUE;
@@ -103,21 +81,16 @@ BOOL SvMetaObject::TestAndSeekSpaceOnly( SvStream =
& rOutStm, ULONG nBegPos )
bOnlySpace =3D FALSE;
}
if( bOnlySpace )
- // nichts geschrieben
+ // nothing written
rOutStm.Seek( nBegPos );
else
rOutStm.Seek( nPos );
return bOnlySpace;
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::Back2Delemitter()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaObject::Back2Delemitter( SvStream & rOutStm )
{
- // keine leeren Klammern schreiben
+ // write no empty brackets
ULONG nPos =3D rOutStm.Tell();
rOutStm.SeekRel( -1 );
char c =3D 0;
@@ -135,62 +108,31 @@ void SvMetaObject::Back2Delemitter( SvStream & rO=
utStm )
rOutStm.Seek( nPos );
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaObject::ReadSvIdl( SvIdlDataBase &, SvTokenStream & )
{
return FALSE;
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::WriteSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaObject::WriteSvIdl( SvIdlDataBase &, SvStream &, USHORT /*n=
Tab */ )
{
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::Write()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaObject::Write( SvIdlDataBase &, SvStream &, USHORT /*nTab *=
/,
WriteType, WriteAttribute )
{
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::WriteCxx()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaObject::WriteCxx( SvIdlDataBase &, SvStream &, USHORT /*nTa=
b */ )
{
}
=20
-/*********************************************************************=
****
-|* SvMetaObject::WriteHxx()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaObject::WriteHxx( SvIdlDataBase &, SvStream &, USHORT /*nTa=
b */ )
{
}
=20
#endif
=20
-/****************** SvMetaName ***************************************=
**/
SV_IMPL_META_FACTORY1( SvMetaName, SvMetaObject );
-/*********************************************************************=
****
-|* SvMetaName::SvMetaName()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaName::SvMetaName()
{
}
@@ -239,18 +181,13 @@ BOOL SvMetaName::SetName( const ByteString & rNam=
e, SvIdlDataBase * )
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|* SvMetaName::ReadNameSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaName::ReadNameSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos =3D rInStm.Tell();
SvToken * pTok =3D rInStm.GetToken_Next();
=20
- // Modulnamen lesen
+ // read module name
if( pTok->IsIdentifier() )
if( SetName( pTok->GetString(), &rBase ) )
return TRUE;
@@ -259,11 +196,6 @@ BOOL SvMetaName::ReadNameSvIdl( SvIdlDataBase & rB=
ase,
return FALSE;
}
=20
-/*********************************************************************=
****
-|* SvMetaName::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -277,21 +209,12 @@ void SvMetaName::ReadAttributesSvIdl( SvIdlDataBa=
se & rBase,
aHelpText.ReadSvIdl( rBase, rInStm );
aConfigName.ReadSvIdl( SvHash_ConfigName(), rInStm );
aDescription.ReadSvIdl( SvHash_Description(), rInStm );
-/*
- aHelpContext.ReadSvIdl( GetModule()->GetInfo()->GetHelpContextCont=
ainer(),
- rInStm );
-*/
}
=20
-/*********************************************************************=
****
-|* SvMetaName::DoReadContextSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::DoReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm, char cDel )=
{
- UINT32 nBeginPos =3D 0; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos =3D 0; // can not happen with Tell
while( nBeginPos !=3D rInStm.Tell() )
{
nBeginPos =3D rInStm.Tell();
@@ -303,39 +226,19 @@ void SvMetaName::DoReadContextSvIdl( SvIdlDataBas=
e & rBase,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaName::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::ReadContextSvIdl( SvIdlDataBase &, SvTokenStream & )
{
}
=20
-/*********************************************************************=
****
-|* SvMetaName::Test()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaName::Test( SvIdlDataBase &, SvTokenStream & )
{
return TRUE;
}
=20
-/*********************************************************************=
****
-|* SvMetaName::WriteContextSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::WriteContextSvIdl( SvIdlDataBase &, SvStream &, USHOR=
T )
{
}
=20
-/*********************************************************************=
****
-|* SvMetaName::WriteDescription()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::WriteDescription( SvStream & rOutStm )
{
rOutStm << "<DESCRIPTION>" << endl;
@@ -352,11 +255,6 @@ void SvMetaName::WriteDescription( SvStream & rOut=
Stm )
rOutStm << aDesc.GetBuffer() << endl << "</DESCRIPTION>" << endl;
}
=20
-/*********************************************************************=
****
-|* SvMetaName::WriteAttributesIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -386,18 +284,13 @@ void SvMetaName::WriteAttributesSvIdl( SvIdlDataB=
ase & rBase,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaName::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaName::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rIn=
Stm )
{
UINT32 nTokPos =3D rInStm.Tell();
BOOL bOk =3D TRUE;
if( rInStm.Read( '[' ) )
{
- UINT32 nBeginPos =3D 0; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos =3D 0; // can not happen with Tell
while( nBeginPos !=3D rInStm.Tell() )
{
nBeginPos =3D rInStm.Tell();
@@ -421,11 +314,6 @@ BOOL SvMetaName::ReadSvIdl( SvIdlDataBase & rBase,=
SvTokenStream & rInStm )
return bOk;
}
=20
-/*********************************************************************=
****
-|* 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 =3D rOutStm.Tell();
WriteAttributesSvIdl( rBase, rOutStm, nTab +1 );
=20
- // 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 =3D rOutStm.Tell();
WriteContextSvIdl( rBase, rOutStm, nTab +1 );
=20
- // 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,
}
}
=20
-/*********************************************************************=
****
-|* 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, SvSt=
ream & rOutStm,
ULONG nOldPos =3D rOutStm.Tell();
WriteAttributes( rBase, rOutStm, nTab +1, nT, nA );
=20
- // keine leeren Klammern schreiben
+ // write no empty brackets
ULONG nPos =3D rOutStm.Tell();
rOutStm.Seek( nOldPos );
BOOL bOnlySpace =3D TRUE;
@@ -490,7 +373,7 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvSt=
ream & rOutStm,
bOnlySpace =3D FALSE;
}
if( bOnlySpace )
- // nichts geschrieben
+ // nothing written
rOutStm.Seek( nBeginPos );
else
{
@@ -500,11 +383,6 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvS=
tream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaName::WriteAttributes()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::WriteAttributes( SvIdlDataBase &, SvStream & rOutStm,=
USHORT nTab,
WriteType, WriteAttribute )
@@ -529,11 +407,6 @@ void SvMetaName::WriteAttributes( SvIdlDataBase &,=
SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaName::WriteContext()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaName::WriteContext( SvIdlDataBase &, SvStream &,
USHORT,
WriteType, WriteAttribute )
@@ -541,14 +414,8 @@ void SvMetaName::WriteContext( SvIdlDataBase &, Sv=
Stream &,
}
#endif // IDL_COMPILER
=20
-/****************** SvMetaReference **********************************=
*******/
SV_IMPL_META_FACTORY1( SvMetaReference, SvMetaName );
=20
-/*********************************************************************=
****
-|* SvMetaReference::SvMetaReference()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaReference::SvMetaReference()
{
}
@@ -577,25 +444,18 @@ void SvMetaReference::Save( SvPersistStream & rSt=
m )
{
SvMetaName::Save( rStm );
=20
- // Maske erstellen
+ // create mask
BYTE nMask =3D 0;
if( aRef.Is() )
nMask |=3D 0x01;
=20
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aRef;
}
=20
-/*********************************************************************=
*****/
-/****************** SvMetaExtern *************************************=
*****/
SV_IMPL_META_FACTORY1( SvMetaExtern, SvMetaReference );
=20
-/*********************************************************************=
****
-|* SvMetaExtern::SvMetaExtern()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaExtern::SvMetaExtern()
: pModule( NULL )
, bReadUUId( FALSE )
@@ -626,7 +486,7 @@ void SvMetaExtern::Save( SvPersistStream & rStm )
{
SvMetaReference::Save( rStm );
=20
- // Maske erstellen
+ // create mask
BYTE nMask =3D 0;
if( pModule ) =09nMask |=3D 0x01;
if( aUUId !=3D SvGlobalName() )=09nMask |=3D 0x02;
@@ -634,29 +494,19 @@ void SvMetaExtern::Save( SvPersistStream & rStm )=
if( bReadUUId ) =09=09=09=09nMask |=3D 0x08;
if( bReadVersion ) =09=09=09nMask |=3D 0x10;
=20
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << pModule;
if( nMask & 0x02 ) rStm << aUUId;
if( nMask & 0x04 ) rStm << aVersion;
}
=20
-/*********************************************************************=
****
-|* SvMetaExtern::GetModule()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaModule * SvMetaExtern::GetModule() const
{
DBG_ASSERT( pModule !=3D NULL, "module not set" );
return pModule;
}
=20
-/*********************************************************************=
****
-|* SvMetaExtern::GetUUId()
-|*
-|* Beschreibung
-**********************************************************************=
***/
const SvGlobalName & SvMetaExtern::GetUUId() const
{
#ifdef IDL_COMPILER
@@ -667,21 +517,11 @@ const SvGlobalName & SvMetaExtern::GetUUId() cons=
t
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|* SvMetaExtern::SetModule()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaExtern::SetModule( SvIdlDataBase & rBase )
{
pModule =3D (SvMetaModule *)rBase.GetStack().Get( TYPE( SvMetaModu=
le ) );
}
=20
-/*********************************************************************=
****
-|* SvMetaExtern::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -692,11 +532,6 @@ void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataB=
ase & rBase,
bReadVersion =3D TRUE;
}
=20
-/*********************************************************************=
****
-|* SvMetaExtern::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaExtern::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm, USHORT nT=
ab )
{
@@ -721,34 +556,19 @@ void SvMetaExtern::WriteAttributesSvIdl( SvIdlDat=
aBase & rBase,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaExtern::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaExtern::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & r=
InStm )
{
SetModule( rBase );
- GetUUId(); // Id wird angelegt
+ GetUUId(); // id gets created
return SvMetaReference::ReadSvIdl( rBase, rInStm );
}
=20
-/*********************************************************************=
****
-|* SvMetaExtern::WriteSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaExtern::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutS=
tm,
USHORT nTab )
{
SvMetaReference::WriteSvIdl( rBase, rOutStm, nTab );
}
=20
-/*********************************************************************=
****
-|* 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, S=
vStream & rOutStm,
SvMetaReference::Write( rBase, rOutStm, nTab, nT, nA );
}
=20
-/*********************************************************************=
****
-|* 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/bastyp=
e.cxx
index fff80cc..1c14469 100644
--- a/idl/source/objects/bastype.cxx
+++ b/idl/source/objects/bastype.cxx
@@ -40,7 +40,6 @@
#include <database.hxx>
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
***/
static BOOL ReadRangeSvIdl( SvStringHashEntry * pName, SvTokenStream &=
rInStm,
ULONG nMin, ULONG nMax, ULONG* pValue )
{
@@ -72,12 +71,6 @@ static BOOL ReadRangeSvIdl( SvStringHashEntry * pNam=
e, SvTokenStream & rInStm,
}
#endif
=20
-/*********************************************************************=
****
-|*
-|* 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 );
}
=20
-/*********************************************************************=
****
-|*
-|* SvStream& operator << ( SvBOOL )
-|* SvStream& operator >> ( SvBOOL )
-|*
-**********************************************************************=
***/
SvStream& operator << (SvStream & rStm, const SvBOOL & rb )
{
BYTE n =3D rb.nVal;
@@ -116,19 +103,13 @@ SvStream& operator >> (SvStream & rStm, SvBOOL & =
rb )
return rStm;
}
=20
-/*********************************************************************=
****
-|*
-|* SvStream& operator << ( SvVersion )
-|* SvStream& operator >> ( SvVersion )
-|*
-**********************************************************************=
***/
SvStream& operator << (SvStream & rStm, const SvVersion & r )
{
if( (r.GetMajorVersion() || r.GetMinorVersion())
&& r.GetMajorVersion() <=3D 0x0F && r.GetMinorVersion() <=3D 0x0=
F )
- { // 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
=20
int n =3D r.GetMajorVersion() << 4;
n |=3D r.GetMinorVersion();
@@ -148,12 +129,12 @@ SvStream& operator >> (SvStream & rStm, SvVersion=
& r )
BYTE n;
rStm >> n;
if( n =3D=3D 0 )
- { // nicht komprimiert
+ { // not compressed
rStm >> r.nMajorVersion;
rStm >> r.nMinorVersion;
}
else
- { // komprimiert
+ { // compressed
r.nMajorVersion =3D (n >> 4) & 0x0F;
r.nMinorVersion =3D n & 0x0F;
}
@@ -162,13 +143,6 @@ SvStream& operator >> (SvStream & rStm, SvVersion =
& r )
=20
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
***/
-
-/*********************************************************************=
****
-|*
-|* SvBOOL::ReadSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rIn=
Stm )
{
UINT32 nTokPos =3D rInStm.Tell();
@@ -191,7 +165,7 @@ BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, =
SvTokenStream & rInStm )
bOk =3D rInStm.Read( ')' );
}
else
- *this =3D TRUE; //Defaultaktion ist auf TRUE setzen
+ *this =3D TRUE; //default action set to TRUE
if( bOk )
return TRUE;
}
@@ -199,13 +173,6 @@ BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName,=
SvTokenStream & rInStm )
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* 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;
}
=20
-/*********************************************************************=
****
-|*
-|* SvBOOL::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
ByteString SvBOOL::GetSvIdlString( SvStringHashEntry * pName )
{
if( nVal )
@@ -235,14 +195,6 @@ ByteString SvBOOL::GetSvIdlString( SvStringHashEnt=
ry * pName )
}
=20
=20
-/*********************************************************************=
***/
-/*********************************************************************=
****
-|*
-|* SvIdentifier::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvIdentifier::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream=
& rInStm )
{
UINT32 nTokPos =3D rInStm.Tell();
@@ -270,13 +222,6 @@ BOOL SvIdentifier::ReadSvIdl( SvStringHashEntry * =
pName, SvTokenStream & rInStm
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvIdentifier::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvIdentifier::WriteSvIdl( SvStringHashEntry * pName,
SvStream & rOutStm,
USHORT /*nTab */ )
@@ -299,14 +244,6 @@ SvStream& operator >> (SvStream & rStm, SvIdentifi=
er & r )
}
=20
=20
-/*********************************************************************=
***/
-/*********************************************************************=
****
-|*
-|* SvNumberIdentifier::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
SvStringHashEntry * pName,
SvTokenStream & rInStm )
@@ -331,13 +268,6 @@ BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase =
& rBase,
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvNumberIdentifier::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -366,12 +296,6 @@ BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase =
& rBase,
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvStream& operator << ( SvNumberIdentifier )
-|* SvStream& operator >> ( SvNumberIdentifier )
-|*
-**********************************************************************=
***/
SvStream& operator << (SvStream & rStm, const SvNumberIdentifier & r )=
{
rStm << (SvIdentifier &)r;
@@ -387,12 +311,6 @@ SvStream& operator >> (SvStream & rStm, SvNumberId=
entifier & r )
}
=20
=20
-/*********************************************************************=
***/
-/*********************************************************************=
****
-|*
-|* SvString::ReadSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvString::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & r=
InStm )
{
UINT32 nTokPos =3D rInStm.Tell();
@@ -420,11 +338,6 @@ BOOL SvString::ReadSvIdl( SvStringHashEntry * pNam=
e, SvTokenStream & rInStm )
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvString::WriteSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvString::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutS=
tm,
USHORT /*nTab */ )
{
@@ -446,32 +359,16 @@ SvStream& operator >> (SvStream & rStm, SvString =
& r )
}
=20
=20
-/*********************************************************************=
****
-|*
-|* SvHelpText::ReadSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvHelpText::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
{
return SvString::ReadSvIdl( SvHash_HelpText(), rInStm );
}
=20
-/*********************************************************************=
****
-|*
-|* SvHelpText::WriteSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvHelpText::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, USHO=
RT nTab )
{
return SvString::WriteSvIdl( SvHash_HelpText(), rOutStm, nTab );
}
=20
-/*********************************************************************=
***/
-/*********************************************************************=
****
-|*
-|* SvUUId::ReadSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
{
UINT32 nTokPos =3D rInStm.Tell();
@@ -499,26 +396,15 @@ BOOL SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenS=
tream & rInStm )
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvMetaObject::WriteSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvUUId::WriteSvIdl( SvStream & rOutStm )
{
- // Global Id schreiben
+ // write global id
rOutStm << SvHash_uuid()->GetName().GetBuffer() << "(\"";
rOutStm << ByteString( GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBu=
ffer() << "\")";
return TRUE;
}
=20
=20
-/*********************************************************************=
***/
-/*********************************************************************=
****
-|*
-|* SvVersion::ReadSvIdl()
-|*
-**********************************************************************=
***/
BOOL SvVersion::ReadSvIdl( SvTokenStream & rInStm )
{
ULONG n =3D 0;
@@ -543,11 +429,6 @@ BOOL SvVersion::ReadSvIdl( SvTokenStream & rInStm =
)
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* 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>
=20
-/****************** SvMetaModule *************************************=
*****/
SV_IMPL_META_FACTORY1( SvMetaModule, SvMetaExtern );
=20
-/*********************************************************************=
****
-|* SvMetaModule::SvMetaModule()
-**********************************************************************=
***/
SvMetaModule::SvMetaModule()
#ifdef IDL_COMPILER
: bImported( FALSE )
@@ -60,30 +56,27 @@ SvMetaModule::SvMetaModule( const String & rIdlFile=
Name, BOOL bImp )
}
#endif
=20
-/*********************************************************************=
****
-|* SvMetaModule::Load()
-**********************************************************************=
***/
#define MODULE_VER 0x0001
void SvMetaModule::Load( SvPersistStream & rStm )
{
- bImported =3D TRUE; // immer importiert
+ bImported =3D TRUE; // import always
SvMetaExtern::Load( rStm );
=20
USHORT nVer;
=20
- rStm >> nVer; // Version
+ rStm >> nVer; // version
DBG_ASSERT( (nVer & ~IDL_WRITE_MASK) =3D=3D MODULE_VER, "false ver=
sion" );
=20
rStm >> aClassList;
rStm >> aTypeList;
rStm >> aAttrList;
- // Browser
+ // browser
rStm.ReadByteString( aIdlFileName );
rStm.ReadByteString( aHelpFileName );
rStm.ReadByteString( aSlotIdFile );
rStm.ReadByteString( aModulePrefix );
=20
- // Compiler Daten lesen
+ // read compiler data
USHORT nCmpLen;
rStm >> nCmpLen;
#ifdef IDL_COMPILER
@@ -97,25 +90,22 @@ void SvMetaModule::Load( SvPersistStream & rStm )
#endif
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::Save()
-**********************************************************************=
***/
void SvMetaModule::Save( SvPersistStream & rStm )
{
SvMetaExtern::Save( rStm );
=20
- rStm << (USHORT)(MODULE_VER | IDL_WRITE_COMPILER); // Version
+ rStm << (USHORT)(MODULE_VER | IDL_WRITE_COMPILER); // version
=20
rStm << aClassList;
rStm << aTypeList;
rStm << aAttrList;
- // Browser
+ // browser
rStm.WriteByteString( aIdlFileName );
rStm.WriteByteString( aHelpFileName );
rStm.WriteByteString( aSlotIdFile );
rStm.WriteByteString( aModulePrefix );
=20
- // Compiler Daten schreiben
+ // write compiler data
USHORT nCmpLen =3D 0;
ULONG nLenPos =3D 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 =3D rStm.Tell();
rStm.Seek( nLenPos );
rStm << (USHORT)( nPos - nLenPos - sizeof( USHORT ) );
@@ -131,9 +121,6 @@ void SvMetaModule::Save( SvPersistStream & rStm )
#endif
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::SetName()
-**********************************************************************=
***/
BOOL SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * =
pBase )
{
if( pBase )
@@ -145,9 +132,6 @@ BOOL SvMetaModule::SetName( const ByteString & rNam=
e, SvIdlDataBase * pBase )
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|* SvMetaModule::GetNextName()
-**********************************************************************=
***/
BOOL SvMetaModule::FillNextName( SvGlobalName * pName )
{
*pName =3D aNextName;
@@ -161,9 +145,6 @@ BOOL SvMetaModule::FillNextName( SvGlobalName * pNa=
me )
return FALSE;
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::ReadSvIdl()
-**********************************************************************=
***/
void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -187,9 +168,6 @@ void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBa=
se & rBase,
aModulePrefix.ReadSvIdl( SvHash_ModulePrefix(), rInStm );
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::WriteAttributesSvIdl()
-**********************************************************************=
***/
void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -218,9 +196,6 @@ void SvMetaModule::WriteAttributesSvIdl( SvIdlDataB=
ase & rBase,
}
}
=20
-/*********************************************************************=
****
-|* 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,
=20
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,
=20
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( SvIdlDataBas=
e & rBase,
SvTokenStream aTokStm( aFullName.GetFull() );
if( SVSTREAM_OK =3D=3D aTokStm.GetStream().GetError() =
)
{
- // Fehler aus alter Datei retten
+ // rescue error from old file
SvIdlError aOldErr =3D rBase.GetError();
- // Fehler zuruecksetzen
+ // reset error
rBase.SetError( SvIdlError() );
=20
- UINT32 nBeginPos =3D 0xFFFFFFFF; // kann mit Tell =
nicht vorkommen
+ UINT32 nBeginPos =3D 0xFFFFFFFF; // can not happen=
with Tell
while( nBeginPos !=3D aTokStm.Tell() )
{
nBeginPos =3D 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( SvIdlDataBas=
e & rBase,
{
if( xSlot->Test( rBase, rInStm ) )
{
- // Im Modul deklariert
+ // declared in module
aAttrList.Append( xSlot );
- // Global bekanntgeben
+ // announce globally
rBase.AppendAttr( xSlot );
}
}
}
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::WriteContextSvIdl()
-**********************************************************************=
***/
void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -358,12 +330,9 @@ void SvMetaModule::WriteContextSvIdl( SvIdlDataBas=
e & rBase,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::ReadSvIdl()
-**********************************************************************=
***/
BOOL SvMetaModule::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & r=
InStm )
{
- bIsModified =3D TRUE; // bisher immer wenn Compiler laueft
+ bIsModified =3D TRUE; // up to now always when compiler running
=20
UINT32 nTokPos =3D rInStm.Tell();
SvToken * pTok =3D rInStm.GetToken_Next();
@@ -387,24 +356,21 @@ BOOL SvMetaModule::ReadSvIdl( SvIdlDataBase & rBa=
se, SvTokenStream & rInStm )
{
aNextName =3D aBeginName;
=20
- rBase.Push( this ); // auf den Context Stack
+ rBase.Push( this ); // onto the context stack
=20
if( ReadNameSvIdl( rBase, rInStm ) )
{
- // Zeiger auf sich selbst setzen
+ // set pointer to itself
SetModule( rBase );
bOk =3D SvMetaName::ReadSvIdl( rBase, rInStm );
}
- rBase.GetStack().Pop(); // und runter
+ rBase.GetStack().Pop(); // remove from stack
}
if( !bOk )
rInStm.Seek( nTokPos );
return bOk;
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::WriteSvIdl()
-**********************************************************************=
***/
void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutS=
tm,
USHORT nTab )
{
@@ -417,9 +383,6 @@ void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBas=
e, SvStream & rOutStm,
SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::WriteSfx()
-**********************************************************************=
***/
void SvMetaModule::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm=
)
{
for( ULONG n =3D 0; n < aClassList.Count(); n++ )
@@ -439,9 +402,6 @@ void SvMetaModule::WriteHelpIds( SvIdlDataBase & rB=
ase, SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::WriteAttributes()
-**********************************************************************=
***/
void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab,
@@ -457,9 +417,6 @@ void SvMetaModule::WriteAttributes( SvIdlDataBase &=
rBase,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::Write()
-**********************************************************************=
***/
void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -516,7 +473,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, Sv=
Stream & rOutStm,
if( pSC )
rOutStm << " : " << pSC->GetName().GetBuffer();
=20
- // Importierte Klassen
+ // imported classes
const SvClassElementMemberList& rClassList =3D pClass-=
>GetClassList();
if ( rClassList.Count() )
{
@@ -538,7 +495,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, Sv=
Stream & rOutStm,
}
}
rOutStm << "</CLASSES>" << endl << endl;
- // kein Break!
+ // no break!
}
=20
case WRITE_C_SOURCE:
@@ -547,7 +504,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, Sv=
Stream & rOutStm,
for( ULONG n =3D 0; n < aClassList.Count(); n++ )
{
SvMetaClass * pClass =3D 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, Sv=
Stream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::WriteSrc()
-**********************************************************************=
***/
void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm=
,
Table * pTable )
{
@@ -572,9 +526,6 @@ void SvMetaModule::WriteSrc( SvIdlDataBase & rBase,=
SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaModule::WriteHxx()
-**********************************************************************=
***/
void SvMetaModule::WriteHxx( SvIdlDataBase & rBase, SvStream & rOutStm=
,
USHORT nTab )
{
@@ -585,9 +536,6 @@ void SvMetaModule::WriteHxx( SvIdlDataBase & rBase,=
SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* 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>
=20
-/******************** class SvClassElement ***************************=
****/
SV_IMPL_PERSIST1( SvClassElement, SvPersistBase );
=20
-/*********************************************************************=
****
-|* SvClassElement::SvClassElement()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvClassElement::SvClassElement()
{
};
=20
-/*********************************************************************=
****
-|* SvClassElement::Load()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvClassElement::Load( SvPersistStream & rStm )
{
BYTE nMask;
@@ -75,43 +64,27 @@ void SvClassElement::Load( SvPersistStream & rStm )=
}
}
=20
-/*********************************************************************=
****
-|* SvClassElement::Save()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvClassElement::Save( SvPersistStream & rStm )
{
- // Maske erstellen
+ // create mask
BYTE nMask =3D 0;
if( aAutomation.IsSet() ) =09=09nMask |=3D 0x1;
if( aPrefix.Len() )=09=09 =09=09nMask |=3D 0x2;
if( xClass.Is() )=09=09=09=09nMask |=3D 0x4;
=20
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aAutomation;
if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
if( nMask & 0x04 ) rStm << xClass;
}
=20
-/****************** SvMetaClass **************************************=
****/
SV_IMPL_META_FACTORY1( SvMetaClass, SvMetaType );
-/*********************************************************************=
****
-|* SvMetaClass::SvMetaClass()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaClass::SvMetaClass()
: aAutomation( TRUE, FALSE )
{
}
=20
-/*********************************************************************=
****
-|* 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;
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::Save()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::Save( SvPersistStream & rStm )
{
SvMetaType::Save( rStm );
=20
- // Maske erstellen
+ // create mask
BYTE nMask =3D 0;
if( aAttrList.Count() ) =09=09nMask |=3D 0x1;
if( aSuperClass.Is() ) =09=09nMask |=3D 0x2;
@@ -158,7 +126,7 @@ void SvMetaClass::Save( SvPersistStream & rStm )
if( xAutomationInterface.Is() ) nMask |=3D 0x8;
if( aAutomation.IsSet() )=09=09nMask |=3D 0x10;
=20
- // 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 )
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|* SvMetaClass::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -180,11 +143,6 @@ void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBa=
se & rBase,
aAutomation.ReadSvIdl( SvHash_Automation(), rInStm );
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm, USHORT nTab )
{
@@ -203,11 +161,6 @@ void SvMetaClass::WriteAttributesSvIdl( SvIdlDataB=
ase & rBase,
}
}
=20
-/*********************************************************************=
****
-|* 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.GetTo=
ken() );
rBase.WriteError( rInStm );
}
@@ -307,11 +260,6 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase =
& rBase,
rInStm.Seek( nTokPos );
}
=20
-/*********************************************************************=
****
-|* 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 =3D 0; n < aAttrList.Count(); n++ )
{
@@ -342,11 +289,6 @@ void SvMetaClass::WriteContextSvIdl
}
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rI=
nStm )
{
ULONG nTokPos =3D rInStm.Tell();
@@ -359,7 +301,7 @@ BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase,=
SvTokenStream & rInStm )
bOk =3D 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;
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::TestAttribute()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream =
& rInStm,
SvMetaAttribute & rAttr ) const
{
@@ -396,7 +333,7 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rB=
ase, SvTokenStream & rInStm,
SvMetaAttribute * pS =3D aAttrList.GetObject( n );
if( pS->GetName() =3D=3D rAttr.GetName() )
{
- // Werte muessen uebereinstimmen
+ // values have to match
if( pS->GetSlotId().GetValue() !=3D rAttr.GetSlotId().GetV=
alue() )
{
DBG_ERROR( "Gleicher Name in MetaClass : " );
@@ -416,7 +353,7 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rB=
ase, SvTokenStream & rInStm,
{
UINT32 nId1 =3D pS->GetSlotId().GetValue();
UINT32 nId2 =3D rAttr.GetSlotId().GetValue();
- if( nId1 =3D=3D nId2 && nId1 !=3D 0 /*&& nId2 !=3D 0 ist u=
eberfluessig*/ )
+ if( nId1 =3D=3D nId2 && nId1 !=3D 0 )
{
DBG_ERROR( "Gleiche Id in MetaClass : " );
DBG_ERROR( ByteString::CreateFromInt32( pS->GetSlotId(=
).GetValue() ).GetBuffer() );
@@ -440,11 +377,6 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & r=
Base, SvTokenStream & rInStm,
return TRUE;
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::WriteSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutSt=
m,
USHORT nTab )
{
@@ -456,11 +388,6 @@ void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBas=
e, SvStream & rOutStm,
rOutStm << endl;
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::Write()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute )
@@ -489,7 +416,7 @@ void SvMetaClass::Write( SvIdlDataBase & rBase, SvS=
tream & rOutStm,
WriteDescription( rOutStm );
rOutStm=09<< "</INTERFACE>" << endl << endl;
=20
- // alle Attribute schreiben
+ // write all attributes
ULONG n;
for( n =3D 0; n < aAttrList.Count(); n++ )
{
@@ -511,11 +438,6 @@ void SvMetaClass::Write( SvIdlDataBase & rBase, Sv=
Stream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::WriteSlotParamArray()
-|*
-|* Beschreibung
-**********************************************************************=
***/
USHORT SvMetaClass::WriteSlotParamArray( SvIdlDataBase & rBase,
SvSlotElementList & rSlotList,=
SvStream & rOutStm )
@@ -531,11 +453,6 @@ USHORT SvMetaClass::WriteSlotParamArray( SvIdlData=
Base & rBase,
return nCount;
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::WriteSlots()
-|*
-|* Beschreibung
-**********************************************************************=
***/
USHORT SvMetaClass::WriteSlots( const ByteString & rShellName,
USHORT nCount, SvSlotElementList & rSl=
otList,
SvIdlDataBase & rBase,
@@ -555,23 +472,18 @@ USHORT SvMetaClass::WriteSlots( const ByteString =
& rShellName,
return nSCount;
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::InsertSlots()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSu=
perList,
SvMetaClassList &rClassList,
const ByteString & rPrefix, SvIdlDataBase&=
rBase)
{
- // Wurde diese Klasse schon geschrieben ?
+ // was this class already written?
for ( size_t i =3D 0, n =3D rClassList.size(); i < n ; ++i )
if ( rClassList[ i ] =3D=3D this )
return;
=20
rClassList.push_back( this );
=20
- // alle direkten Attribute schreiben
+ // write all direct attributes
ULONG n;
for( n =3D 0; n < aAttrList.Count(); n++ )
{
@@ -587,22 +499,22 @@ void SvMetaClass::InsertSlots( SvSlotElementList&=
rList, SvULongs& rSuperList,
=20
if( nPos =3D=3D 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);
}
}
=20
- // Alle schon von SuperShells importierten Interfaces sollen nicht=
- // mehr geschrieben werden
- // Es ist also verboten, da\s Shell und SuperShell die gleiche Kla=
sse
- // 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 );
=20
- // 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 h=
ave
+ // not already been imported by the superclass.
for( n =3D 0; n < aClassList.Count(); n++ )
{
SvClassElement * pEle =3D aClassList.GetObject( n );
@@ -612,32 +524,27 @@ void SvMetaClass::InsertSlots( SvSlotElementList&=
rList, SvULongs& rSuperList,
rPre +=3D '.';
rPre +=3D pEle->GetPrefix();
=20
- // Zun"achst die direkt importierten Interfaces schreiben
+ // first of all write direct imported interfaces
pCl->InsertSlots( rList, rSuperList, rClassList, rPre, rBase )=
;
}
=20
- // Superklassen nur schreiben, wenn keine Shell und nicht in der L=
iste
+ // only write superclass if no shell and not in the list
if( !IsShell() && aSuperClass.Is() )
{
aSuperClass->InsertSlots( rList, rSuperList, rClassList, rPref=
ix, rBase );
}
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::FillClasses()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::FillClasses( SvMetaClassList & rList )
{
- // Bin ich noch nicht drin ?
+ // Am I not yet in?
for ( size_t i =3D 0, n =3D rList.size(); i < n; ++i )
if ( rList[ i ] =3D=3D this )
return;
=20
rList.push_back( this );
=20
- // Meine Imports
+ // my imports
for( ULONG n =3D 0; n < aClassList.Count(); n++ )
{
SvClassElement * pEle =3D aClassList.GetObject( n );
@@ -645,23 +552,18 @@ void SvMetaClass::FillClasses( SvMetaClassList & =
rList )
pCl->FillClasses( rList );
}
=20
- // Meine Superklasse
+ // my superclass
if( aSuperClass.Is() )
aSuperClass->FillClasses( rList );
}
=20
=20
-/*********************************************************************=
****
-|* SvMetaClass::WriteSlotStubs()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::WriteSlotStubs( const ByteString & rShellName,
SvSlotElementList & rSlotList,
ByteStringList & rList,
SvStream & rOutStm )
{
- // alle Attribute schreiben
+ // write all attributes
for( ULONG n =3D 0; n < rSlotList.Count(); n++ )
{
SvSlotElement *pEle =3D rSlotList.GetObject( n );
@@ -670,27 +572,22 @@ void SvMetaClass::WriteSlotStubs( const ByteStrin=
g & rShellName,
}
}
=20
-/*********************************************************************=
****
-|* 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;=
=20
- // 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() << ')' << e=
ndl
<< '{' << endl;
=20
@@ -707,13 +604,13 @@ void SvMetaClass::WriteSfx( SvIdlDataBase & rBase=
, SvStream & rOutStm )
=20
ULONG nSlotCount =3D aSlotList.Count();
=20
- // alle Attribute schreiben
+ // write all attributes
USHORT nArgCount =3D WriteSlotParamArray( rBase, aSlotList, rOutSt=
m );
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 )
=20
rOutStm << endl;
=20
- // Slotmap schreiben
+ // write slotmap
rOutStm << "SFX_SLOTMAP_ARG(" << GetName().GetBuffer() << ')' << e=
ndl
<< '{' << endl;
=20
- // 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 & rBa=
se, SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaShell::WriteSrc()
-**********************************************************************=
***/
void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,=
Table * pTable )
{
@@ -782,11 +676,6 @@ void SvMetaClass::WriteSrc( SvIdlDataBase & rBase,=
SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::WriteHxx()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, USHOR=
T )
{
ByteString aSuperName( "SvDispatch" );
@@ -812,11 +701,6 @@ void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStr=
eam & rOutStm, USHORT )
<< "};" << endl;
}
=20
-/*********************************************************************=
****
-|* SvMetaClass::WriteCxx()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaClass::WriteCxx( SvIdlDataBase &, SvStream & rOutStm, USHOR=
T )
{
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>
=20
-/****************** SvMetaSlot ***************************************=
**/
SV_IMPL_META_FACTORY1( SvMetaSlot, SvMetaAttribute );
=20
SvMetaObject *SvMetaSlot::MakeClone() const
@@ -44,12 +43,6 @@ SvMetaObject *SvMetaSlot::MakeClone() const
return new SvMetaSlot( *this );
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::SvMetaSlot()
-|*
-|*=09 Beschreibung=09=09Zweites FALSE bei den SvBOOL-Objekten bedeute=
t,
-|*=09=09=09=09=09=09IsSet() liefert FALSE (Defaultinitialisierung).
-**********************************************************************=
***/
SvMetaSlot::SvMetaSlot()
: aCachable( TRUE, FALSE )
, aSynchron( TRUE, FALSE )
@@ -73,17 +66,6 @@ SvMetaSlot::SvMetaSlot( SvMetaType * pType )
{
}
=20
-/*
-#define TEST_READ=09=09=09=09=09=09=09=09=09=09=09=09\
-{=09=09=09=09=09=09=09=09=09=09=09=09=09=09=09=09\
- UINT32=09nPos;=09=09=09=09=09=09=09=09=09=09=09=09\
- rStm >> nPos;=09=09=09=09=09=09=09=09=09=09=09=09\
- DBG_ASSERT( nPos +4 =3D=3D rStm.Tell(), "stream pos error" ); \
-}
-
-#define TEST_WRITE=09=09=09=09=09=09=09=09=09=09=09=09\
- rStm << (UINT32)rStm.Tell();
-*/
#define TEST_READ
#define TEST_WRITE
=20
@@ -188,7 +170,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
{
SvMetaAttribute::Save( rStm );
=20
- // Maske erstellen
+ // create mask
USHORT nMask =3D 0;
if( aMethod.Is() )=09=09=09nMask |=3D 0x0001;
if( aGroupId.Len() )=09=09nMask |=3D 0x0002;
@@ -207,7 +189,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
if( aSynchron.IsSet() ) =09nMask |=3D 0x4000;
if( aAsynchron.IsSet() )=09nMask |=3D 0x8000;
=20
- // 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;
=20
- // naechste Fuhre schreiben
- // Maske erstellen
+ // write next bunch
+ // create mask
nMask =3D 0;
if( aRecordPerItem.IsSet() ) nMask |=3D 0x0001;
if( aRecordManual.IsSet() ) nMask |=3D 0x0002;
@@ -262,7 +244,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
if( aRecordAbsolute.IsSet() ) nMask |=3D 0x4000;
if( aImageRotation.IsSet() ) nMask |=3D 0x8000;
=20
- // 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;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::IsVariable()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaSlot::IsVariable() const
{
return SvMetaAttribute::IsVariable();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::IsMethod()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaSlot::IsMethod() const
{
BOOL b =3D SvMetaAttribute::IsMethod();
@@ -329,11 +301,6 @@ BOOL SvMetaSlot::IsMethod() const
return b;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::HasMethods()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
ByteString SvMetaSlot::GetMangleName( BOOL bVariable ) const
{
if( !bVariable )
@@ -346,12 +313,12 @@ ByteString SvMetaSlot::GetMangleName( BOOL bVaria=
ble ) const
}
=20
/*********************************************************************=
****
-|*=09 Referenz
+|*=09 reference
|*
-|*=09 Beschreibung=09=09Zweites FALSE bei den SvBOOL-Objekten bedeute=
t,
-|*=09=09=09=09=09=09IsSet() liefert FALSE (Defaultinitialisierung).
+|*=09 description=09=09Second FALSE in the SvBOOL-Objects means
+|*=09=09=09=09=09=09IsSet() 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();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::FillSbxObject()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
-/*
-void SvMetaSlot::FillSbxObject( SvIdlDataBase & rBase, SbxObject * pOb=
j,
- BOOL bVariable )
-{
- // keine Attribut fuer Automation
- if( !GetAutomation() || !GetExport() )
- return;
-
- if( !bVariable )
- {
- SvMetaAttributeRef xM =3D GetMethod();
- if( xM.Is() )
- {
- SvMetaType *=09pType =3D xM->GetType();
- SvMetaType *=09pRetBaseType =3D pType->GetReturnType()->Ge=
tBaseType();
- ByteString=09=09=09aName =3D xM->GetName();
-
- SbxMethodRef xMeth =3D 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
-/*********************************************************************=
****
-|*=09 SvMetaSlot::ReadAttributesSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -717,11 +631,6 @@ void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBas=
e & rBase,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::WriteAttributesSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -800,7 +709,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBas=
e & rBase,
if( aVolatile )
aOut +=3D aVolatile.GetSvIdlString( SvHash_Volatile() );
else if( !aCachable )
- // wegen Default =3D=3D TRUE, nur wenn kein anderer gesetzt
+ // because of Default =3D=3D TRUE, only when no other is set
aOut +=3D aCachable.GetSvIdlString( SvHash_Cachable() );
else
aDel.Erase();
@@ -820,7 +729,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBas=
e & rBase,
if( aAsynchron )
( aOut +=3D aDel ) +=3D aAsynchron.GetSvIdlString( SvHash_Asyn=
chron() );
else if( !aSynchron )
- // wegen Default =3D=3D TRUE, nur wenn kein anderer gesetzt
+ // because of Default =3D=3D TRUE, only when no other is set
( aOut +=3D aDel ) +=3D aSynchron.GetSvIdlString( SvHash_Synch=
ron() );
else
aDel1 =3D aDel;
@@ -831,7 +740,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBas=
e & rBase,
else if( aNoRecord )
( aOut +=3D aDel1 ) +=3D aNoRecord.GetSvIdlString( SvHash_NoRe=
cord() );
else if( !aRecordPerSet )
- // wegen Default =3D=3D TRUE, nur wenn kein anderer gesetzt
+ // because of Default =3D=3D TRUE, only when no other is set
( aOut +=3D aDel1 ) +=3D aRecordPerSet.GetSvIdlString( SvHash_=
RecordPerSet() );
else if( aRecordPerItem )
( aOut +=3D aDel1 ) +=3D aRecordPerItem.GetSvIdlString( SvHash=
_RecordPerItem() );
@@ -898,11 +807,6 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBa=
se & rBase,
}
=20
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::Test()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )=
{
BOOL bOk =3D SvMetaAttribute::Test( rBase, rInStm );
@@ -922,11 +826,6 @@ BOOL SvMetaSlot::Test( SvIdlDataBase & rBase, SvTo=
kenStream & rInStm )
return bOk;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::ReadSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rIn=
Stm )
{
UINT32=09nTokPos =09=3D rInStm.Tell();
@@ -935,7 +834,7 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, =
SvTokenStream & rInStm )
SvMetaAttribute * pAttr =3D rBase.ReadKnownAttr( rInStm, GetType()=
);
if( pAttr )
{
- // F"ur Testzwecke: Referenz bei Kurz-Syntax
+ // c
SvMetaSlot * pKnownSlot =3D PTR_CAST( SvMetaSlot, pAttr );
if( pKnownSlot )
{
@@ -960,13 +859,13 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase=
, SvTokenStream & rInStm )
SvMetaAttribute *pAttr2 =3D rBase.SearchKnownAttr( GetSlotId()=
);
if( pAttr2 )
{
- // F"ur Testzwecke: Referenz bei kompletter Definition
+ // for testing purposes: reference in case of complete def=
inition
SvMetaSlot * pKnownSlot =3D PTR_CAST( SvMetaSlot, pAttr2 )=
;
if( pKnownSlot )
{
SetRef( pKnownSlot );
=20
- // Namen d"urfen abweichen, da mit angegeben
+ // names may differ, because explicitly given
if ( pKnownSlot->GetName() !=3D GetName() )
{
DBG_ERROR("Illegal definition!");
@@ -994,22 +893,12 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase=
, SvTokenStream & rInStm )
return bOk;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::WriteSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaSlot::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm=
,
USHORT nTab )
{
SvMetaAttribute::WriteSvIdl( rBase, rOutStm, nTab );
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::Write()
-|*
-|*=09 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 =3D (USHORT) GetSlotId().GetValue();
USHORT nListCount =3D (USHORT) rList.Count();
USHORT nPos;
@@ -1099,18 +988,18 @@ void SvMetaSlot::Insert( SvSlotElementList& rLis=
t, const ByteString & rPrefix,
=20
rList.Insert( new SvSlotElement( this, rPrefix ), nPos );
=20
- // EnumSlots plattklopfen
+ // iron out EnumSlots
SvMetaTypeEnum * pEnum =3D NULL;
SvMetaType * pBType =3D GetType()->GetBaseType();
pEnum =3D PTR_CAST( SvMetaTypeEnum, pBType );
if( GetPseudoSlots() && pEnum && pEnum->Count() )
{
- // Den MasterSlot clonen
+ // clone the MasterSlot
SvMetaSlotRef xEnumSlot;
SvMetaSlot *pFirstEnumSlot =3D NULL;
for( ULONG n =3D 0; n < pEnum->Count(); n++ )
{
- // Die SlotId erzeugen
+ // create SlotId
SvMetaEnumValue *enumValue =3D pEnum->GetObject(n);
ByteString aValName =3D enumValue->GetName();
ByteString aSId( GetSlotId() );
@@ -1145,24 +1034,24 @@ void SvMetaSlot::Insert( SvSlotElementList& rLi=
st, const ByteString & rPrefix,
}
}
=20
- // Die Slaves sind kein Master !
+ // The slaves are no master!
xEnumSlot->aPseudoSlots =3D FALSE;
xEnumSlot->SetEnumValue(enumValue);
=20
if ( !pFirstEnumSlot || xEnumSlot->GetSlotId().GetValue() =
< pFirstEnumSlot->GetSlotId().GetValue() )
pFirstEnumSlot =3D xEnumSlot;
=20
- // Den erzeugten Slave ebenfalls einf"ugen
+ // insert the created slave as well
xEnumSlot->Insert( rList, rPrefix, rBase);
=20
- // Die EnumSlots mit dem Master verketten
+ // concatenate the EnumSlots with the master
xEnumSlot->pLinkedSlot =3D this;
}
=20
- // Master zeigt auf den ersten Slave
+ // master points to the first slave
pLinkedSlot =3D pFirstEnumSlot;
=20
- // Slaves untereinander verketten
+ // concatenate slaves among themselves
rList.Seek((ULONG)0);
xEnumSlot =3D pFirstEnumSlot;
SvSlotElement *pEle;
@@ -1181,11 +1070,6 @@ void SvMetaSlot::Insert( SvSlotElementList& rLis=
t, const ByteString & rPrefix,
}
=20
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::WriteSlotMap()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
static ByteString MakeSlotName( SvStringHashEntry * pEntry )
{
ByteString aName( "SFX_SLOT_" );
@@ -1258,7 +1142,6 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
if ( !GetExport() && !GetHidden() )
return;
=20
-//=09BOOL bIsEnumSlot =3D 0 !=3D rValueName.Len();
BOOL bIsEnumSlot =3D 0 !=3D pEnumValue;
=20
rOutStm << "// Slot Nr. " << ByteString::CreateFromInt32(nListPos)=
.GetBuffer() << " : ";
@@ -1307,8 +1190,8 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, 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 =3D rSlotList.Next();
pNextSlot =3D pEle ? &pEle->xSlot : NULL;
while ( pNextSlot )
@@ -1322,9 +1205,8 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
=20
if ( !pNextSlot )
{
- // Es gibt nach mir keinen Slot mehr, der die gleiche Exec=
Methode
- // hat. Also suche ich den ersten Slot, der diese hatte (d=
as
- // 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 =3D rSlotList.First();
pNextSlot =3D pEle ? &pEle->xSlot : NULL;
while ( pNextSlot !=3D this )
@@ -1355,7 +1237,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
=20
WriteTab( rOutStm, 4 );
=20
- // ExecMethod schreiben, wenn nicht angegeben, standard Namen
+ // write ExecMethod, with standard name if not specified
if( GetExecMethod().Len() && GetExecMethod() !=3D "NoExec")
rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ',=
'
<< GetExecMethod().GetBuffer() << ')';
@@ -1363,7 +1245,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
rOutStm << "SFX_STUB_PTR_EXEC_NONE";
rOutStm << ',';
=20
- // StateMethod schreiben, wenn nicht angegeben, standard Namen=
+ // write StateMethod, with standard name if not specified
if( GetStateMethod().Len() && GetStateMethod() !=3D "NoState")=
rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ',=
'
<< GetStateMethod().GetBuffer() << ')';
@@ -1373,7 +1255,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
rOutStm << ',' << endl;
WriteTab( rOutStm, 4 );
=20
- // Flags schreiben
+ // write flags
if( GetHasCoreId() )
rOutStm << MakeSlotName( SvHash_HasCoreId() ).GetBuffer() << '=
|';
if( GetCachable() )
@@ -1427,7 +1309,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
else
rOutStm << GetDisableFlags().GetBuffer();
=20
- // Attribut Typ schreiben
+ // write attribute type
if( !bIsEnumSlot )
{
rOutStm << ',' << endl;
@@ -1477,7 +1359,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
else
rOutStm << '0';
=20
- // Name f"urs Recording
+ // name for recording
if ( GetExport() )
{
rOutStm << ",\"";
@@ -1492,7 +1374,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rS=
hellName, USHORT nCount,
else
rOutStm << ", 0, ";
=20
- // 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';
}
=20
-// if ( GetUnoName().Len() )
{
rOutStm << ",\"";
rOutStm << GetMangleName( FALSE ).GetBuffer();
- //rOutStm << GetUnoName().GetBuffer();
rOutStm << "\"";
}
-// else
-// rOutStm << ", 0";
=20
rOutStm << " )," << endl;
}
@@ -1544,9 +1422,9 @@ USHORT SvMetaSlot::WriteSlotParamArray( SvIdlData=
Base & 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 =3D GetSlotId();
=20
USHORT nSCount =3D 0;
@@ -1582,9 +1460,6 @@ USHORT SvMetaSlot::WriteSlotMap( const ByteString=
& rShellName, USHORT nCount,
return nSCount;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaSlot::WriteSrc()
-**********************************************************************=
***/
void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
Table * pTable )
{
@@ -1635,7 +1510,7 @@ void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase,=
SvStream & rOutStm,
bIdOk =3D TRUE;
}
=20
- // 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 & rBa=
se, SvStream & rOutStm,
bIdOk =3D TRUE;
}
=20
- // 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.cx=
x
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>
=20
-/****************** 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=
)
{
}
=20
-/*********************************************************************=
****
-|* 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 );
=20
- // Maske erstellen
+ // create mask
BYTE nMask =3D 0;
if( aType.Is() ) =09=09nMask |=3D 0x1;
if( aSlotId.IsSet() ) =09=09nMask |=3D 0x2;
@@ -109,7 +96,7 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )=
if( aReadOnlyDoc.IsSet() ) nMask |=3D 0x40;
if( aHidden.IsSet() ) =09=09nMask |=3D 0x80;
=20
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x1 )=09rStm << aType;
if( nMask & 0x2 )=09rStm << aSlotId;
@@ -121,59 +108,33 @@ void SvMetaAttribute::Save( SvPersistStream & rSt=
m )
if( nMask & 0x80 ) rStm << aHidden;
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::GetType()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaType * SvMetaAttribute::GetType() const
{
if( aType.Is() || !GetRef() ) return aType;
return ((SvMetaAttribute *)GetRef())->GetType();
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::GetSlotId()
-|*
-|* Beschreibung
-**********************************************************************=
***/
const SvNumberIdentifier & SvMetaAttribute::GetSlotId() const
{
if( aSlotId.IsSet() || !GetRef() ) return aSlotId;
return ((SvMetaAttribute *)GetRef())->GetSlotId();
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::GetReadonly()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaAttribute::GetReadonly() const
{
if( aReadonly.IsSet() || !GetRef() ) return aReadonly;
return ((SvMetaAttribute *)GetRef())->GetReadonly();
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::GetExport()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaAttribute::GetExport() const
{
if( aExport.IsSet() || !GetRef() ) return aExport;
return ((SvMetaAttribute *)GetRef())->GetExport();
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::GetHidden()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaAttribute::GetHidden() const
{
- // Wenn Export gesetzt wurde, aber Hidden nicht, gilt der Default
- // aHidden =3D !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();
}
=20
-/*********************************************************************=
****
-|* 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();
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::IsMethod()
-|* SvMetaAttribute::IsVariable()
-|*=09 SvMetaAttribute::GetMangleName()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaAttribute::IsMethod() const
{
SvMetaType * pType =3D GetType();
@@ -242,11 +191,6 @@ ByteString SvMetaAttribute::GetMangleName( BOOL ) =
const
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|* SvMetaAttribute::Test()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -260,17 +204,12 @@ BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase=
,
return bOk;
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos =3D rInStm.Tell();
if( !GetType() )
- // Es wurde kein Typ im ctor mitgegeben
+ // no type in ctor passed on
aType =3D rBase.ReadKnownType( rInStm );
BOOL bOk =3D FALSE;
if( GetType() )
@@ -298,11 +237,6 @@ BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & r=
Base,
return bOk;
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::WriteSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaAttribute::WriteSvIdl
(
SvIdlDataBase & rBase,
@@ -323,11 +257,6 @@ void SvMetaAttribute::WriteSvIdl
TestAndSeekSpaceOnly( rOutStm, nPos );
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -342,18 +271,13 @@ void SvMetaAttribute::ReadAttributesSvIdl( SvIdlD=
ataBase & rBase,
{
if( GetType()->GetType() =3D=3D TYPE_METHOD )
{
- // Fehler setzen
+ // set error
rBase.SetError( "Readonly in function attribute", rInStm.G=
etToken() );
rBase.WriteError( rInStm );
}
}
}
=20
-/*********************************************************************=
****
-|* SvMetaAttribute::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaAttribute::WriteAttributesSvIdl
(
SvIdlDataBase & rBase,
@@ -363,7 +287,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
{
SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab );
=20
- //aSlotId.WriteSvIdl( SvHash_SlotId(), rOutStm, nTab );
if( !aExport || !aAutomation || aReadonly )
{
WriteTab( rOutStm, nTab );
@@ -407,11 +330,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
}
}
=20
-/*********************************************************************=
****
-|* 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 )
{
-//=09=09=09=09=09if ( nT =3D=3D WRITE_DOCU )
rOutStm << ',';
-//=09=09=09=09=09else
-//=09=09=09=09=09=09rOutStm << ',' << endl;
}
}
}
@@ -470,11 +385,6 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & =
rBase,
}
}
=20
-/*********************************************************************=
****
-|* SvMetaSlot::WriteSlotId()
-|*
-|* Beschreibung
-**********************************************************************=
***/
ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, BOOL bVar=
) const
{
const SvNumberIdentifier & rId =3D GetSlotId();
@@ -493,11 +403,6 @@ ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBas=
e & rBase, BOOL bVar ) const
return n;
}
=20
-/*********************************************************************=
****
-|* SvMetaSlot::WriteAttributes()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream=
& rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA =
)
@@ -532,11 +437,6 @@ void SvMetaAttribute::WriteAttributes( SvIdlDataBa=
se & rBase, SvStream & rOutStm
}
}
=20
-/*********************************************************************=
****
-|* 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 =3D GetType();
SvMetaType * pBaseType =3D pType->GetBaseType();
=20
- // Bei Set ist der Return immer void
+ // for Set the return is always void
BOOL bVoid =3D bSet;
if( pBaseType->GetType() =3D=3D TYPE_METHOD )
bVoid =3D pBaseType->GetReturnType()->GetBaseType()->GetName()=
=3D=3D "void";
=20
- // Methoden/Funktions-Body ausgeben
+ // emit methods/functions body
rOutStm << '{' << endl;
WriteTab( rOutStm, 1 );
=20
@@ -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;
}
=20
-/*********************************************************************=
****
-|* 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( SvIdlData=
Base & rBase,
if ( GetSlotId().Len() )
rBase.aStructSlotId =3D GetSlotId();
=20
- // Offizielle Hack-Schnittstelle von MM: spezielle Schalter werden=
"uber
- // die WriteAttribute "ubergeben
+ // offial hack interface by MM: special controls get passed with t=
he WriteAttribute
if ( GetReadonly() )
nA |=3D WA_READONLY;
=20
@@ -647,16 +540,11 @@ void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDa=
taBase & rBase,
rBase.aStructSlotId =3D slotId;
}
=20
-/*********************************************************************=
****
-|* 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 =3D=3D WRITE_DOCU )
{
if ( GetHidden() )
@@ -705,15 +593,12 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBas=
e, SvStream & rOutStm,
{
if( !bVariable && IsMethod() )
{
- ByteString name; // (rBase.GetActModulePrefix());
+ ByteString name;
name +=3D rBase.aIFaceName;
name +=3D GetName();
const char * pName =3D name.GetBuffer();
- // Beispiel
- // void SetPosSize( C_Object *, C_Rectangle * );
WriteTab( rOutStm, nTab );
pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
-//=09=09=09rOutStm << " SYSCALL";
rOutStm << ' ' << pName;
pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
if( nT =3D=3D WRITE_C_HEADER )
@@ -725,21 +610,19 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBas=
e, SvStream & rOutStm,
{
if( nBType =3D=3D TYPE_STRUCT )
{
- // Zur Hilfe den Namen des Properties als Kommentar au=
sgeben
+ // for assistance emit the name of the property as aco=
mment
rOutStm << "/* " << GetName().GetBuffer() << " */" << =
endl;
=20
WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
}
else
{
- // Beispiel
- // void SetValue( C_Object *, USHORT n );
ByteString name =3D GetName();
=20
BOOL bReadonly =3D 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 );
}
=20
- // 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;=09// readonly
=20
- // Returntype
+ // return type
SvMetaType* pType2 =3D GetType();
SvMetaType* pBaseType2 =3D pType2->GetBaseType();
rOutStm << pBaseType2->GetReturnType()->GetBaseType()->Get=
BasicName().GetBuffer() << endl;
@@ -785,20 +668,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBas=
e, SvStream & rOutStm,
DBG_ASSERT( pBaseType2->GetReturnType()->GetBaseType()->Ge=
tBasicName().Len(),
"Leerer BasicName" );
=20
- // Syntax
+ // syntax
rOutStm << GetName().GetBuffer();
pType2->WriteMethodArgs( rBase, rOutStm, nTab, nT );
=20
- // C-Returntype
+ // C return type
pBaseType2->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HE=
ADER );
rOutStm << endl;
=20
- // 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;
=20
- // Description
+ // description
WriteDescription( rOutStm );
rOutStm << "</METHOD>" << endl << endl;
}
@@ -818,20 +701,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBas=
e, SvStream & rOutStm,
else
rOutStm << endl;
=20
- // Bei properties Type anstelle des return value
+ // for properties type instead of the return value
rOutStm << pBaseType->GetBasicName().GetBuffer() << en=
dl;
=20
DBG_ASSERT( pBaseType->GetBasicName().Len(),
"Leerer BasicName" );
=20
- // Bei properties keine Syntax
+ // for properties no syntax
rOutStm << endl;
=20
- // C-Returntype
+ // C return type
pBaseType->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C=
_HEADER );
rOutStm << endl;
=20
- // Description
+ // description
WriteDescription( rOutStm );
rOutStm=09<< "</PROPERTY>" << endl << endl;
}
@@ -839,11 +722,6 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase=
, SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaAttribute::MakeSfx()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
ULONG SvMetaAttribute::MakeSfx( ByteString * pAttrArray )
{
SvMetaType * pType =3D GetType();
@@ -867,11 +745,6 @@ void SvMetaAttribute::Insert (SvSlotElementList&, =
const ByteString &, SvIdlDataB
{
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaAttribute::WriteSrc()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaAttribute::WriteSrc( SvIdlDataBase &, SvStream &, Table * )=
{
}
@@ -882,14 +755,7 @@ void SvMetaAttribute::WriteHelpId( SvIdlDataBase &=
, SvStream &, Table * )
=20
#endif // IDL_COMPILER
=20
-/****************** SvMetaType *************************************/
-/*********************************************************************=
***/
SV_IMPL_META_FACTORY1( SvMetaType, SvMetaExtern );
-/*********************************************************************=
****
-|*=09 SvMetaType::SvMetaType()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
#define CTOR=09=09=09=09=09=09=09\
: aCall0( CALL_VALUE, FALSE ) \
, aCall1( CALL_VALUE, FALSE ) \
@@ -923,7 +789,6 @@ SvMetaType::SvMetaType( const ByteString & rName,
const ByteString & rBasicPostfix )
CTOR
{
-// aSbxDataType =3D (int)nT;
SetName( rName );
aSbxName=09=3D rSbxName;
aOdlName=09=3D rOdlName;
@@ -966,7 +831,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
{
SvMetaExtern::Save( rStm );
=20
- // Maske erstellen
+ // create mask
USHORT nMask =3D 0;
if( aIn.IsSet() )=09=09=09=09nMask |=3D 0x0001;
if( aOut.IsSet() )=09=09=09=09nMask |=3D 0x0002;
@@ -985,7 +850,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
if( aBasicName.IsSet() ) =09=09nMask |=3D 0x4000;
if( aBasicPostfix.IsSet() ) =09nMask |=3D 0x8000;
=20
- // 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;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetAttrList()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
SvMetaAttributeMemberList &=09SvMetaType::GetAttrList() const
{
if( !pAttrList )
@@ -1015,18 +875,12 @@ SvMetaAttributeMemberList &=09SvMetaType::GetAtt=
rList() const
return *pAttrList;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::SetType()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::SetType( int nT )
{
nType =3D nT;
if( nType =3D=3D TYPE_ENUM )
{
aOdlName =3D "short";
-// aSbxDataType =3D SbxINTEGER;
}
else if( nType =3D=3D TYPE_CLASS )
{
@@ -1035,11 +889,6 @@ void SvMetaType::SetType( int nT )
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetBaseType()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
SvMetaType * SvMetaType::GetBaseType() const
{
if( GetRef() && GetType() =3D=3D TYPE_BASE )
@@ -1047,11 +896,6 @@ SvMetaType * SvMetaType::GetBaseType() const
return (SvMetaType *)this;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetReturnType()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
SvMetaType * SvMetaType::GetReturnType() const
{
DBG_ASSERT( GetType() =3D=3D TYPE_METHOD, "no method" );
@@ -1059,25 +903,6 @@ SvMetaType * SvMetaType::GetReturnType() const
return (SvMetaType *)GetRef();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetSbxDataType()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
-/*
-SbxDataType SvMetaType::GetSbxDataType() const
-{
- if( aSbxDataType.IsSet() || !GetRef() )
- return (SbxDataType)(int)aSbxDataType;
- else
- return ((SvMetaType *)GetRef())->GetSbxDataType();
-}
-*/
-/*********************************************************************=
****
-|*=09 SvMetaType::GetBasicName()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
const ByteString& SvMetaType::GetBasicName() const
{
if( aBasicName.IsSet() || !GetRef() )
@@ -1086,17 +911,12 @@ const ByteString& SvMetaType::GetBasicName() con=
st
return ((SvMetaType*)GetRef())->GetBasicName();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetBasicPostfix()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
ByteString SvMetaType::GetBasicPostfix() const
{
=20
ByteString aRet;
=20
- // MBN und Co wollen immer "As xxx"
+ // MBN and Co always want "As xxx"
{
=20
aRet =3D " As ";
@@ -1106,11 +926,6 @@ ByteString SvMetaType::GetBasicPostfix() const
return aRet;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetIn()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaType::GetIn() const
{
if( aIn.IsSet() || !GetRef() )
@@ -1119,11 +934,6 @@ BOOL SvMetaType::GetIn() const
return ((SvMetaType *)GetRef())->GetIn();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetOut()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaType::GetOut() const
{
if( aOut.IsSet() || !GetRef() )
@@ -1132,11 +942,6 @@ BOOL SvMetaType::GetOut() const
return ((SvMetaType *)GetRef())->GetOut();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::SetCall0()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::SetCall0( int e )
{
aCall0 =3D (int)e;
@@ -1153,11 +958,6 @@ void SvMetaType::SetCall0( int e )
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetCall0()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
int SvMetaType::GetCall0() const
{
if( aCall0.IsSet() || !GetRef() )
@@ -1166,11 +966,6 @@ int SvMetaType::GetCall0() const
return ((SvMetaType *)GetRef())->GetCall0();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::SetCall1()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::SetCall1( int e )
{
aCall1 =3D (int)e;
@@ -1187,11 +982,6 @@ void SvMetaType::SetCall1( int e )
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetCall1()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
int SvMetaType::GetCall1() const
{
if( aCall1.IsSet() || !GetRef() )
@@ -1200,11 +990,6 @@ int SvMetaType::GetCall1() const
return ((SvMetaType *)GetRef())->GetCall1();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetSvName()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
const ByteString & SvMetaType::GetSvName() const
{
if( aSvName.IsSet() || !GetRef() )
@@ -1213,11 +998,6 @@ const ByteString & SvMetaType::GetSvName() const
return ((SvMetaType *)GetRef())->GetSvName();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetSbxName()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
const ByteString & SvMetaType::GetSbxName() const
{
if( aSbxName.IsSet() || !GetRef() )
@@ -1226,11 +1006,6 @@ const ByteString & SvMetaType::GetSbxName() cons=
t
return ((SvMetaType *)GetRef())->GetSbxName();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetOdlName()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
const ByteString & SvMetaType::GetOdlName() const
{
if( aOdlName.IsSet() || !GetRef() )
@@ -1239,11 +1014,6 @@ const ByteString & SvMetaType::GetOdlName() cons=
t
return ((SvMetaType *)GetRef())->GetOdlName();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetCName()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
const ByteString & SvMetaType::GetCName() const
{
if( aCName.IsSet() || !GetRef() )
@@ -1252,11 +1022,6 @@ const ByteString & SvMetaType::GetCName() const
return ((SvMetaType *)GetRef())->GetCName();
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::SetName()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pB=
ase )
{
aSvName =09=3D rName;
@@ -1268,11 +1033,6 @@ BOOL SvMetaType::SetName( const ByteString & rNa=
me, SvIdlDataBase * pBase )
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|*=09 SvMetaType::GetString()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
ByteString SvMetaType::GetCString() const
{
ByteString out( GetSvName() );
@@ -1287,11 +1047,6 @@ ByteString SvMetaType::GetCString() const
return out;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::ReadHeaderSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1336,12 +1091,8 @@ BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase =
& rBase,
SetRef( pType );
if( ReadNameSvIdl( rBase, rInStm ) )
{
- /* =09// um aufwaertskompatibel zu bleiben
- aOdlName =3D 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;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::ReadSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1385,11 +1131,6 @@ BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBas=
e,
return FALSE;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteSvIdl()
-|*
-|*=09 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;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteContext()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutS=
tm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -1434,17 +1170,12 @@ void SvMetaType::WriteContext( SvIdlDataBase & =
rBase, SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::Write()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
{
if( nT =3D=3D WRITE_C_HEADER && nType !=3D TYPE_ENUM )
- // nur enum schreiben
+ // write only enum
return;
=20
ByteString name =3D GetName();
@@ -1519,11 +1250,6 @@ void SvMetaType::Write( SvIdlDataBase & rBase, S=
vStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::ReadNamesSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1532,11 +1258,6 @@ BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase &=
rBase,
return bOk;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteHeaderSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -1597,11 +1318,6 @@ void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase=
& rBase,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::ReadAttributesSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1611,11 +1327,6 @@ void SvMetaType::ReadAttributesSvIdl( SvIdlDataB=
ase & rBase,
aOdlName.ReadSvIdl( SvHash_OdlName(), rInStm );
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteAttributesSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -1647,11 +1358,6 @@ void SvMetaType::WriteAttributesSvIdl( SvIdlData=
Base & rBase,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::ReadContextSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1663,11 +1369,6 @@ void SvMetaType::ReadContextSvIdl( SvIdlDataBase=
& rBase,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteContextSvIdl()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteContextSvIdl
(
SvIdlDataBase & rBase,
@@ -1691,11 +1392,6 @@ void SvMetaType::WriteContextSvIdl
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteAttributes()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rO=
utStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -1703,11 +1399,6 @@ void SvMetaType::WriteAttributes( SvIdlDataBase =
& rBase, SvStream & rOutStm,
SvMetaExtern::WriteAttributes( rBase, rOutStm, nTab, nT, nA );
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::MakeSfx()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
ULONG SvMetaType::MakeSfx( ByteString * pAttrArray )
{
ULONG nC =3D 0;
@@ -1715,7 +1406,7 @@ ULONG SvMetaType::MakeSfx( ByteString * pAttrArra=
y )
if( GetBaseType()->GetType() =3D=3D TYPE_STRUCT )
{
ULONG nAttrCount =3D GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n =3D 0; n < nAttrCount; n++ )
{
nC +=3D pAttrList->GetObject( n )->MakeSfx( pAttrArray );
@@ -1737,14 +1428,13 @@ void SvMetaType::WriteSfxItem(
ByteString=09aTypeName =3D "SfxType";
ByteString aAttrArray;
ULONG=09nAttrCount =3D MakeSfx( &aAttrArray );
- //ULONG=09nAttrCount =3D GetAttrCount();
ByteString aAttrCount( ByteString::CreateFromInt32( nAttrCount ) =
);
aTypeName +=3D aAttrCount;
=20
rOutStm << "extern " << aTypeName.GetBuffer()
<< aVarName.GetBuffer() << ';' << endl;
=20
- // Den Implementationsteil schreiben
+ // write the implementation part
rOutStm << "#ifdef SFX_TYPEMAP" << endl
<< aTypeName.GetBuffer() << aVarName.GetBuffer()
<< " =3D " << 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;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteSfx()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )=
{
if( IsItem() )
@@ -1778,18 +1463,12 @@ void SvMetaType::WriteSfx( SvIdlDataBase & rBas=
e, SvStream & rOutStm )
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::ReadMethodArgs()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
BOOL SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos =3D 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;
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteMethodArgs()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteMethodArgs
(
SvIdlDataBase & rBase,
@@ -1904,11 +1578,6 @@ void SvMetaType::WriteMethodArgs
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteTypePrefix()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rO=
utStm,
USHORT nTab, WriteType nT )
{
@@ -2021,11 +1690,6 @@ void SvMetaType::WriteTypePrefix( SvIdlDataBase =
& rBase, SvStream & rOutStm,
}
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::WriteTheType()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutS=
tm,
USHORT nTab, WriteType nT )
{
@@ -2034,11 +1698,6 @@ void SvMetaType::WriteTheType( SvIdlDataBase & r=
Base, SvStream & rOutStm,
WriteMethodArgs( rBase, rOutStm, nTab +2, nT );
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaType::GetParserString()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
ByteString SvMetaType::GetParserString() const
{
SvMetaType * pBT =3D GetBaseType();
@@ -2051,7 +1710,7 @@ ByteString SvMetaType::GetParserString() const
if( TYPE_METHOD =3D=3D type || TYPE_STRUCT =3D=3D type )
{
ULONG nAttrCount =3D GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n =3D 0; n < nAttrCount; n++ )
{
SvMetaAttribute * pT =3D pAttrList->GetObject( n );
@@ -2063,11 +1722,6 @@ ByteString SvMetaType::GetParserString() const
return aPStr;
}
=20
-/*********************************************************************=
****
-|* 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 =3D=3D type || TYPE_STRUCT =3D=3D type )
{
ULONG nAttrCount =3D GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n =3D 0; n < nAttrCount; n++ )
{
SvMetaAttribute * pA =3D pAttrList->GetObject( n );
- // Fuer Methoden ist rChief immer ""
- ByteString aStr =3D /*rChief;
- if( aStr.Len() )
- aStr +=3D "->";
- aStr +=3D */pA->GetName();
+ ByteString aStr =3D pA->GetName();
pA->GetType()->WriteParamNames( rBase, rOutStm, aStr )=
;
if( n +1 < nAttrCount )
rOutStm << ", ";
@@ -2104,16 +1754,7 @@ void SvMetaType::WriteParamNames( SvIdlDataBase =
& rBase,
=20
#endif // IDL_COMPILER
=20
-/*********************************************************************=
***/
-/*********************************************************************=
***/
SV_IMPL_META_FACTORY1( SvMetaTypeString, SvMetaType );
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypeString::SvMetaTypeString()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
SvMetaTypeString::SvMetaTypeString()
: SvMetaType( "String", "SbxSTRING", "BSTR", 's', "char *", "Strin=
g", "$" )
{
@@ -2129,16 +1770,7 @@ void SvMetaTypeString::Save( SvPersistStream & r=
Stm )
SvMetaType::Save( rStm );
}
=20
-/*********************************************************************=
***/
-/*********************************************************************=
***/
SV_IMPL_META_FACTORY1( SvMetaEnumValue, SvMetaName );
-/*********************************************************************=
****
-|*
-|*=09 SvMetaEnumValue::SvMetaEnumValue()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
SvMetaEnumValue::SvMetaEnumValue()
{
}
@@ -2162,23 +1794,16 @@ void SvMetaEnumValue::Save( SvPersistStream & r=
Stm )
{
SvMetaName::Save( rStm );
=20
- // Maske erstellen
+ // create mask
BYTE nMask =3D 0;
if( aEnumValue.Len() ) nMask |=3D 0x01;
=20
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm.WriteByteString( aEnumValue );
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|*
-|*=09 SvMetaEnumValue::ReadSvIdl()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2187,25 +1812,11 @@ BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase =
& rBase,
return TRUE;
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvMetaEnumValue::WriteSvIdl()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
void SvMetaEnumValue::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm,=
USHORT )
{
rOutStm << GetName().GetBuffer();
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvMetaEnumValue::Write()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, USHO=
RT,
WriteType nT, WriteAttribute )
{
@@ -2216,16 +1827,7 @@ void SvMetaEnumValue::Write( SvIdlDataBase &, Sv=
Stream & rOutStm, USHORT,
}
#endif // IDL_COMPILER
=20
-/*********************************************************************=
***/
-/*********************************************************************=
***/
SV_IMPL_META_FACTORY1( SvMetaTypeEnum, SvMetaType );
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypeEnum::SvMetaTypeEnum()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
SvMetaTypeEnum::SvMetaTypeEnum()
{
SetBasicName( "Integer" );
@@ -2251,25 +1853,18 @@ void SvMetaTypeEnum::Save( SvPersistStream & rS=
tm )
{
SvMetaType::Save( rStm );
=20
- // Maske erstellen
+ // create mask
BYTE nMask =3D 0;
if( aEnumValueList.Count() )=09nMask |=3D 0x01;
if( aPrefix.Len() ) =09=09=09nMask |=3D 0x02;
=20
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aEnumValueList;
if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
}
=20
#ifdef IDL_COMPILER
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypeEnum::ReadContextSvIdl()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2280,7 +1875,7 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataB=
ase & rBase,
if( bOk )
{
if( 0 =3D=3D aEnumValueList.Count() )
- // der Erste
+ // the first
aPrefix =3D aEnumVal->GetName();
else
{
@@ -2294,13 +1889,6 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlData=
Base & rBase,
rInStm.Seek( nTokPos );
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypeEnum::WriteSvIdl()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -2316,13 +1904,6 @@ void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDat=
aBase & rBase,
}
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypeEnum::ReadSvIdl()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2337,13 +1918,6 @@ BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & =
rBase,
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypeEnum::WriteSvIdl()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOu=
tStm,
USHORT nTab )
{
@@ -2353,13 +1927,6 @@ void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase &=
rBase, SvStream & rOutStm,
rOutStm << endl;
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypeEnum::Write()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,=
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -2367,11 +1934,6 @@ void SvMetaTypeEnum::Write( SvIdlDataBase & rBas=
e, SvStream & rOutStm,
SvMetaType::Write( rBase, rOutStm, nTab, nT, nA );
}
=20
-/*********************************************************************=
****
-|*=09 SvMetaTypeEnum::WriteContext()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & r=
OutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -2399,16 +1961,7 @@ void SvMetaTypeEnum::WriteContext( SvIdlDataBase=
& rBase, SvStream & rOutStm,
=20
#endif // IDL_COMPILER
=20
-/*********************************************************************=
***/
-/*********************************************************************=
***/
SV_IMPL_META_FACTORY1( SvMetaTypevoid, SvMetaType );
-/*********************************************************************=
****
-|*
-|*=09 SvMetaTypevoid::SvMetaTypevoid()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
SvMetaTypevoid::SvMetaTypevoid()
: SvMetaType( "void", "SbxVOID", "void", 'v', "void", "", "" )
{
@@ -2432,8 +1985,7 @@ ByteString SvMetaAttribute::Compare( SvMetaAttrib=
ute* pAttr )
{
if ( aType->GetType() =3D=3D TYPE_METHOD )
{
- // Nur testen, wenn das Attribut eine Methode ist, nicht w=
enn es
- // eine hat !!
+ // Test only when the attribute is a method not if it has =
one!
if ( !pAttr->GetType()->GetType() =3D=3D TYPE_METHOD )
aStr +=3D " 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>
=20
-/*********************************************************************=
****
-|*
-|*=09 Syntaxbeschreibung
-|*
-**********************************************************************=
***/
char const * SyntaxStrings[] =3D {
"basic-type:",
"\tvoid| char| int| float| double|",
@@ -91,7 +86,6 @@ char const * SyntaxStrings[] =3D {
"\t\tAccelConfig, MenuConfig, StatusBarConfig, ToolbarConfig",
"\t\tAutomation*",
"\t\tAutoUpdate",
-// "\t\tCachable*, Volatile",
"\t\tContainer",
"\t\tDefault =3D Identifier",
"\t\tExecMethod =3D Identifier",
@@ -134,11 +128,6 @@ char CommandLineSyntax[] =3D
"-help, ? @<file> response file\n"
" <filenames>\n";
=20
-/*********************************************************************=
****
-|*
-|*=09 Init()
-|*
-**********************************************************************=
***/
void Init()
{
if( !IDLAPP->pHashTable )
@@ -147,25 +136,11 @@ void Init()
IDLAPP->pGlobalNames=09=3D new SvGlobalHashNames();
}
=20
-/*********************************************************************=
****
-|*
-|*=09 DeInit()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
void DeInit()
{
delete IDLAPP;
}
=20
-/*********************************************************************=
****
-|*
-|*=09 DeInit()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
BOOL ReadIdl( SvIdlWorkingBase * pDataBase, const SvCommand & rCommand=
)
{
for( size_t n =3D 0; n < rCommand.aInFileList.size(); ++n )
@@ -204,21 +179,14 @@ BOOL ReadIdl( SvIdlWorkingBase * pDataBase, const=
SvCommand & rCommand )
return TRUE;
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvCommand::SvCommand()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
static BOOL ResponseFile( StringList * pList, int argc, char ** argv )=
{
- // Programmname
+ // program name
pList->push_back( new String( String::CreateFromAscii(*argv) ) );
for( int i =3D 1; i < argc; i++ )
{
if( '@' =3D=3D **(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() !=3D SVSTREAM_OK )
return FALSE;
@@ -246,11 +214,6 @@ static BOOL ResponseFile( StringList * pList, int =
argc, char ** argv )
return TRUE;
}
=20
-/*********************************************************************=
****
-|*=09 SvCommand::SvCommand()
-|*
-|*=09 Beschreibung
-**********************************************************************=
***/
SvCommand::SvCommand( int argc, char ** argv )
: nVerbosity(1), nFlags( 0 )
{
@@ -271,67 +234,58 @@ SvCommand::SvCommand( int argc, char ** argv )
aFirstChar =3D aParam.GetChar(0);
String aName( aParam.Copy( 1 ) );
if( 's' =3D=3D aFirstChar )
- { // Name der Slot-Ausgabe
+ { // name of slot output
aSlotMapFile =3D aName;
}
else if( 'l' =3D=3D aFirstChar )
- { // Name der Listing
+ { // name of listing
aListFile =3D aName;
}
else if( 'i' =3D=3D aFirstChar )
- { // Name der Item-Datei
-// aSfxItemFile =3D aName;
+ {
}
else if( 'o' =3D=3D aFirstChar )
- { // Name der ODL-Datei
-// aODLFile =3D aName;
+ {
}
else if( 'd' =3D=3D aFirstChar )
- { // Name der Datenbasis-Datei
+ { // name of data set file
aDataBaseFile =3D aName;
}
else if( 'D' =3D=3D aFirstChar )
- { // Name der Docu-Datei f"ur das API
-// aDocuFile =3D aName;
+ {
}
else if( 'C' =3D=3D aFirstChar )
- { // Name der cxx-Datei
-// aCxxFile =3D aName;
+ {
}
else if( 'H' =3D=3D aFirstChar )
- { // Name der hxx-Datei
-// aHxxFile =3D aName;
+ {
}
else if( 'c' =3D=3D aFirstChar )
- { // Name der C-Header-Datei
-// aCSourceFile =3D aName;
+ {
}
else if( 'h' =3D=3D aFirstChar )
- { // Name der C-Header-Datei
-// aCHeaderFile =3D aName;
+ {
}
else if( 't' =3D=3D aFirstChar )
- { // Name der Info-Datei
-// aCallingFile =3D aName;
+ {
}
else if( 'm' =3D=3D aFirstChar )
- { // Name der Info-Datei
+ { // name of info file
aTargetFile =3D aName;
}
else if( 'r' =3D=3D aFirstChar )
- { // Name der Resource-Datei
-// aSrcFile =3D aName;
+ {
}
else if( 'z' =3D=3D aFirstChar )
- { // Name der HelpId-Datei
+ { // name of HelpId file
aHelpIdFile =3D aName;
}
else if( 'y' =3D=3D aFirstChar )
- { // Name der CSV-Datei
+ { // name of CSV file
aCSVFile =3D aName;
}
else if( 'x' =3D=3D aFirstChar )
- { // Name der IDL-Datei fuer die CSV-Datei
+ { // name of IDL file for the CSV file
aExportFile =3D 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 =3D 2;
}
else if( aParam.EqualsIgnoreCaseAscii( "syntax" ) )
- { // Hilfe
+ { // help
int j =3D 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 +=3D DirEntry::GetSearchDelimiter();
aPath +=3D aName;
}
else if( aParam.EqualsIgnoreCaseAscii( "rsc", 0, 3 ) )
- { // erste Zeile im *.srs File
+ { // first line in *.srs file
if( aList[ i + 1 ] )
{
aSrsLine =3D ByteString( *aList[ i +1 ], RTL_TEXTE=
NCODING_UTF8 );
@@ -401,7 +355,7 @@ SvCommand::SvCommand( int argc, char ** argv )
aList.clear();
=20
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 )
}
}
=20
-/*********************************************************************=
****
-|*
-|*=09 SvCommand::~SvCommand()
-|*
-|*=09 Beschreibung
-|*
-**********************************************************************=
***/
SvCommand::~SvCommand()
{
- // ByteString Liste freigeben
+ // release ByteString list
for ( size_t i =3D 0, n =3D 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>
=20
-/****************** SvIdlDataBase ************************************=
****/
-/*********************************************************************=
****
-|* SvIdlDataBase::SvIdlDataBase()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
: bExport( FALSE )
, nUniqueId( 0 )
@@ -53,11 +47,6 @@ SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd =
)
{
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::~SvIdlDataBase()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvIdlDataBase::~SvIdlDataBase()
{
for ( size_t i =3D 0, n =3D aIdFileList.size(); i < n; ++i )
@@ -67,11 +56,6 @@ SvIdlDataBase::~SvIdlDataBase()
delete pIdTable;
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::GetTypeList()
-|*
-|* Beschreibung
-**********************************************************************=
***/
#define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost )=
\
aTypeList.Append( new SvMetaType( SvHash_##Name()->GetName(),=09\
BasName, OdlName, ParserChar, CName, BasName, Bas=
Post ) );
@@ -79,11 +63,11 @@ SvIdlDataBase::~SvIdlDataBase()
SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
{
if( aTypeList.Count() =3D=3D 0 )
- { // Initial fuellen
+ { // fill initially=20
aTypeList.Append( new SvMetaTypeString() );
aTypeList.Append( new SvMetaTypevoid() );
=20
- // 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", "" =
);
=20
- // A c h t u n g !!!, bei hinzufuegen von Typen werden alle
- // bin=84ren Datenbasen inkompatibel
-
- /*
- // So tun als ob die Init-Daten auf einem Stream gelesen wurde=
n
- 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 inco=
mpatible=20
+
}
return aTypeList;
}
=20
-/*********************************************************************=
****
-|*
-|* SvIdlDataBase::GetModuleInfo()
-|*
-**********************************************************************=
***/
SvMetaModule * SvIdlDataBase::GetModule( const ByteString & rName )
{
for( ULONG n =3D 0; n < aModuleList.Count(); n++ )
@@ -125,13 +94,6 @@ SvMetaModule * SvIdlDataBase::GetModule( const Byte=
String & rName )
return NULL;
}
=20
-/*********************************************************************=
****
-|*
-|* 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 & rSt=
m )
return nSig =3D=3D DATABASE_SIGNATURE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvIdlDataBase::Load()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
void SvIdlDataBase::Load( SvStream & rStm )
{
DBG_ASSERT( aTypeList.Count() =3D=3D 0, "type list already initial=
ized" );
@@ -181,11 +136,6 @@ void SvIdlDataBase::Load( SvStream & rStm )
aPStm.SetError( SVSTREAM_GENERALERROR );
}
=20
-/*********************************************************************=
****
-|* 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;
=20
- //aClassList.WriteObjects( aPStm, bOnlyStreamedObjs );
aTypeList.WriteObjects( aPStm, bOnlyStreamedObjs );
aAttrList.WriteObjects( aPStm, bOnlyStreamedObjs );
aModuleList.WriteObjects( aPStm, bOnlyStreamedObjs );
aPStm << nUniqueId;
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::SetError()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvIdlDataBase::SetError( const ByteString & rError, SvToken * pTo=
k )
{
if( pTok->GetLine() > 10000 )
@@ -237,24 +181,12 @@ void SvIdlDataBase::SetError( const ByteString & =
rError, SvToken * pTok )
}
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::Push()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvIdlDataBase::Push( SvMetaObject * pObj )
{
GetStack().Push( pObj );
}
=20
#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 & rId=
Name, ULONG * pVal )
return FALSE;
}
=20
-/*********************************************************************=
****
-|*
-|* SvIdlDataBase::InsertId()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
BOOL SvIdlDataBase::InsertId( const ByteString & rIdName, ULONG nVal )=
{
if( !pIdTable )
@@ -290,11 +215,6 @@ BOOL SvIdlDataBase::InsertId( const ByteString & r=
IdName, ULONG nVal )
return FALSE;
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::ReadIdFile()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
{
DirEntry aFullName( rFileName );
@@ -325,7 +245,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFil=
eName )
else
{
ByteString aStr( "unexpected token after defin=
e" );
- // Fehler setzen
+ // set error
SetError( aStr, pTok );
WriteError( aTokStm );
return FALSE;
@@ -357,7 +277,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFil=
eName )
ByteString aStr( "unknown operator '" =
);
aStr +=3D pTok->GetChar();
aStr +=3D "'in define";
- // Fehler setzen
+ // set error
SetError( aStr, pTok );
WriteError( aTokStm );
return FALSE;
@@ -365,8 +285,8 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFil=
eName )
if( pTok->GetChar() !=3D '+'
&& pTok->GetChar() !=3D '('
&& pTok->GetChar() !=3D ')' )
- // nur + erlaubt, Klammern spielen kei=
n 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 & rFil=
eName )
if( pTok->IsEof() )
{
ByteString aStr( "unexpected eof in #inclu=
de" );
- // Fehler setzen
+ // set error
SetError( aStr, pTok );
WriteError( aTokStm );
return FALSE;
@@ -430,11 +350,6 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFi=
leName )
return TRUE;
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::FindType()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
SvMetaTypeMemberList & rList )
{
@@ -452,25 +367,20 @@ SvMetaType * SvIdlDataBase::FindType( const ByteS=
tring & rName )
return pType;
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::ReadKnownType()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
{
BOOL bIn=09=3D FALSE;
BOOL bOut=09=3D FALSE;
int nCall0=09=3D CALL_VALUE;
int nCall1=09=3D CALL_VALUE;
- BOOL bSet =3D FALSE; //irgent ein Attribut gesetzt
+ BOOL bSet =3D FALSE; // any attribute set
=20
UINT32 nTokPos =3D rInStm.Tell();
SvToken * pTok =3D rInStm.GetToken_Next();
=20
if( pTok->HasHash() )
{
- UINT32 nBeginPos =3D 0; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos =3D 0; // can not happen with Tell
while( nBeginPos !=3D rInStm.Tell() )
{
nBeginPos =3D rInStm.Tell();
@@ -529,7 +439,7 @@ SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenS=
tream & rInStm )
}
=20
if( !bSet )
- // Ist genau dieser Typ
+ // is exactly this type
return pType;
=20
DBG_ASSERT( aTmpTypeList.First(), "mindestens ein Element"=
);
@@ -548,18 +458,11 @@ SvMetaType * SvIdlDataBase::ReadKnownType( SvToke=
nStream & rInStm )
return NULL;
}
=20
-/*********************************************************************=
****
-|*
-|* SvIdlDataBase::ReadKnownAttr()
-|*
-|* Beschreibung
-|*
-**********************************************************************=
***/
SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
(
SvTokenStream & rInStm,
- SvMetaType *=09pType=09/* Wenn der pType =3D=3D NULL, dann muss de=
r Typ
- noch gelesen werden. */
+ SvMetaType *=09pType=09/* If pType =3D=3D NULL, then the type has
+ still to be read. */
)
{
UINT32 nTokPos =3D rInStm.Tell();
@@ -569,7 +472,7 @@ SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
=20
if( !pType )
{
- // sonst SlotId?
+ // otherwise SlotId?
SvToken * pTok =3D rInStm.GetToken_Next();
if( pTok->IsIdentifier() )
{
@@ -613,11 +516,6 @@ SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
return NULL;
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::ReadKnownClass()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
{
UINT32 nTokPos =3D rInStm.Tell();
@@ -635,11 +533,6 @@ SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTok=
enStream & rInStm )
return NULL;
}
=20
-/*********************************************************************=
****
-|* SvIdlDataBase::Write()
-|*
-|* Beschreibung
-**********************************************************************=
***/
void SvIdlDataBase::Write( const ByteString & rText )
{
#ifndef W31
@@ -648,36 +541,26 @@ void SvIdlDataBase::Write( const ByteString & rTe=
xt )
#endif
}
=20
-/*********************************************************************=
****
-|* 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=
);
=20
if( rErrorText.Len() )
- { // Fehler gesetzt
+ { // error set
fprintf( stderr, "\t%s\n", rErrorText.GetBuffer() );
}
#endif
}
=20
-/*********************************************************************=
****
-|* 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 & r=
InStm )
rInStm.SeekEnd();
SvToken *pTok =3D rInStm.GetToken();
=20
- // Fehlerposition
+ // error position
nRow =09=3D pTok->GetLine();
nColumn =3D pTok->GetColumn();
=20
if( aError.IsError() )
- { // Fehler gesetzt
- // Fehler Token suchen
- // Fehlertext
+ { // error set
+ // search error token
+ // error text
if( aError.GetText().Len() )
{
aErrorText =3D "may be <";
@@ -709,14 +592,14 @@ void SvIdlDataBase::WriteError( SvTokenStream & r=
InStm )
pTok =3D rInStm.GetToken_PrevAll();
}
=20
- // Fehlerposition
+ // error position
aErrorText +=3D "> at ( ";
aErrorText +=3D ByteString::CreateFromInt64(aError.nLine);
aErrorText +=3D ", ";
aErrorText +=3D ByteString::CreateFromInt64(aError.nColumn);
aErrorText +=3D " )";
=20
- // Fehler zuruecksetzen
+ // reset error
aError =3D SvIdlError();
}
=20
@@ -726,7 +609,7 @@ void SvIdlDataBase::WriteError( SvTokenStream & rIn=
Stm )
if( !pTok )
return;
=20
- // Identifier in der Naehe suchen
+ // look for identifier close by
if( !pTok->IsIdentifier() )
{
rInStm.GetToken_PrevAll();
@@ -741,28 +624,17 @@ void SvIdlDataBase::WriteError( SvTokenStream & r=
InStm )
#endif
}
=20
-/****************** SvIdlWorkingBase *********************************=
*******/
-/*********************************************************************=
****
-|* SvIdlWorkingBase::SvIdlWorkingBase()
-|*
-|* Beschreibung
-**********************************************************************=
***/
SvIdlWorkingBase::SvIdlWorkingBase(const SvCommand& rCmd) : SvIdlDataB=
ase(rCmd)
{
}
=20
-/*********************************************************************=
****
-|* SvIdlWorkingBase::ReadSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImport=
ed, const String & rPath )
{
- aPath =3D rPath; // nur fuer den durchlauf gueltig
+ aPath =3D rPath; // only valid for this iteration
SvToken * pTok;
BOOL bOk =3D TRUE;
pTok =3D 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 & r=
InStm, BOOL bImported, const
bOk =3D FALSE;
}
=20
- UINT32 nBeginPos =3D 0xFFFFFFFF; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos =3D 0xFFFFFFFF; // can not happen with Tell
=20
while( bOk && nBeginPos !=3D rInStm.Tell() )
{
@@ -813,8 +685,8 @@ BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & r=
InStm, BOOL bImported, const
if( pTok->IsEmpty() )
bOk =3D FALSE;
=20
- // 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 =3D new SvMetaModule( rInStm.GetFi=
leName(), 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;
}
=20
-/*********************************************************************=
****
-|* SvIdlWorkingBase::WriteSvIdl()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
{
if( rOutStm.GetError() !=3D SVSTREAM_OK )
@@ -862,23 +729,17 @@ BOOL SvIdlWorkingBase::WriteSvIdl( SvStream & rOu=
tStm )
for( ULONG n =3D 0; n < GetModuleList().Count(); n++ )
{
SvMetaModule * pModule =3D GetModuleList().GetObject( n );
- //if( !pModule->IsImported() )
- pModule->WriteSvIdl( *this, rOutStm, 0 );
+ pModule->WriteSvIdl( *this, rOutStm, 0 );
}
return TRUE;
}
=20
-/*********************************************************************=
****
-|* SvIdlWorkingBase::WriteSfx()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
{
if( rOutStm.GetError() !=3D SVSTREAM_OK )
return FALSE;
=20
- // 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& rOut=
Stm )
for( n =3D 0; n < GetModuleList().Count(); n++ )
{
SvMetaModule * pModule =3D GetModuleList().GetObject( n );
- //if( !pModule->IsImported() )
- pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
+ pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
}
=20
const SvMetaAttributeMemberList & rAttrList =3D GetAttrList();
@@ -923,11 +783,6 @@ BOOL SvIdlWorkingBase::WriteHelpIds( SvStream& rOu=
tStm )
return TRUE;
}
=20
-/*********************************************************************=
****
-|* SvIdlWorkingBase::WriteSfxItem()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvIdlWorkingBase::WriteSfxItem( SvStream & )
{
return FALSE;
@@ -963,11 +818,6 @@ BOOL SvIdlWorkingBase::WriteCSV( SvStream& rStrm )=
return TRUE;
}
=20
-/*********************************************************************=
****
-|* SvIdlWorkingBase::WriteDocumentation()
-|*
-|* Beschreibung
-**********************************************************************=
***/
BOOL SvIdlWorkingBase::WriteDocumentation( SvStream & rOutStm )
{
if( rOutStm.GetError() !=3D 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"
=20
-/****************** I N C L U D E S **********************************=
****/
#include <tools/shl.hxx>
=20
#include <globals.hxx>
#include <database.hxx>
=20
-/****************** G L O B A L S ************************************=
****/
#ifdef DOS
static IdlDll * pApp =3D NULL;
IdlDll * GetIdlApp()
@@ -50,9 +48,6 @@ IdlDll * GetIdlApp()
if( !(*(IdlDll**)GetAppData(SHL_IDL)) )
{
(*(IdlDll**)GetAppData(SHL_IDL)) =3D new IdlDll();
- // Temporaer, sonst nur wenn Compiler
- //GetIdlApp()->pHashTable =3D new SvStringHashTable( 2801=
);
- //GetIdlApp()->pGlobalNames =3D new SvGlobalHashNames();
}
return (*(IdlDll**)GetAppData(SHL_IDL));
}
@@ -93,11 +88,6 @@ IdlDll::~IdlDll()
delete pHashTable;
}
=20
-/*********************************************************************=
****
-|*
-|* 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 @@
=20
#include <sysdep.hxx>
=20
-// Statische DLL-Verwaltungs-Variablen
-static HINSTANCE hDLLInst =3D 0; // HANDLE der DLL
+// static DLL handle
+static HINSTANCE hDLLInst =3D 0; // HANDLE of the DLL
=20
=20
/*********************************************************************=
******
|*
|* LibMain()
|*
-|* Beschreibung Initialisierungsfunktion der DLL
+|* description initializing function of the DLL
|*
**********************************************************************=
*****/
=20
@@ -62,7 +62,7 @@ extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD=
, WORD nHeap, LPSTR )
|*
|* WEP()
|*
-|* Beschreibung DLL-Deinitialisierung
+|* description DLL de-initializing
|*
**********************************************************************=
*****/
=20
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 St=
ring & rFile2, BOOL bImmerVer
}
DirEntry aF2( rFile2 );
if( nC1 !=3D 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 Str=
ing & rFile2, BOOL bImmerVer
return 0 =3D=3D aF2.Kill();
}
=20
-/*********************************************************************=
****
-|*=09 main()
-|*
-|*=09 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 );
}
--=20
1.7.4
--nextPart13818007.ONtyt7Czqr--
More information about the LibreOffice
mailing list