summaryrefslogtreecommitdiff
path: root/idl/source/objects
diff options
context:
space:
mode:
authorMichael Münch <michael@codingmicha.de>2011-02-13 18:06:10 +0100
committerThomas Arnhold <thomas@arnhold.org>2011-02-13 18:06:10 +0100
commitfdba64b10f4b9628e32802dcaf6ad1978c20e801 (patch)
tree5ccac9211f23048f8eeffa77783318fca39f287d /idl/source/objects
parentbc1d99cef822b8015de6b3980193d0feb5383f2d (diff)
Easy hack: idl removed and translated comments
Diffstat (limited to 'idl/source/objects')
-rw-r--r--idl/source/objects/basobj.cxx219
-rw-r--r--idl/source/objects/bastype.cxx133
-rw-r--r--idl/source/objects/module.cxx104
-rw-r--r--idl/source/objects/object.cxx188
-rw-r--r--idl/source/objects/slot.cxx221
-rw-r--r--idl/source/objects/types.cxx526
6 files changed, 173 insertions, 1218 deletions
diff --git a/idl/source/objects/basobj.cxx b/idl/source/objects/basobj.cxx
index 46936b3124..6f7a01904f 100644
--- a/idl/source/objects/basobj.cxx
+++ b/idl/source/objects/basobj.cxx
@@ -39,13 +39,7 @@
#include <globals.hxx>
#include <database.hxx>
-/****************** SvMetaObject *****************************************/
SV_IMPL_META_FACTORY1( SvMetaObject, SvRttiBase )
-/*************************************************************************
-|* SvMetaObject::SvMetaObject()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaObject::SvMetaObject()
{
}
@@ -58,24 +52,13 @@ void SvMetaObject::Save( SvPersistStream & )
{
}
-/*************************************************************************
-|* SvMetaObject::WriteTab()
-|*
-|* Beschreibung
-*************************************************************************/
#ifdef IDL_COMPILER
void SvMetaObject::WriteTab( SvStream & rOutStm, USHORT nTab )
{
while( nTab-- )
rOutStm << " ";
-// rOutStm << '\t';
}
-/*************************************************************************
-|* SvMetaObject::WriteStart()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaObject::WriteStars( SvStream & rOutStm )
{
rOutStm << '/';
@@ -84,14 +67,9 @@ void SvMetaObject::WriteStars( SvStream & rOutStm )
rOutStm << '/' << endl;
}
-/*************************************************************************
-|* SvMetaObject::TestAndSeekSpaceOnly()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaObject::TestAndSeekSpaceOnly( SvStream & rOutStm, ULONG nBegPos )
{
- // keine leeren Klammern schreiben
+ // write no empty brackets
ULONG nPos = rOutStm.Tell();
rOutStm.Seek( nBegPos );
BOOL bOnlySpace = TRUE;
@@ -103,21 +81,16 @@ BOOL SvMetaObject::TestAndSeekSpaceOnly( SvStream & rOutStm, ULONG nBegPos )
bOnlySpace = FALSE;
}
if( bOnlySpace )
- // nichts geschrieben
+ // nothing written
rOutStm.Seek( nBegPos );
else
rOutStm.Seek( nPos );
return bOnlySpace;
}
-/*************************************************************************
-|* SvMetaObject::Back2Delemitter()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaObject::Back2Delemitter( SvStream & rOutStm )
{
- // keine leeren Klammern schreiben
+ // write no empty brackets
ULONG nPos = rOutStm.Tell();
rOutStm.SeekRel( -1 );
char c = 0;
@@ -135,62 +108,31 @@ void SvMetaObject::Back2Delemitter( SvStream & rOutStm )
rOutStm.Seek( nPos );
}
-/*************************************************************************
-|* SvMetaObject::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaObject::ReadSvIdl( SvIdlDataBase &, SvTokenStream & )
{
return FALSE;
}
-/*************************************************************************
-|* SvMetaObject::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaObject::WriteSvIdl( SvIdlDataBase &, SvStream &, USHORT /*nTab */ )
{
}
-/*************************************************************************
-|* SvMetaObject::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaObject::Write( SvIdlDataBase &, SvStream &, USHORT /*nTab */,
WriteType, WriteAttribute )
{
}
-/*************************************************************************
-|* SvMetaObject::WriteCxx()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaObject::WriteCxx( SvIdlDataBase &, SvStream &, USHORT /*nTab */ )
{
}
-/*************************************************************************
-|* SvMetaObject::WriteHxx()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaObject::WriteHxx( SvIdlDataBase &, SvStream &, USHORT /*nTab */ )
{
}
#endif
-/****************** SvMetaName *****************************************/
SV_IMPL_META_FACTORY1( SvMetaName, SvMetaObject );
-/*************************************************************************
-|* SvMetaName::SvMetaName()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaName::SvMetaName()
{
}
@@ -239,18 +181,13 @@ BOOL SvMetaName::SetName( const ByteString & rName, SvIdlDataBase * )
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaName::ReadNameSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaName::ReadNameSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
SvToken * pTok = rInStm.GetToken_Next();
- // Modulnamen lesen
+ // read module name
if( pTok->IsIdentifier() )
if( SetName( pTok->GetString(), &rBase ) )
return TRUE;
@@ -259,11 +196,6 @@ BOOL SvMetaName::ReadNameSvIdl( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|* SvMetaName::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -277,21 +209,12 @@ void SvMetaName::ReadAttributesSvIdl( SvIdlDataBase & rBase,
aHelpText.ReadSvIdl( rBase, rInStm );
aConfigName.ReadSvIdl( SvHash_ConfigName(), rInStm );
aDescription.ReadSvIdl( SvHash_Description(), rInStm );
-/*
- aHelpContext.ReadSvIdl( GetModule()->GetInfo()->GetHelpContextContainer(),
- rInStm );
-*/
}
-/*************************************************************************
-|* SvMetaName::DoReadContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::DoReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm, char cDel )
{
- UINT32 nBeginPos = 0; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos = 0; // can not happen with Tell
while( nBeginPos != rInStm.Tell() )
{
nBeginPos = rInStm.Tell();
@@ -303,39 +226,19 @@ void SvMetaName::DoReadContextSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaName::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::ReadContextSvIdl( SvIdlDataBase &, SvTokenStream & )
{
}
-/*************************************************************************
-|* SvMetaName::Test()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaName::Test( SvIdlDataBase &, SvTokenStream & )
{
return TRUE;
}
-/*************************************************************************
-|* SvMetaName::WriteContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::WriteContextSvIdl( SvIdlDataBase &, SvStream &, USHORT )
{
}
-/*************************************************************************
-|* SvMetaName::WriteDescription()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::WriteDescription( SvStream & rOutStm )
{
rOutStm << "<DESCRIPTION>" << endl;
@@ -352,11 +255,6 @@ void SvMetaName::WriteDescription( SvStream & rOutStm )
rOutStm << aDesc.GetBuffer() << endl << "</DESCRIPTION>" << endl;
}
-/*************************************************************************
-|* SvMetaName::WriteAttributesIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -386,18 +284,13 @@ void SvMetaName::WriteAttributesSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaName::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaName::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
BOOL bOk = TRUE;
if( rInStm.Read( '[' ) )
{
- UINT32 nBeginPos = 0; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos = 0; // can not happen with Tell
while( nBeginPos != rInStm.Tell() )
{
nBeginPos = rInStm.Tell();
@@ -421,11 +314,6 @@ BOOL SvMetaName::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
return bOk;
}
-/*************************************************************************
-|* SvMetaName::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
@@ -435,9 +323,9 @@ void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
ULONG nOldPos = rOutStm.Tell();
WriteAttributesSvIdl( rBase, rOutStm, nTab +1 );
- // keine leeren Klammern schreiben
+ // write no empty brackets
if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
- // nichts geschrieben
+ // nothing written
rOutStm.Seek( nBeginPos );
else
{
@@ -452,9 +340,9 @@ void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
nOldPos = rOutStm.Tell();
WriteContextSvIdl( rBase, rOutStm, nTab +1 );
- // keine leeren Klammern schreiben
+ // write no empty brackets
if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
- // nichts geschrieben
+ // nothing written
rOutStm.Seek( nBeginPos );
else
{
@@ -463,11 +351,6 @@ void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaName::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -478,7 +361,7 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
ULONG nOldPos = rOutStm.Tell();
WriteAttributes( rBase, rOutStm, nTab +1, nT, nA );
- // keine leeren Klammern schreiben
+ // write no empty brackets
ULONG nPos = rOutStm.Tell();
rOutStm.Seek( nOldPos );
BOOL bOnlySpace = TRUE;
@@ -490,7 +373,7 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
bOnlySpace = FALSE;
}
if( bOnlySpace )
- // nichts geschrieben
+ // nothing written
rOutStm.Seek( nBeginPos );
else
{
@@ -500,11 +383,6 @@ void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaName::WriteAttributes()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::WriteAttributes( SvIdlDataBase &, SvStream & rOutStm,
USHORT nTab,
WriteType, WriteAttribute )
@@ -529,11 +407,6 @@ void SvMetaName::WriteAttributes( SvIdlDataBase &, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaName::WriteContext()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaName::WriteContext( SvIdlDataBase &, SvStream &,
USHORT,
WriteType, WriteAttribute )
@@ -541,14 +414,8 @@ void SvMetaName::WriteContext( SvIdlDataBase &, SvStream &,
}
#endif // IDL_COMPILER
-/****************** SvMetaReference *****************************************/
SV_IMPL_META_FACTORY1( SvMetaReference, SvMetaName );
-/*************************************************************************
-|* SvMetaReference::SvMetaReference()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaReference::SvMetaReference()
{
}
@@ -577,25 +444,18 @@ void SvMetaReference::Save( SvPersistStream & rStm )
{
SvMetaName::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aRef.Is() )
nMask |= 0x01;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aRef;
}
-/**************************************************************************/
-/****************** SvMetaExtern ******************************************/
SV_IMPL_META_FACTORY1( SvMetaExtern, SvMetaReference );
-/*************************************************************************
-|* SvMetaExtern::SvMetaExtern()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaExtern::SvMetaExtern()
: pModule( NULL )
, bReadUUId( FALSE )
@@ -626,7 +486,7 @@ void SvMetaExtern::Save( SvPersistStream & rStm )
{
SvMetaReference::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( pModule ) nMask |= 0x01;
if( aUUId != SvGlobalName() ) nMask |= 0x02;
@@ -634,29 +494,19 @@ void SvMetaExtern::Save( SvPersistStream & rStm )
if( bReadUUId ) nMask |= 0x08;
if( bReadVersion ) nMask |= 0x10;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << pModule;
if( nMask & 0x02 ) rStm << aUUId;
if( nMask & 0x04 ) rStm << aVersion;
}
-/*************************************************************************
-|* SvMetaExtern::GetModule()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaModule * SvMetaExtern::GetModule() const
{
DBG_ASSERT( pModule != NULL, "module not set" );
return pModule;
}
-/*************************************************************************
-|* SvMetaExtern::GetUUId()
-|*
-|* Beschreibung
-*************************************************************************/
const SvGlobalName & SvMetaExtern::GetUUId() const
{
#ifdef IDL_COMPILER
@@ -667,21 +517,11 @@ const SvGlobalName & SvMetaExtern::GetUUId() const
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaExtern::SetModule()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaExtern::SetModule( SvIdlDataBase & rBase )
{
pModule = (SvMetaModule *)rBase.GetStack().Get( TYPE( SvMetaModule ) );
}
-/*************************************************************************
-|* SvMetaExtern::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -692,11 +532,6 @@ void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataBase & rBase,
bReadVersion = TRUE;
}
-/*************************************************************************
-|* SvMetaExtern::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaExtern::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm, USHORT nTab )
{
@@ -721,34 +556,19 @@ void SvMetaExtern::WriteAttributesSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaExtern::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaExtern::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
{
SetModule( rBase );
- GetUUId(); // Id wird angelegt
+ GetUUId(); // id gets created
return SvMetaReference::ReadSvIdl( rBase, rInStm );
}
-/*************************************************************************
-|* SvMetaExtern::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaExtern::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
SvMetaReference::WriteSvIdl( rBase, rOutStm, nTab );
}
-/*************************************************************************
-|* SvMetaExtern::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaExtern::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -756,11 +576,6 @@ void SvMetaExtern::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaReference::Write( rBase, rOutStm, nTab, nT, nA );
}
-/*************************************************************************
-|* SvMetaExtern::WriteAttributes()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaExtern::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
diff --git a/idl/source/objects/bastype.cxx b/idl/source/objects/bastype.cxx
index fff80ccade..1c14469171 100644
--- a/idl/source/objects/bastype.cxx
+++ b/idl/source/objects/bastype.cxx
@@ -40,7 +40,6 @@
#include <database.hxx>
#ifdef IDL_COMPILER
-/************************************************************************/
static BOOL ReadRangeSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm,
ULONG nMin, ULONG nMax, ULONG* pValue )
{
@@ -72,12 +71,6 @@ static BOOL ReadRangeSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm,
}
#endif
-/*************************************************************************
-|*
-|* SvUINT32::Read()
-|* SvUINT32::Write()
-|*
-*************************************************************************/
UINT32 SvUINT32::Read( SvStream & rStm )
{
return SvPersistStream::ReadCompressed( rStm );
@@ -88,12 +81,6 @@ void SvUINT32::Write( SvStream & rStm, UINT32 nVal )
SvPersistStream::WriteCompressed( rStm, nVal );
}
-/*************************************************************************
-|*
-|* SvStream& operator << ( SvBOOL )
-|* SvStream& operator >> ( SvBOOL )
-|*
-*************************************************************************/
SvStream& operator << (SvStream & rStm, const SvBOOL & rb )
{
BYTE n = rb.nVal;
@@ -116,19 +103,13 @@ SvStream& operator >> (SvStream & rStm, SvBOOL & rb )
return rStm;
}
-/*************************************************************************
-|*
-|* SvStream& operator << ( SvVersion )
-|* SvStream& operator >> ( SvVersion )
-|*
-*************************************************************************/
SvStream& operator << (SvStream & rStm, const SvVersion & r )
{
if( (r.GetMajorVersion() || r.GetMinorVersion())
&& r.GetMajorVersion() <= 0x0F && r.GetMinorVersion() <= 0x0F )
- { // Versionsnummer in 1 Byte komprimieren
- // Format 4 Bit fuer Major, dann 4 Bit fuer Minor.
- // 0.0 wird nicht komprimiert
+ { // compress version number in 1 byte
+ // format first 4 bit for major, then 4 bit for minor
+ // 0.0 gets not compressed
int n = r.GetMajorVersion() << 4;
n |= r.GetMinorVersion();
@@ -148,12 +129,12 @@ SvStream& operator >> (SvStream & rStm, SvVersion & r )
BYTE n;
rStm >> n;
if( n == 0 )
- { // nicht komprimiert
+ { // not compressed
rStm >> r.nMajorVersion;
rStm >> r.nMinorVersion;
}
else
- { // komprimiert
+ { // compressed
r.nMajorVersion = (n >> 4) & 0x0F;
r.nMinorVersion = n & 0x0F;
}
@@ -162,13 +143,6 @@ SvStream& operator >> (SvStream & rStm, SvVersion & r )
#ifdef IDL_COMPILER
-/************************************************************************/
-
-/*************************************************************************
-|*
-|* SvBOOL::ReadSvIdl()
-|*
-*************************************************************************/
BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
@@ -191,7 +165,7 @@ BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
bOk = rInStm.Read( ')' );
}
else
- *this = TRUE; //Defaultaktion ist auf TRUE setzen
+ *this = TRUE; //default action set to TRUE
if( bOk )
return TRUE;
}
@@ -199,13 +173,6 @@ BOOL SvBOOL::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
return FALSE;
}
-/*************************************************************************
-|*
-|* SvBOOL::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvBOOL::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm )
{
if( nVal )
@@ -215,13 +182,6 @@ BOOL SvBOOL::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm )
return TRUE;
}
-/*************************************************************************
-|*
-|* SvBOOL::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
ByteString SvBOOL::GetSvIdlString( SvStringHashEntry * pName )
{
if( nVal )
@@ -235,14 +195,6 @@ ByteString SvBOOL::GetSvIdlString( SvStringHashEntry * pName )
}
-/************************************************************************/
-/*************************************************************************
-|*
-|* SvIdentifier::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvIdentifier::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
@@ -270,13 +222,6 @@ BOOL SvIdentifier::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm
return FALSE;
}
-/*************************************************************************
-|*
-|* SvIdentifier::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvIdentifier::WriteSvIdl( SvStringHashEntry * pName,
SvStream & rOutStm,
USHORT /*nTab */ )
@@ -299,14 +244,6 @@ SvStream& operator >> (SvStream & rStm, SvIdentifier & r )
}
-/************************************************************************/
-/*************************************************************************
-|*
-|* SvNumberIdentifier::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
SvStringHashEntry * pName,
SvTokenStream & rInStm )
@@ -331,13 +268,6 @@ BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|*
-|* SvNumberIdentifier::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -366,12 +296,6 @@ BOOL SvNumberIdentifier::ReadSvIdl( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|*
-|* SvStream& operator << ( SvNumberIdentifier )
-|* SvStream& operator >> ( SvNumberIdentifier )
-|*
-*************************************************************************/
SvStream& operator << (SvStream & rStm, const SvNumberIdentifier & r )
{
rStm << (SvIdentifier &)r;
@@ -387,12 +311,6 @@ SvStream& operator >> (SvStream & rStm, SvNumberIdentifier & r )
}
-/************************************************************************/
-/*************************************************************************
-|*
-|* SvString::ReadSvIdl()
-|*
-*************************************************************************/
BOOL SvString::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
@@ -420,11 +338,6 @@ BOOL SvString::ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm )
return FALSE;
}
-/*************************************************************************
-|*
-|* SvString::WriteSvIdl()
-|*
-*************************************************************************/
BOOL SvString::WriteSvIdl( SvStringHashEntry * pName, SvStream & rOutStm,
USHORT /*nTab */ )
{
@@ -446,32 +359,16 @@ SvStream& operator >> (SvStream & rStm, SvString & r )
}
-/*************************************************************************
-|*
-|* SvHelpText::ReadSvIdl()
-|*
-*************************************************************************/
BOOL SvHelpText::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
{
return SvString::ReadSvIdl( SvHash_HelpText(), rInStm );
}
-/*************************************************************************
-|*
-|* SvHelpText::WriteSvIdl()
-|*
-*************************************************************************/
BOOL SvHelpText::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, USHORT nTab )
{
return SvString::WriteSvIdl( SvHash_HelpText(), rOutStm, nTab );
}
-/************************************************************************/
-/*************************************************************************
-|*
-|* SvUUId::ReadSvIdl()
-|*
-*************************************************************************/
BOOL SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
@@ -499,26 +396,15 @@ BOOL SvUUId::ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm )
return FALSE;
}
-/*************************************************************************
-|*
-|* SvMetaObject::WriteSvIdl()
-|*
-*************************************************************************/
BOOL SvUUId::WriteSvIdl( SvStream & rOutStm )
{
- // Global Id schreiben
+ // write global id
rOutStm << SvHash_uuid()->GetName().GetBuffer() << "(\"";
rOutStm << ByteString( GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << "\")";
return TRUE;
}
-/************************************************************************/
-/*************************************************************************
-|*
-|* SvVersion::ReadSvIdl()
-|*
-*************************************************************************/
BOOL SvVersion::ReadSvIdl( SvTokenStream & rInStm )
{
ULONG n = 0;
@@ -543,11 +429,6 @@ BOOL SvVersion::ReadSvIdl( SvTokenStream & rInStm )
return FALSE;
}
-/*************************************************************************
-|*
-|* SvVersion::WriteSvIdl()
-|*
-*************************************************************************/
BOOL SvVersion::WriteSvIdl( SvStream & rOutStm )
{
rOutStm << SvHash_Version()->GetName().GetBuffer() << '('
diff --git a/idl/source/objects/module.cxx b/idl/source/objects/module.cxx
index 19c6e51fb8..6b7cdcf86f 100644
--- a/idl/source/objects/module.cxx
+++ b/idl/source/objects/module.cxx
@@ -38,12 +38,8 @@
#include <tools/fsys.hxx>
#include <tools/debug.hxx>
-/****************** SvMetaModule ******************************************/
SV_IMPL_META_FACTORY1( SvMetaModule, SvMetaExtern );
-/*************************************************************************
-|* SvMetaModule::SvMetaModule()
-*************************************************************************/
SvMetaModule::SvMetaModule()
#ifdef IDL_COMPILER
: bImported( FALSE )
@@ -60,30 +56,27 @@ SvMetaModule::SvMetaModule( const String & rIdlFileName, BOOL bImp )
}
#endif
-/*************************************************************************
-|* SvMetaModule::Load()
-*************************************************************************/
#define MODULE_VER 0x0001
void SvMetaModule::Load( SvPersistStream & rStm )
{
- bImported = TRUE; // immer importiert
+ bImported = TRUE; // import always
SvMetaExtern::Load( rStm );
USHORT nVer;
- rStm >> nVer; // Version
+ rStm >> nVer; // version
DBG_ASSERT( (nVer & ~IDL_WRITE_MASK) == MODULE_VER, "false version" );
rStm >> aClassList;
rStm >> aTypeList;
rStm >> aAttrList;
- // Browser
+ // browser
rStm.ReadByteString( aIdlFileName );
rStm.ReadByteString( aHelpFileName );
rStm.ReadByteString( aSlotIdFile );
rStm.ReadByteString( aModulePrefix );
- // Compiler Daten lesen
+ // read compiler data
USHORT nCmpLen;
rStm >> nCmpLen;
#ifdef IDL_COMPILER
@@ -97,25 +90,22 @@ void SvMetaModule::Load( SvPersistStream & rStm )
#endif
}
-/*************************************************************************
-|* SvMetaModule::Save()
-*************************************************************************/
void SvMetaModule::Save( SvPersistStream & rStm )
{
SvMetaExtern::Save( rStm );
- rStm << (USHORT)(MODULE_VER | IDL_WRITE_COMPILER); // Version
+ rStm << (USHORT)(MODULE_VER | IDL_WRITE_COMPILER); // version
rStm << aClassList;
rStm << aTypeList;
rStm << aAttrList;
- // Browser
+ // browser
rStm.WriteByteString( aIdlFileName );
rStm.WriteByteString( aHelpFileName );
rStm.WriteByteString( aSlotIdFile );
rStm.WriteByteString( aModulePrefix );
- // Compiler Daten schreiben
+ // write compiler data
USHORT nCmpLen = 0;
ULONG nLenPos = rStm.Tell();
rStm << nCmpLen;
@@ -123,7 +113,7 @@ void SvMetaModule::Save( SvPersistStream & rStm )
rStm << aBeginName;
rStm << aEndName;
rStm << aNextName;
- // Laenge der Compiler Daten schreiben
+ // write length of compiler data
ULONG nPos = rStm.Tell();
rStm.Seek( nLenPos );
rStm << (USHORT)( nPos - nLenPos - sizeof( USHORT ) );
@@ -131,9 +121,6 @@ void SvMetaModule::Save( SvPersistStream & rStm )
#endif
}
-/*************************************************************************
-|* SvMetaModule::SetName()
-*************************************************************************/
BOOL SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * pBase )
{
if( pBase )
@@ -145,9 +132,6 @@ BOOL SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * pBase )
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaModule::GetNextName()
-*************************************************************************/
BOOL SvMetaModule::FillNextName( SvGlobalName * pName )
{
*pName = aNextName;
@@ -161,9 +145,6 @@ BOOL SvMetaModule::FillNextName( SvGlobalName * pName )
return FALSE;
}
-/*************************************************************************
-|* SvMetaModule::ReadSvIdl()
-*************************************************************************/
void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -187,9 +168,6 @@ void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase,
aModulePrefix.ReadSvIdl( SvHash_ModulePrefix(), rInStm );
}
-/*************************************************************************
-|* SvMetaModule::WriteAttributesSvIdl()
-*************************************************************************/
void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -218,9 +196,6 @@ void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaModule::ReadContextSvIdl()
-*************************************************************************/
void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -232,7 +207,7 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
if( aClass->ReadSvIdl( rBase, rInStm ) )
{
aClassList.Append( aClass );
- // Global bekanntgeben
+ // announce globally
rBase.GetClassList().Append( aClass );
}
}
@@ -242,9 +217,9 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
if( aEnum->ReadSvIdl( rBase, rInStm ) )
{
- // Im Modul deklariert
+ // declared in module
aTypeList.Append( aEnum );
- // Global bekanntgeben
+ // announce globally
rBase.GetTypeList().Append( aEnum );
}
}
@@ -256,9 +231,9 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
if( xItem->ReadSvIdl( rBase, rInStm ) )
{
- // Im Modul deklariert
+ // declared in module
aTypeList.Append( xItem );
- // Global bekanntgeben
+ // announce globally
rBase.GetTypeList().Append( xItem );
}
}
@@ -276,12 +251,12 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream aTokStm( aFullName.GetFull() );
if( SVSTREAM_OK == aTokStm.GetStream().GetError() )
{
- // Fehler aus alter Datei retten
+ // rescue error from old file
SvIdlError aOldErr = rBase.GetError();
- // Fehler zuruecksetzen
+ // reset error
rBase.SetError( SvIdlError() );
- UINT32 nBeginPos = 0xFFFFFFFF; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
while( nBeginPos != aTokStm.Tell() )
{
nBeginPos = aTokStm.Tell();
@@ -293,7 +268,7 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
{
rBase.WriteError( aTokStm );
}
- // Fehler aus alter Datei wieder herstellen
+ // recover error from old file
rBase.SetError( aOldErr );
}
else
@@ -321,18 +296,15 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase,
{
if( xSlot->Test( rBase, rInStm ) )
{
- // Im Modul deklariert
+ // declared in module
aAttrList.Append( xSlot );
- // Global bekanntgeben
+ // announce globally
rBase.AppendAttr( xSlot );
}
}
}
}
-/*************************************************************************
-|* SvMetaModule::WriteContextSvIdl()
-*************************************************************************/
void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -358,12 +330,9 @@ void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaModule::ReadSvIdl()
-*************************************************************************/
BOOL SvMetaModule::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
{
- bIsModified = TRUE; // bisher immer wenn Compiler laueft
+ bIsModified = TRUE; // up to now always when compiler running
UINT32 nTokPos = rInStm.Tell();
SvToken * pTok = rInStm.GetToken_Next();
@@ -387,24 +356,21 @@ BOOL SvMetaModule::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
{
aNextName = aBeginName;
- rBase.Push( this ); // auf den Context Stack
+ rBase.Push( this ); // onto the context stack
if( ReadNameSvIdl( rBase, rInStm ) )
{
- // Zeiger auf sich selbst setzen
+ // set pointer to itself
SetModule( rBase );
bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
}
- rBase.GetStack().Pop(); // und runter
+ rBase.GetStack().Pop(); // remove from stack
}
if( !bOk )
rInStm.Seek( nTokPos );
return bOk;
}
-/*************************************************************************
-|* SvMetaModule::WriteSvIdl()
-*************************************************************************/
void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
@@ -417,9 +383,6 @@ void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
}
-/*************************************************************************
-|* SvMetaModule::WriteSfx()
-*************************************************************************/
void SvMetaModule::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
{
for( ULONG n = 0; n < aClassList.Count(); n++ )
@@ -439,9 +402,6 @@ void SvMetaModule::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaModule::WriteAttributes()
-*************************************************************************/
void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab,
@@ -457,9 +417,6 @@ void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaModule::Write()
-*************************************************************************/
void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -516,7 +473,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
if( pSC )
rOutStm << " : " << pSC->GetName().GetBuffer();
- // Importierte Klassen
+ // imported classes
const SvClassElementMemberList& rClassList = pClass->GetClassList();
if ( rClassList.Count() )
{
@@ -538,7 +495,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
rOutStm << "</CLASSES>" << endl << endl;
- // kein Break!
+ // no break!
}
case WRITE_C_SOURCE:
@@ -547,7 +504,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
for( ULONG n = 0; n < aClassList.Count(); n++ )
{
SvMetaClass * pClass = aClassList.GetObject( n );
- if( !pClass->IsShell() /* && pClass->GetAutomation() */ )
+ if( !pClass->IsShell() )
pClass->Write( rBase, rOutStm, nTab, nT, nA );
}
}
@@ -558,9 +515,6 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaModule::WriteSrc()
-*************************************************************************/
void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
Table * pTable )
{
@@ -572,9 +526,6 @@ void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaModule::WriteHxx()
-*************************************************************************/
void SvMetaModule::WriteHxx( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
@@ -585,9 +536,6 @@ void SvMetaModule::WriteHxx( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaModule::WriteCxx()
-*************************************************************************/
void SvMetaModule::WriteCxx( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
diff --git a/idl/source/objects/object.cxx b/idl/source/objects/object.cxx
index 11f4f7edaa..60e76c659d 100644
--- a/idl/source/objects/object.cxx
+++ b/idl/source/objects/object.cxx
@@ -38,23 +38,12 @@
#include <globals.hxx>
#include <database.hxx>
-/******************** class SvClassElement *******************************/
SV_IMPL_PERSIST1( SvClassElement, SvPersistBase );
-/*************************************************************************
-|* SvClassElement::SvClassElement()
-|*
-|* Beschreibung
-*************************************************************************/
SvClassElement::SvClassElement()
{
};
-/*************************************************************************
-|* SvClassElement::Load()
-|*
-|* Beschreibung
-*************************************************************************/
void SvClassElement::Load( SvPersistStream & rStm )
{
BYTE nMask;
@@ -75,43 +64,27 @@ void SvClassElement::Load( SvPersistStream & rStm )
}
}
-/*************************************************************************
-|* SvClassElement::Save()
-|*
-|* Beschreibung
-*************************************************************************/
void SvClassElement::Save( SvPersistStream & rStm )
{
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aAutomation.IsSet() ) nMask |= 0x1;
if( aPrefix.Len() ) nMask |= 0x2;
if( xClass.Is() ) nMask |= 0x4;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aAutomation;
if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
if( nMask & 0x04 ) rStm << xClass;
}
-/****************** SvMetaClass ******************************************/
SV_IMPL_META_FACTORY1( SvMetaClass, SvMetaType );
-/*************************************************************************
-|* SvMetaClass::SvMetaClass()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaClass::SvMetaClass()
: aAutomation( TRUE, FALSE )
{
}
-/*************************************************************************
-|* SvMetaClass::Load()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::Load( SvPersistStream & rStm )
{
SvMetaType::Load( rStm );
@@ -141,16 +114,11 @@ void SvMetaClass::Load( SvPersistStream & rStm )
if( nMask & 0x10 ) rStm >> aAutomation;
}
-/*************************************************************************
-|* SvMetaClass::Save()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::Save( SvPersistStream & rStm )
{
SvMetaType::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aAttrList.Count() ) nMask |= 0x1;
if( aSuperClass.Is() ) nMask |= 0x2;
@@ -158,7 +126,7 @@ void SvMetaClass::Save( SvPersistStream & rStm )
if( xAutomationInterface.Is() ) nMask |= 0x8;
if( aAutomation.IsSet() ) nMask |= 0x10;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aAttrList;
if( nMask & 0x02 ) rStm << aSuperClass;
@@ -168,11 +136,6 @@ void SvMetaClass::Save( SvPersistStream & rStm )
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaClass::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -180,11 +143,6 @@ void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBase & rBase,
aAutomation.ReadSvIdl( SvHash_Automation(), rInStm );
}
-/*************************************************************************
-|* SvMetaClass::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm, USHORT nTab )
{
@@ -203,11 +161,6 @@ void SvMetaClass::WriteAttributesSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaClass::ReadContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -232,7 +185,7 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
{
if( xAutomationInterface.Is() )
{
- // Fehler setzen
+ // set error
rBase.SetError( "Automation allready set",
rInStm.GetToken() );
rBase.WriteError( rInStm );
@@ -242,14 +195,14 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
}
else
{
- // Fehler setzen
+ // set error
rBase.SetError( "missing ]", rInStm.GetToken() );
rBase.WriteError( rInStm );
}
}
else
{
- // Fehler setzen
+ // set error
rBase.SetError( "only attribute Automation allowed",
rInStm.GetToken() );
rBase.WriteError( rInStm );
@@ -265,7 +218,7 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
}
else
{
- // Fehler setzen
+ // set error
rBase.SetError( "unknown imported interface", rInStm.GetToken() );
rBase.WriteError( rInStm );
}
@@ -307,11 +260,6 @@ void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
rInStm.Seek( nTokPos );
}
-/*************************************************************************
-|* SvMetaClass::WriteContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::WriteContextSvIdl
(
SvIdlDataBase & rBase,
@@ -319,7 +267,6 @@ void SvMetaClass::WriteContextSvIdl
USHORT nTab
)
{
- //SvMetaType::WriteContextSvIdl( rBase, rOutStm, nTab );
ULONG n;
for( n = 0; n < aAttrList.Count(); n++ )
{
@@ -342,11 +289,6 @@ void SvMetaClass::WriteContextSvIdl
}
}
-/*************************************************************************
-|* SvMetaClass::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
{
ULONG nTokPos = rInStm.Tell();
@@ -359,7 +301,7 @@ BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
bOk = aSuperClass.Is();
if( !bOk )
{
- // Fehler setzen
+ // set error
rBase.SetError( "unknown super class",
rInStm.GetToken() );
rBase.WriteError( rInStm );
@@ -377,11 +319,6 @@ BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
return FALSE;
}
-/*************************************************************************
-|* SvMetaClass::TestAttribute()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
SvMetaAttribute & rAttr ) const
{
@@ -396,7 +333,7 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
SvMetaAttribute * pS = aAttrList.GetObject( n );
if( pS->GetName() == rAttr.GetName() )
{
- // Werte muessen uebereinstimmen
+ // values have to match
if( pS->GetSlotId().GetValue() != rAttr.GetSlotId().GetValue() )
{
DBG_ERROR( "Gleicher Name in MetaClass : " );
@@ -416,7 +353,7 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
{
UINT32 nId1 = pS->GetSlotId().GetValue();
UINT32 nId2 = rAttr.GetSlotId().GetValue();
- if( nId1 == nId2 && nId1 != 0 /*&& nId2 != 0 ist ueberfluessig*/ )
+ if( nId1 == nId2 && nId1 != 0 )
{
DBG_ERROR( "Gleiche Id in MetaClass : " );
DBG_ERROR( ByteString::CreateFromInt32( pS->GetSlotId().GetValue() ).GetBuffer() );
@@ -440,11 +377,6 @@ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
return TRUE;
}
-/*************************************************************************
-|* SvMetaClass::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
@@ -456,11 +388,6 @@ void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
rOutStm << endl;
}
-/*************************************************************************
-|* SvMetaClass::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute )
@@ -489,7 +416,7 @@ void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
WriteDescription( rOutStm );
rOutStm << "</INTERFACE>" << endl << endl;
- // alle Attribute schreiben
+ // write all attributes
ULONG n;
for( n = 0; n < aAttrList.Count(); n++ )
{
@@ -511,11 +438,6 @@ void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaClass::WriteSlotParamArray()
-|*
-|* Beschreibung
-*************************************************************************/
USHORT SvMetaClass::WriteSlotParamArray( SvIdlDataBase & rBase,
SvSlotElementList & rSlotList,
SvStream & rOutStm )
@@ -531,11 +453,6 @@ USHORT SvMetaClass::WriteSlotParamArray( SvIdlDataBase & rBase,
return nCount;
}
-/*************************************************************************
-|* SvMetaClass::WriteSlots()
-|*
-|* Beschreibung
-*************************************************************************/
USHORT SvMetaClass::WriteSlots( const ByteString & rShellName,
USHORT nCount, SvSlotElementList & rSlotList,
SvIdlDataBase & rBase,
@@ -555,23 +472,18 @@ USHORT SvMetaClass::WriteSlots( const ByteString & rShellName,
return nSCount;
}
-/*************************************************************************
-|* SvMetaClass::InsertSlots()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList,
SvMetaClassList &rClassList,
const ByteString & rPrefix, SvIdlDataBase& rBase)
{
- // Wurde diese Klasse schon geschrieben ?
+ // was this class already written?
for ( size_t i = 0, n = rClassList.size(); i < n ; ++i )
if ( rClassList[ i ] == this )
return;
rClassList.push_back( this );
- // alle direkten Attribute schreiben
+ // write all direct attributes
ULONG n;
for( n = 0; n < aAttrList.Count(); n++ )
{
@@ -587,22 +499,22 @@ void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList,
if( nPos == rSuperList.Count() )
{
- // nur schreiben, wenn nicht schon bei SubClass oder
- // importiertem Interface geschrieben
+ // Write only if not already written by subclass or
+ // imported interface.
rSuperList.Insert( nId, nPos );
pAttr->Insert(rList, rPrefix, rBase);
}
}
- // Alle schon von SuperShells importierten Interfaces sollen nicht
- // mehr geschrieben werden
- // Es ist also verboten, da\s Shell und SuperShell die gleiche Klasse
- // direkt importieren !
+ // All Interfaces already imported by SuperShells should not be
+ // written any more.
+ // It is prohibited that Shell and SuperShell directly import the same
+ //class.
if( IsShell() && aSuperClass.Is() )
aSuperClass->FillClasses( rClassList );
- // alle Attribute der importierten Klassen schreiben, sofern diese nicht
- // schon von der Superklasse importiert wurden
+ // Write all attributes of the imported classes, as long as they have
+ // not already been imported by the superclass.
for( n = 0; n < aClassList.Count(); n++ )
{
SvClassElement * pEle = aClassList.GetObject( n );
@@ -612,32 +524,27 @@ void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList,
rPre += '.';
rPre += pEle->GetPrefix();
- // Zun"achst die direkt importierten Interfaces schreiben
+ // first of all write direct imported interfaces
pCl->InsertSlots( rList, rSuperList, rClassList, rPre, rBase );
}
- // Superklassen nur schreiben, wenn keine Shell und nicht in der Liste
+ // only write superclass if no shell and not in the list
if( !IsShell() && aSuperClass.Is() )
{
aSuperClass->InsertSlots( rList, rSuperList, rClassList, rPrefix, rBase );
}
}
-/*************************************************************************
-|* SvMetaClass::FillClasses()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::FillClasses( SvMetaClassList & rList )
{
- // Bin ich noch nicht drin ?
+ // Am I not yet in?
for ( size_t i = 0, n = rList.size(); i < n; ++i )
if ( rList[ i ] == this )
return;
rList.push_back( this );
- // Meine Imports
+ // my imports
for( ULONG n = 0; n < aClassList.Count(); n++ )
{
SvClassElement * pEle = aClassList.GetObject( n );
@@ -645,23 +552,18 @@ void SvMetaClass::FillClasses( SvMetaClassList & rList )
pCl->FillClasses( rList );
}
- // Meine Superklasse
+ // my superclass
if( aSuperClass.Is() )
aSuperClass->FillClasses( rList );
}
-/*************************************************************************
-|* SvMetaClass::WriteSlotStubs()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::WriteSlotStubs( const ByteString & rShellName,
SvSlotElementList & rSlotList,
ByteStringList & rList,
SvStream & rOutStm )
{
- // alle Attribute schreiben
+ // write all attributes
for( ULONG n = 0; n < rSlotList.Count(); n++ )
{
SvSlotElement *pEle = rSlotList.GetObject( n );
@@ -670,27 +572,22 @@ void SvMetaClass::WriteSlotStubs( const ByteString & rShellName,
}
}
-/*************************************************************************
-|* SvMetaClass::WriteSfx()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
{
WriteStars( rOutStm );
- // Klasse definieren
+ // define class
rOutStm << "#ifdef " << GetName().GetBuffer() << endl;
rOutStm << "#undef ShellClass" << endl;
rOutStm << "#undef " << GetName().GetBuffer() << endl;
rOutStm << "#define ShellClass " << GetName().GetBuffer() << endl;
- // Fuer Interfaces werden kein Slotmaps geschrieben
+ // no slotmaps get written for interfaces
if( !IsShell() )
{
rOutStm << "#endif" << endl << endl;
return;
}
- // Parameter Array schreiben
+ // write parameter array
rOutStm << "SFX_ARGUMENTMAP(" << GetName().GetBuffer() << ')' << endl
<< '{' << endl;
@@ -707,13 +604,13 @@ void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
ULONG nSlotCount = aSlotList.Count();
- // alle Attribute schreiben
+ // write all attributes
USHORT nArgCount = WriteSlotParamArray( rBase, aSlotList, rOutStm );
if( nArgCount )
Back2Delemitter( rOutStm );
else
{
- // mindestens einen dummy
+ // at leaast one dummy
WriteTab( rOutStm, 1 );
rOutStm << "SFX_ARGUMENT( 0, 0, SfxVoidItem )" << endl;
}
@@ -727,17 +624,17 @@ void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
rOutStm << endl;
- // Slotmap schreiben
+ // write slotmap
rOutStm << "SFX_SLOTMAP_ARG(" << GetName().GetBuffer() << ')' << endl
<< '{' << endl;
- // alle Attribute schreiben
+ // write all attributes
WriteSlots( GetName(), 0, aSlotList, rBase, rOutStm );
if( nSlotCount )
Back2Delemitter( rOutStm );
else
{
- // mindestens einen dummy
+ // at least one dummy
WriteTab( rOutStm, 1 );
rOutStm << "SFX_SLOT_ARG(" << GetName().GetBuffer()
<< ", 0, 0, "
@@ -769,9 +666,6 @@ void SvMetaClass::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaShell::WriteSrc()
-*************************************************************************/
void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
Table * pTable )
{
@@ -782,11 +676,6 @@ void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaClass::WriteHxx()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, USHORT )
{
ByteString aSuperName( "SvDispatch" );
@@ -812,11 +701,6 @@ void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, USHORT )
<< "};" << endl;
}
-/*************************************************************************
-|* SvMetaClass::WriteCxx()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaClass::WriteCxx( SvIdlDataBase &, SvStream & rOutStm, USHORT )
{
ByteString aSuperName( "SvDispatch" );
diff --git a/idl/source/objects/slot.cxx b/idl/source/objects/slot.cxx
index bff0efa183..837d770e2b 100644
--- a/idl/source/objects/slot.cxx
+++ b/idl/source/objects/slot.cxx
@@ -36,7 +36,6 @@
#include <globals.hxx>
#include <database.hxx>
-/****************** SvMetaSlot *****************************************/
SV_IMPL_META_FACTORY1( SvMetaSlot, SvMetaAttribute );
SvMetaObject *SvMetaSlot::MakeClone() const
@@ -44,12 +43,6 @@ SvMetaObject *SvMetaSlot::MakeClone() const
return new SvMetaSlot( *this );
}
-/*************************************************************************
-|* SvMetaSlot::SvMetaSlot()
-|*
-|* Beschreibung Zweites FALSE bei den SvBOOL-Objekten bedeutet,
-|* IsSet() liefert FALSE (Defaultinitialisierung).
-*************************************************************************/
SvMetaSlot::SvMetaSlot()
: aCachable( TRUE, FALSE )
, aSynchron( TRUE, FALSE )
@@ -73,17 +66,6 @@ SvMetaSlot::SvMetaSlot( SvMetaType * pType )
{
}
-/*
-#define TEST_READ \
-{ \
- UINT32 nPos; \
- rStm >> nPos; \
- DBG_ASSERT( nPos +4 == rStm.Tell(), "stream pos error" ); \
-}
-
-#define TEST_WRITE \
- rStm << (UINT32)rStm.Tell();
-*/
#define TEST_READ
#define TEST_WRITE
@@ -188,7 +170,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
{
SvMetaAttribute::Save( rStm );
- // Maske erstellen
+ // create mask
USHORT nMask = 0;
if( aMethod.Is() ) nMask |= 0x0001;
if( aGroupId.Len() ) nMask |= 0x0002;
@@ -207,7 +189,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
if( aSynchron.IsSet() ) nMask |= 0x4000;
if( aAsynchron.IsSet() ) nMask |= 0x8000;
- // Daten schreiben
+ // write data
rStm << nMask;
TEST_WRITE
if( nMask & 0x0001 ) rStm << aMethod;
@@ -242,8 +224,8 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
TEST_WRITE
if( nMask & 0x8000 ) rStm << aAsynchron;
- // naechste Fuhre schreiben
- // Maske erstellen
+ // write next bunch
+ // create mask
nMask = 0;
if( aRecordPerItem.IsSet() ) nMask |= 0x0001;
if( aRecordManual.IsSet() ) nMask |= 0x0002;
@@ -262,7 +244,7 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
if( aRecordAbsolute.IsSet() ) nMask |= 0x4000;
if( aImageRotation.IsSet() ) nMask |= 0x8000;
- // Daten schreiben
+ // write data
rStm << nMask;
TEST_WRITE
if( nMask & 0x0001 ) rStm << aRecordPerItem;
@@ -307,21 +289,11 @@ void SvMetaSlot::Save( SvPersistStream & rStm )
if( nMask & 0x0002 ) rStm << aImageReflection;
}
-/*************************************************************************
-|* SvMetaSlot::IsVariable()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaSlot::IsVariable() const
{
return SvMetaAttribute::IsVariable();
}
-/*************************************************************************
-|* SvMetaSlot::IsMethod()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaSlot::IsMethod() const
{
BOOL b = SvMetaAttribute::IsMethod();
@@ -329,11 +301,6 @@ BOOL SvMetaSlot::IsMethod() const
return b;
}
-/*************************************************************************
-|* SvMetaSlot::HasMethods()
-|*
-|* Beschreibung
-*************************************************************************/
ByteString SvMetaSlot::GetMangleName( BOOL bVariable ) const
{
if( !bVariable )
@@ -346,12 +313,12 @@ ByteString SvMetaSlot::GetMangleName( BOOL bVariable ) const
}
/*************************************************************************
-|* Referenz
+|* reference
|*
-|* Beschreibung Zweites FALSE bei den SvBOOL-Objekten bedeutet,
-|* IsSet() liefert FALSE (Defaultinitialisierung).
+|* description Second FALSE in the SvBOOL-Objects means
+|* IsSet() provides FALSE (default initialization).
*************************************************************************/
-/** Referenz Aufloesung **/
+/** reference disbandment **/
SvMetaType * SvMetaSlot::GetSlotType() const
{
if( aSlotType.Is() || !GetRef() ) return aSlotType;
@@ -402,28 +369,16 @@ BOOL SvMetaSlot::GetPseudoSlots() const
if( aPseudoSlots.IsSet() || !GetRef() ) return aPseudoSlots;
return ((SvMetaSlot *)GetRef())->GetPseudoSlots();
}
-/*
-BOOL SvMetaSlot::GetGet() const
-{
- if( aGet.IsSet() || !GetRef() ) return aGet;
- return ((SvMetaSlot *)GetRef())->GetGet();
-}
-BOOL SvMetaSlot::GetSet() const
-{
- if( aSet.IsSet() || !GetRef() ) return aSet;
- return ((SvMetaSlot *)GetRef())->GetSet();
-}
-*/
BOOL SvMetaSlot::GetCachable() const
{
- // Cachable und Volatile sind exclusiv
+ // Cachable and Volatile are exclusive
if( !GetRef() || aCachable.IsSet() || aVolatile.IsSet() )
return aCachable;
return ((SvMetaSlot *)GetRef())->GetCachable();
}
BOOL SvMetaSlot::GetVolatile() const
{
- // Cachable und Volatile sind exclusiv
+ // Cachable and Volatile are exclusive
if( !GetRef() || aVolatile.IsSet() || aCachable.IsSet() )
return aVolatile;
return ((SvMetaSlot *)GetRef())->GetVolatile();
@@ -440,21 +395,21 @@ BOOL SvMetaSlot::GetAutoUpdate() const
}
BOOL SvMetaSlot::GetSynchron() const
{
- // Synchron und Asynchron sind exclusiv
+ // Synchron and Asynchron are exclusive
if( !GetRef() || aSynchron.IsSet() || aAsynchron.IsSet() )
return aSynchron;
return ((SvMetaSlot *)GetRef())->GetSynchron();
}
BOOL SvMetaSlot::GetAsynchron() const
{
- // Synchron und Asynchron sind exclusiv
+ // Synchron and Asynchron are exclusive
if( !GetRef() || aAsynchron.IsSet() || aSynchron.IsSet() )
return aAsynchron;
return ((SvMetaSlot *)GetRef())->GetAsynchron();
}
BOOL SvMetaSlot::GetRecordPerItem() const
{
- // Record- PerItem, No, PerSet und Manual sind exclusiv
+ // Record- PerItem, No, PerSet and Manual are exclusive
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
return aRecordPerItem;
@@ -462,7 +417,7 @@ BOOL SvMetaSlot::GetRecordPerItem() const
}
BOOL SvMetaSlot::GetRecordPerSet() const
{
- // Record- PerItem, No, PerSet und Manual sind exclusiv
+ // Record- PerItem, No, PerSet and Manual are exclusive
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
return aRecordPerSet;
@@ -470,7 +425,7 @@ BOOL SvMetaSlot::GetRecordPerSet() const
}
BOOL SvMetaSlot::GetRecordManual() const
{
- // Record- PerItem, No, PerSet und Manual sind exclusiv
+ // Record- PerItem, No, PerSet and Manual are exclusive
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
return aRecordManual;
@@ -478,7 +433,7 @@ BOOL SvMetaSlot::GetRecordManual() const
}
BOOL SvMetaSlot::GetNoRecord() const
{
- // Record- PerItem, No, PerSet und Manual sind exclusiv
+ // Record- PerItem, No, PerSet and Manual are exclusive
if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
|| aRecordPerSet.IsSet() || aRecordManual.IsSet() )
return aNoRecord;
@@ -549,48 +504,7 @@ const ByteString& SvMetaSlot::GetUnoName() const
return ((SvMetaSlot *)GetRef())->GetUnoName();
}
-/*************************************************************************
-|* SvMetaSlot::FillSbxObject()
-|*
-|* Beschreibung
-*************************************************************************/
-/*
-void SvMetaSlot::FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj,
- BOOL bVariable )
-{
- // keine Attribut fuer Automation
- if( !GetAutomation() || !GetExport() )
- return;
-
- if( !bVariable )
- {
- SvMetaAttributeRef xM = GetMethod();
- if( xM.Is() )
- {
- SvMetaType * pType = xM->GetType();
- SvMetaType * pRetBaseType = pType->GetReturnType()->GetBaseType();
- ByteString aName = xM->GetName();
-
- SbxMethodRef xMeth = new SbxMethod( aName,
- pRetBaseType->GetSbxDataType() );
- pType->FillSbxObject( xMeth, bVariable );
- xMeth->SetUserData( MakeSlotValue(rBase, FALSE) );
-
- pObj->Insert( &xMeth );
- return;
- }
- }
-
- SvMetaAttribute::FillSbxObject( rBase, pObj, bVariable );
-}
- */
-
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaSlot::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -717,11 +631,6 @@ void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaSlot::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -800,7 +709,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
if( aVolatile )
aOut += aVolatile.GetSvIdlString( SvHash_Volatile() );
else if( !aCachable )
- // wegen Default == TRUE, nur wenn kein anderer gesetzt
+ // because of Default == TRUE, only when no other is set
aOut += aCachable.GetSvIdlString( SvHash_Cachable() );
else
aDel.Erase();
@@ -820,7 +729,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
if( aAsynchron )
( aOut += aDel ) += aAsynchron.GetSvIdlString( SvHash_Asynchron() );
else if( !aSynchron )
- // wegen Default == TRUE, nur wenn kein anderer gesetzt
+ // because of Default == TRUE, only when no other is set
( aOut += aDel ) += aSynchron.GetSvIdlString( SvHash_Synchron() );
else
aDel1 = aDel;
@@ -831,7 +740,7 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
else if( aNoRecord )
( aOut += aDel1 ) += aNoRecord.GetSvIdlString( SvHash_NoRecord() );
else if( !aRecordPerSet )
- // wegen Default == TRUE, nur wenn kein anderer gesetzt
+ // because of Default == TRUE, only when no other is set
( aOut += aDel1 ) += aRecordPerSet.GetSvIdlString( SvHash_RecordPerSet() );
else if( aRecordPerItem )
( aOut += aDel1 ) += aRecordPerItem.GetSvIdlString( SvHash_RecordPerItem() );
@@ -898,11 +807,6 @@ void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase,
}
-/*************************************************************************
-|* SvMetaSlot::Test()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )
{
BOOL bOk = SvMetaAttribute::Test( rBase, rInStm );
@@ -922,11 +826,6 @@ BOOL SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )
return bOk;
}
-/*************************************************************************
-|* SvMetaSlot::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
@@ -935,7 +834,7 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, GetType() );
if( pAttr )
{
- // F"ur Testzwecke: Referenz bei Kurz-Syntax
+ // c
SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr );
if( pKnownSlot )
{
@@ -960,13 +859,13 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
SvMetaAttribute *pAttr2 = rBase.SearchKnownAttr( GetSlotId() );
if( pAttr2 )
{
- // F"ur Testzwecke: Referenz bei kompletter Definition
+ // for testing purposes: reference in case of complete definition
SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr2 );
if( pKnownSlot )
{
SetRef( pKnownSlot );
- // Namen d"urfen abweichen, da mit angegeben
+ // names may differ, because explicitly given
if ( pKnownSlot->GetName() != GetName() )
{
DBG_ERROR("Illegal definition!");
@@ -994,22 +893,12 @@ BOOL SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
return bOk;
}
-/*************************************************************************
-|* SvMetaSlot::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaSlot::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
SvMetaAttribute::WriteSvIdl( rBase, rOutStm, nTab );
}
-/*************************************************************************
-|* SvMetaSlot::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaSlot::Write( SvIdlDataBase & rBase,
SvStream & rOutStm, USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -1021,7 +910,7 @@ void SvMetaSlot::Write( SvIdlDataBase & rBase,
}
else
{
- // keine Attribut fuer Automation
+ // no attribute for Automation
if( !GetAutomation() || !GetExport() )
return;
}
@@ -1045,7 +934,7 @@ void SvMetaSlot::Write( SvIdlDataBase & rBase,
void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix,
SvIdlDataBase& rBase)
{
- // Einf"ugeposition durch bin"are Suche in der SlotListe ermitteln
+ // get insert position through binary search in slotlist
USHORT nId = (USHORT) GetSlotId().GetValue();
USHORT nListCount = (USHORT) rList.Count();
USHORT nPos;
@@ -1099,18 +988,18 @@ void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix,
rList.Insert( new SvSlotElement( this, rPrefix ), nPos );
- // EnumSlots plattklopfen
+ // iron out EnumSlots
SvMetaTypeEnum * pEnum = NULL;
SvMetaType * pBType = GetType()->GetBaseType();
pEnum = PTR_CAST( SvMetaTypeEnum, pBType );
if( GetPseudoSlots() && pEnum && pEnum->Count() )
{
- // Den MasterSlot clonen
+ // clone the MasterSlot
SvMetaSlotRef xEnumSlot;
SvMetaSlot *pFirstEnumSlot = NULL;
for( ULONG n = 0; n < pEnum->Count(); n++ )
{
- // Die SlotId erzeugen
+ // create SlotId
SvMetaEnumValue *enumValue = pEnum->GetObject(n);
ByteString aValName = enumValue->GetName();
ByteString aSId( GetSlotId() );
@@ -1145,24 +1034,24 @@ void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix,
}
}
- // Die Slaves sind kein Master !
+ // The slaves are no master!
xEnumSlot->aPseudoSlots = FALSE;
xEnumSlot->SetEnumValue(enumValue);
if ( !pFirstEnumSlot || xEnumSlot->GetSlotId().GetValue() < pFirstEnumSlot->GetSlotId().GetValue() )
pFirstEnumSlot = xEnumSlot;
- // Den erzeugten Slave ebenfalls einf"ugen
+ // insert the created slave as well
xEnumSlot->Insert( rList, rPrefix, rBase);
- // Die EnumSlots mit dem Master verketten
+ // concatenate the EnumSlots with the master
xEnumSlot->pLinkedSlot = this;
}
- // Master zeigt auf den ersten Slave
+ // master points to the first slave
pLinkedSlot = pFirstEnumSlot;
- // Slaves untereinander verketten
+ // concatenate slaves among themselves
rList.Seek((ULONG)0);
xEnumSlot = pFirstEnumSlot;
SvSlotElement *pEle;
@@ -1181,11 +1070,6 @@ void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix,
}
-/*************************************************************************
-|* SvMetaSlot::WriteSlotMap()
-|*
-|* Beschreibung
-*************************************************************************/
static ByteString MakeSlotName( SvStringHashEntry * pEntry )
{
ByteString aName( "SFX_SLOT_" );
@@ -1258,7 +1142,6 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
if ( !GetExport() && !GetHidden() )
return;
-// BOOL bIsEnumSlot = 0 != rValueName.Len();
BOOL bIsEnumSlot = 0 != pEnumValue;
rOutStm << "// Slot Nr. " << ByteString::CreateFromInt32(nListPos).GetBuffer() << " : ";
@@ -1307,8 +1190,8 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
}
else
{
- // Den n"achsten Slot suchen, der die gleiche StateMethod hat wie ich
- // Die SlotList ist auf den aktuellen Slot geseekt
+ // look for the next slot with the same StateMethod like me
+ // the slotlist is set to the current slot
SvSlotElement * pEle = rSlotList.Next();
pNextSlot = pEle ? &pEle->xSlot : NULL;
while ( pNextSlot )
@@ -1322,9 +1205,8 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
if ( !pNextSlot )
{
- // Es gibt nach mir keinen Slot mehr, der die gleiche ExecMethode
- // hat. Also suche ich den ersten Slot, der diese hatte (das
- // k"onnte auch ich selbst sein)
+ // There is no slot behind me that has the same ExecMethod.
+ // So I search for the first slot with it (could be myself).
pEle = rSlotList.First();
pNextSlot = pEle ? &pEle->xSlot : NULL;
while ( pNextSlot != this )
@@ -1355,7 +1237,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
WriteTab( rOutStm, 4 );
- // ExecMethod schreiben, wenn nicht angegeben, standard Namen
+ // write ExecMethod, with standard name if not specified
if( GetExecMethod().Len() && GetExecMethod() != "NoExec")
rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ','
<< GetExecMethod().GetBuffer() << ')';
@@ -1363,7 +1245,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
rOutStm << "SFX_STUB_PTR_EXEC_NONE";
rOutStm << ',';
- // StateMethod schreiben, wenn nicht angegeben, standard Namen
+ // write StateMethod, with standard name if not specified
if( GetStateMethod().Len() && GetStateMethod() != "NoState")
rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ','
<< GetStateMethod().GetBuffer() << ')';
@@ -1373,7 +1255,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
rOutStm << ',' << endl;
WriteTab( rOutStm, 4 );
- // Flags schreiben
+ // write flags
if( GetHasCoreId() )
rOutStm << MakeSlotName( SvHash_HasCoreId() ).GetBuffer() << '|';
if( GetCachable() )
@@ -1427,7 +1309,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
else
rOutStm << GetDisableFlags().GetBuffer();
- // Attribut Typ schreiben
+ // write attribute type
if( !bIsEnumSlot )
{
rOutStm << ',' << endl;
@@ -1477,7 +1359,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
else
rOutStm << '0';
- // Name f"urs Recording
+ // name for recording
if ( GetExport() )
{
rOutStm << ",\"";
@@ -1492,7 +1374,7 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
else
rOutStm << ", 0, ";
- // Method/Property Flags
+ // Method/Property flags
if( IsMethod() )
rOutStm << "SFX_SLOT_METHOD|";
if( IsVariable() )
@@ -1505,15 +1387,11 @@ void SvMetaSlot::WriteSlot( const ByteString & rShellName, USHORT nCount,
rOutStm << '0';
}
-// if ( GetUnoName().Len() )
{
rOutStm << ",\"";
rOutStm << GetMangleName( FALSE ).GetBuffer();
- //rOutStm << GetUnoName().GetBuffer();
rOutStm << "\"";
}
-// else
-// rOutStm << ", 0";
rOutStm << " )," << endl;
}
@@ -1544,9 +1422,9 @@ USHORT SvMetaSlot::WriteSlotParamArray( SvIdlDataBase & rBase, SvStream & rOutSt
WriteTab( rOutStm, 1 );
rOutStm << "SFX_ARGUMENT("
<< pPar->GetSlotId().GetBuffer() << ',' // SlodId
- // Parameter Name
+ // parameter name
<< "\"" << pPar->GetName().GetBuffer() << "\","
- // Item Name
+ // item name
<< pPType->GetName().GetBuffer() << ")," << endl;
if( !rBase.FindType( pPType, rBase.aUsedTypes ) )
rBase.aUsedTypes.Append( pPType );
@@ -1562,7 +1440,7 @@ USHORT SvMetaSlot::WriteSlotMap( const ByteString & rShellName, USHORT nCount,
SvIdlDataBase & rBase,
SvStream & rOutStm )
{
- // SlotId, wenn nicht angegeben, aus Namen generieren
+ // SlotId, if not specified generate from name
ByteString slotId = GetSlotId();
USHORT nSCount = 0;
@@ -1582,9 +1460,6 @@ USHORT SvMetaSlot::WriteSlotMap( const ByteString & rShellName, USHORT nCount,
return nSCount;
}
-/*************************************************************************
-|* SvMetaSlot::WriteSrc()
-*************************************************************************/
void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
Table * pTable )
{
@@ -1635,7 +1510,7 @@ void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
bIdOk = TRUE;
}
- // wenn Id nicht gefunden, immer schreiben
+ // if id not found, write always
if( !bIdOk || !pTable->IsKeyValid( nSId2 ) )
{
pTable->Insert( nSId2, this );
@@ -1687,7 +1562,7 @@ void SvMetaSlot::WriteHelpId( SvIdlDataBase & rBase, SvStream & rOutStm,
bIdOk = TRUE;
}
- // wenn Id nicht gefunden, immer schreiben
+ // if id not found, write always
if( !bIdOk || !pTable->IsKeyValid( nSId2 ) )
{
pTable->Insert( nSId2, this );
diff --git a/idl/source/objects/types.cxx b/idl/source/objects/types.cxx
index e57a41814e..b0a9730a16 100644
--- a/idl/source/objects/types.cxx
+++ b/idl/source/objects/types.cxx
@@ -38,14 +38,7 @@
#include <globals.hxx>
#include <database.hxx>
-/****************** SvMetaAttribute *************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaAttribute, SvMetaReference );
-/*************************************************************************
-|* SvMetaAttribute::SvMetaAttribute()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaAttribute::SvMetaAttribute()
: aAutomation( TRUE, FALSE )
, aExport( TRUE, FALSE )
@@ -67,12 +60,6 @@ SvMetaAttribute::SvMetaAttribute( SvMetaType * pType )
{
}
-/*************************************************************************
-|* SvMetaAttribute::Load()
-|* SvMetaAttribute::Save()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::Load( SvPersistStream & rStm )
{
SvMetaReference::Load( rStm );
@@ -98,7 +85,7 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
{
SvMetaReference::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aType.Is() ) nMask |= 0x1;
if( aSlotId.IsSet() ) nMask |= 0x2;
@@ -109,7 +96,7 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
if( aReadOnlyDoc.IsSet() ) nMask |= 0x40;
if( aHidden.IsSet() ) nMask |= 0x80;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x1 ) rStm << aType;
if( nMask & 0x2 ) rStm << aSlotId;
@@ -121,59 +108,33 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
if( nMask & 0x80 ) rStm << aHidden;
}
-/*************************************************************************
-|* SvMetaAttribute::GetType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvMetaAttribute::GetType() const
{
if( aType.Is() || !GetRef() ) return aType;
return ((SvMetaAttribute *)GetRef())->GetType();
}
-/*************************************************************************
-|* SvMetaAttribute::GetSlotId()
-|*
-|* Beschreibung
-*************************************************************************/
const SvNumberIdentifier & SvMetaAttribute::GetSlotId() const
{
if( aSlotId.IsSet() || !GetRef() ) return aSlotId;
return ((SvMetaAttribute *)GetRef())->GetSlotId();
}
-/*************************************************************************
-|* SvMetaAttribute::GetReadonly()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetReadonly() const
{
if( aReadonly.IsSet() || !GetRef() ) return aReadonly;
return ((SvMetaAttribute *)GetRef())->GetReadonly();
}
-/*************************************************************************
-|* SvMetaAttribute::GetExport()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetExport() const
{
if( aExport.IsSet() || !GetRef() ) return aExport;
return ((SvMetaAttribute *)GetRef())->GetExport();
}
-/*************************************************************************
-|* SvMetaAttribute::GetHidden()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetHidden() const
{
- // Wenn Export gesetzt wurde, aber Hidden nicht, gilt der Default
- // aHidden = !aExport
+ // when export is set, but hidden is not the default is used
if ( aExport.IsSet() && !aHidden.IsSet() )
return !aExport;
else if( aHidden.IsSet() || !GetRef() )
@@ -182,11 +143,6 @@ BOOL SvMetaAttribute::GetHidden() const
return ((SvMetaAttribute *)GetRef())->GetHidden();
}
-/*************************************************************************
-|* SvMetaAttribute::GetAutomation()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetAutomation() const
{
if( aAutomation.IsSet() || !GetRef() ) return aAutomation;
@@ -216,13 +172,6 @@ BOOL SvMetaAttribute::GetReadOnlyDoc() const
return ((SvMetaSlot *)GetRef())->GetReadOnlyDoc();
}
-/*************************************************************************
-|* SvMetaAttribute::IsMethod()
-|* SvMetaAttribute::IsVariable()
-|* SvMetaAttribute::GetMangleName()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::IsMethod() const
{
SvMetaType * pType = GetType();
@@ -242,11 +191,6 @@ ByteString SvMetaAttribute::GetMangleName( BOOL ) const
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaAttribute::Test()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -260,17 +204,12 @@ BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaAttribute::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
if( !GetType() )
- // Es wurde kein Typ im ctor mitgegeben
+ // no type in ctor passed on
aType = rBase.ReadKnownType( rInStm );
BOOL bOk = FALSE;
if( GetType() )
@@ -298,11 +237,6 @@ BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaAttribute::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteSvIdl
(
SvIdlDataBase & rBase,
@@ -323,11 +257,6 @@ void SvMetaAttribute::WriteSvIdl
TestAndSeekSpaceOnly( rOutStm, nPos );
}
-/*************************************************************************
-|* SvMetaAttribute::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -342,18 +271,13 @@ void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
{
if( GetType()->GetType() == TYPE_METHOD )
{
- // Fehler setzen
+ // set error
rBase.SetError( "Readonly in function attribute", rInStm.GetToken() );
rBase.WriteError( rInStm );
}
}
}
-/*************************************************************************
-|* SvMetaAttribute::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteAttributesSvIdl
(
SvIdlDataBase & rBase,
@@ -363,7 +287,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
{
SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab );
- //aSlotId.WriteSvIdl( SvHash_SlotId(), rOutStm, nTab );
if( !aExport || !aAutomation || aReadonly )
{
WriteTab( rOutStm, nTab );
@@ -407,11 +330,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
}
}
-/*************************************************************************
-|* SvMetaAttribute::WriteParam()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab,
@@ -434,10 +352,7 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
rList.GetObject( i )->WriteParam( rBase, rOutStm, nTab, nT );
if( i+1<nCount )
{
-// if ( nT == WRITE_DOCU )
rOutStm << ',';
-// else
-// rOutStm << ',' << endl;
}
}
}
@@ -470,11 +385,6 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaSlot::WriteSlotId()
-|*
-|* Beschreibung
-*************************************************************************/
ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, BOOL bVar ) const
{
const SvNumberIdentifier & rId = GetSlotId();
@@ -493,11 +403,6 @@ ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, BOOL bVar ) const
return n;
}
-/*************************************************************************
-|* SvMetaSlot::WriteAttributes()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -532,11 +437,6 @@ void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm
}
}
-/*************************************************************************
-|* SvMetaAttribute::WriteCSource()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
BOOL bSet )
{
@@ -544,12 +444,12 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaType * pType = GetType();
SvMetaType * pBaseType = pType->GetBaseType();
- // Bei Set ist der Return immer void
+ // for Set the return is always void
BOOL bVoid = bSet;
if( pBaseType->GetType() == TYPE_METHOD )
bVoid = pBaseType->GetReturnType()->GetBaseType()->GetName() == "void";
- // Methoden/Funktions-Body ausgeben
+ // emit methods/functions body
rOutStm << '{' << endl;
WriteTab( rOutStm, 1 );
@@ -603,7 +503,6 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
{
rOutStm << ", ";
if( IsMethod() )
- // void SetPosSize( C_Object *, C_Rectangle * pRect );
pBaseType->WriteParamNames( rBase, rOutStm, ByteString() );
else if( bSet )
pBaseType->WriteParamNames( rBase, rOutStm, GetName() );
@@ -613,11 +512,6 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
rOutStm << '}' << endl;
}
-/*************************************************************************
-|* SvMetaAttribute::WriteRecursiv_Impl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
SvStream & rOutStm, USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -629,8 +523,7 @@ void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
if ( GetSlotId().Len() )
rBase.aStructSlotId = GetSlotId();
- // Offizielle Hack-Schnittstelle von MM: spezielle Schalter werden "uber
- // die WriteAttribute "ubergeben
+ // offial hack interface by MM: special controls get passed with the WriteAttribute
if ( GetReadonly() )
nA |= WA_READONLY;
@@ -647,16 +540,11 @@ void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
rBase.aStructSlotId = slotId;
}
-/*************************************************************************
-|* SvMetaAttribute::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
{
- // keine Attribut fuer Automation
+ // no attributes for automation
if( nT == WRITE_DOCU )
{
if ( GetHidden() )
@@ -705,15 +593,12 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
{
if( !bVariable && IsMethod() )
{
- ByteString name; // (rBase.GetActModulePrefix());
+ ByteString name;
name += rBase.aIFaceName;
name += GetName();
const char * pName = name.GetBuffer();
- // Beispiel
- // void SetPosSize( C_Object *, C_Rectangle * );
WriteTab( rOutStm, nTab );
pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
-// rOutStm << " SYSCALL";
rOutStm << ' ' << pName;
pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
if( nT == WRITE_C_HEADER )
@@ -725,21 +610,19 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
{
if( nBType == TYPE_STRUCT )
{
- // Zur Hilfe den Namen des Properties als Kommentar ausgeben
+ // for assistance emit the name of the property as acomment
rOutStm << "/* " << GetName().GetBuffer() << " */" << endl;
WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
}
else
{
- // Beispiel
- // void SetValue( C_Object *, USHORT n );
ByteString name = GetName();
BOOL bReadonly = GetReadonly() || ( nA & WA_READONLY );
if ( !bReadonly && !IsMethod() )
{
- // Zuweisung
+ // allocation
WriteTab( rOutStm, nTab );
rOutStm << "void ";
rOutStm << rBase.aIFaceName.GetBuffer()
@@ -754,7 +637,7 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
WriteCSource( rBase, rOutStm, TRUE );
}
- // Zugriff
+ // access
WriteTab( rOutStm, nTab );
pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
rOutStm << ' ';
@@ -777,7 +660,7 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
<< GetName().GetBuffer() << endl
<< endl; // readonly
- // Returntype
+ // return type
SvMetaType* pType2 = GetType();
SvMetaType* pBaseType2 = pType2->GetBaseType();
rOutStm << pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().GetBuffer() << endl;
@@ -785,20 +668,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
DBG_ASSERT( pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().Len(),
"Leerer BasicName" );
- // Syntax
+ // syntax
rOutStm << GetName().GetBuffer();
pType2->WriteMethodArgs( rBase, rOutStm, nTab, nT );
- // C-Returntype
+ // C return type
pBaseType2->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
rOutStm << endl;
- // Bei Methoden auch C-Syntax
+ // for methods also C syntax
rOutStm << "<C-SYNTAX>" << endl;
Write( rBase, rOutStm, 0, WRITE_C_HEADER, nA );
rOutStm << "</C-SYNTAX>" << endl;
- // Description
+ // description
WriteDescription( rOutStm );
rOutStm << "</METHOD>" << endl << endl;
}
@@ -818,20 +701,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
else
rOutStm << endl;
- // Bei properties Type anstelle des return value
+ // for properties type instead of the return value
rOutStm << pBaseType->GetBasicName().GetBuffer() << endl;
DBG_ASSERT( pBaseType->GetBasicName().Len(),
"Leerer BasicName" );
- // Bei properties keine Syntax
+ // for properties no syntax
rOutStm << endl;
- // C-Returntype
+ // C return type
pBaseType->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
rOutStm << endl;
- // Description
+ // description
WriteDescription( rOutStm );
rOutStm << "</PROPERTY>" << endl << endl;
}
@@ -839,11 +722,6 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaAttribute::MakeSfx()
-|*
-|* Beschreibung
-*************************************************************************/
ULONG SvMetaAttribute::MakeSfx( ByteString * pAttrArray )
{
SvMetaType * pType = GetType();
@@ -867,11 +745,6 @@ void SvMetaAttribute::Insert (SvSlotElementList&, const ByteString &, SvIdlDataB
{
}
-/*************************************************************************
-|* SvMetaAttribute::WriteSrc()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteSrc( SvIdlDataBase &, SvStream &, Table * )
{
}
@@ -882,14 +755,7 @@ void SvMetaAttribute::WriteHelpId( SvIdlDataBase &, SvStream &, Table * )
#endif // IDL_COMPILER
-/****************** SvMetaType *************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaType, SvMetaExtern );
-/*************************************************************************
-|* SvMetaType::SvMetaType()
-|*
-|* Beschreibung
-*************************************************************************/
#define CTOR \
: aCall0( CALL_VALUE, FALSE ) \
, aCall1( CALL_VALUE, FALSE ) \
@@ -923,7 +789,6 @@ SvMetaType::SvMetaType( const ByteString & rName,
const ByteString & rBasicPostfix )
CTOR
{
-// aSbxDataType = (int)nT;
SetName( rName );
aSbxName = rSbxName;
aOdlName = rOdlName;
@@ -966,7 +831,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
{
SvMetaExtern::Save( rStm );
- // Maske erstellen
+ // create mask
USHORT nMask = 0;
if( aIn.IsSet() ) nMask |= 0x0001;
if( aOut.IsSet() ) nMask |= 0x0002;
@@ -985,7 +850,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
if( aBasicName.IsSet() ) nMask |= 0x4000;
if( aBasicPostfix.IsSet() ) nMask |= 0x8000;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x0001 ) rStm << aIn;
if( nMask & 0x0002 ) rStm << aOut;
@@ -1003,11 +868,6 @@ void SvMetaType::Save( SvPersistStream & rStm )
if( nMask & 0x8000 ) rStm << aBasicPostfix;
}
-/*************************************************************************
-|* SvMetaType::GetAttrList()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaAttributeMemberList & SvMetaType::GetAttrList() const
{
if( !pAttrList )
@@ -1015,18 +875,12 @@ SvMetaAttributeMemberList & SvMetaType::GetAttrList() const
return *pAttrList;
}
-/*************************************************************************
-|* SvMetaType::SetType()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::SetType( int nT )
{
nType = nT;
if( nType == TYPE_ENUM )
{
aOdlName = "short";
-// aSbxDataType = SbxINTEGER;
}
else if( nType == TYPE_CLASS )
{
@@ -1035,11 +889,6 @@ void SvMetaType::SetType( int nT )
}
}
-/*************************************************************************
-|* SvMetaType::GetBaseType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvMetaType::GetBaseType() const
{
if( GetRef() && GetType() == TYPE_BASE )
@@ -1047,11 +896,6 @@ SvMetaType * SvMetaType::GetBaseType() const
return (SvMetaType *)this;
}
-/*************************************************************************
-|* SvMetaType::GetReturnType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvMetaType::GetReturnType() const
{
DBG_ASSERT( GetType() == TYPE_METHOD, "no method" );
@@ -1059,25 +903,6 @@ SvMetaType * SvMetaType::GetReturnType() const
return (SvMetaType *)GetRef();
}
-/*************************************************************************
-|* SvMetaType::GetSbxDataType()
-|*
-|* Beschreibung
-*************************************************************************/
-/*
-SbxDataType SvMetaType::GetSbxDataType() const
-{
- if( aSbxDataType.IsSet() || !GetRef() )
- return (SbxDataType)(int)aSbxDataType;
- else
- return ((SvMetaType *)GetRef())->GetSbxDataType();
-}
-*/
-/*************************************************************************
-|* SvMetaType::GetBasicName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString& SvMetaType::GetBasicName() const
{
if( aBasicName.IsSet() || !GetRef() )
@@ -1086,17 +911,12 @@ const ByteString& SvMetaType::GetBasicName() const
return ((SvMetaType*)GetRef())->GetBasicName();
}
-/*************************************************************************
-|* SvMetaType::GetBasicPostfix()
-|*
-|* Beschreibung
-*************************************************************************/
ByteString SvMetaType::GetBasicPostfix() const
{
ByteString aRet;
- // MBN und Co wollen immer "As xxx"
+ // MBN and Co always want "As xxx"
{
aRet = " As ";
@@ -1106,11 +926,6 @@ ByteString SvMetaType::GetBasicPostfix() const
return aRet;
}
-/*************************************************************************
-|* SvMetaType::GetIn()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::GetIn() const
{
if( aIn.IsSet() || !GetRef() )
@@ -1119,11 +934,6 @@ BOOL SvMetaType::GetIn() const
return ((SvMetaType *)GetRef())->GetIn();
}
-/*************************************************************************
-|* SvMetaType::GetOut()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::GetOut() const
{
if( aOut.IsSet() || !GetRef() )
@@ -1132,11 +942,6 @@ BOOL SvMetaType::GetOut() const
return ((SvMetaType *)GetRef())->GetOut();
}
-/*************************************************************************
-|* SvMetaType::SetCall0()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::SetCall0( int e )
{
aCall0 = (int)e;
@@ -1153,11 +958,6 @@ void SvMetaType::SetCall0( int e )
}
}
-/*************************************************************************
-|* SvMetaType::GetCall0()
-|*
-|* Beschreibung
-*************************************************************************/
int SvMetaType::GetCall0() const
{
if( aCall0.IsSet() || !GetRef() )
@@ -1166,11 +966,6 @@ int SvMetaType::GetCall0() const
return ((SvMetaType *)GetRef())->GetCall0();
}
-/*************************************************************************
-|* SvMetaType::SetCall1()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::SetCall1( int e )
{
aCall1 = (int)e;
@@ -1187,11 +982,6 @@ void SvMetaType::SetCall1( int e )
}
}
-/*************************************************************************
-|* SvMetaType::GetCall1()
-|*
-|* Beschreibung
-*************************************************************************/
int SvMetaType::GetCall1() const
{
if( aCall1.IsSet() || !GetRef() )
@@ -1200,11 +990,6 @@ int SvMetaType::GetCall1() const
return ((SvMetaType *)GetRef())->GetCall1();
}
-/*************************************************************************
-|* SvMetaType::GetSvName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetSvName() const
{
if( aSvName.IsSet() || !GetRef() )
@@ -1213,11 +998,6 @@ const ByteString & SvMetaType::GetSvName() const
return ((SvMetaType *)GetRef())->GetSvName();
}
-/*************************************************************************
-|* SvMetaType::GetSbxName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetSbxName() const
{
if( aSbxName.IsSet() || !GetRef() )
@@ -1226,11 +1006,6 @@ const ByteString & SvMetaType::GetSbxName() const
return ((SvMetaType *)GetRef())->GetSbxName();
}
-/*************************************************************************
-|* SvMetaType::GetOdlName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetOdlName() const
{
if( aOdlName.IsSet() || !GetRef() )
@@ -1239,11 +1014,6 @@ const ByteString & SvMetaType::GetOdlName() const
return ((SvMetaType *)GetRef())->GetOdlName();
}
-/*************************************************************************
-|* SvMetaType::GetCName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetCName() const
{
if( aCName.IsSet() || !GetRef() )
@@ -1252,11 +1022,6 @@ const ByteString & SvMetaType::GetCName() const
return ((SvMetaType *)GetRef())->GetCName();
}
-/*************************************************************************
-|* SvMetaType::SetName()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pBase )
{
aSvName = rName;
@@ -1268,11 +1033,6 @@ BOOL SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pBase )
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaType::GetString()
-|*
-|* Beschreibung
-*************************************************************************/
ByteString SvMetaType::GetCString() const
{
ByteString out( GetSvName() );
@@ -1287,11 +1047,6 @@ ByteString SvMetaType::GetCString() const
return out;
}
-/*************************************************************************
-|* SvMetaType::ReadHeaderSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1336,12 +1091,8 @@ BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
SetRef( pType );
if( ReadNameSvIdl( rBase, rInStm ) )
{
- /* // um aufwaertskompatibel zu bleiben
- aOdlName = pType->GetOdlName();
- */
if( rInStm.Read( '(' ) )
{
- //DoReadContextSvIdl( rBase, rInStm, ',' );
DoReadContextSvIdl( rBase, rInStm );
if( rInStm.Read( ')' ) )
{
@@ -1369,11 +1120,6 @@ BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaType::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1385,11 +1131,6 @@ BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|* SvMetaType::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteSvIdl
(
SvIdlDataBase & rBase,
@@ -1405,16 +1146,11 @@ void SvMetaType::WriteSvIdl
rOutStm << endl;
SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
- // nichts geschrieben
+ // nothin written
rOutStm.Seek( nOldPos );
rOutStm << ';' << endl;
}
-/*************************************************************************
-|* SvMetaType::WriteContext()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -1434,17 +1170,12 @@ void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaType::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
{
if( nT == WRITE_C_HEADER && nType != TYPE_ENUM )
- // nur enum schreiben
+ // write only enum
return;
ByteString name = GetName();
@@ -1519,11 +1250,6 @@ void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaType::ReadNamesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1532,11 +1258,6 @@ BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaType::WriteHeaderSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -1597,11 +1318,6 @@ void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaType::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1611,11 +1327,6 @@ void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
aOdlName.ReadSvIdl( SvHash_OdlName(), rInStm );
}
-/*************************************************************************
-|* SvMetaType::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -1647,11 +1358,6 @@ void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaType::ReadContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1663,11 +1369,6 @@ void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaType::WriteContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteContextSvIdl
(
SvIdlDataBase & rBase,
@@ -1691,11 +1392,6 @@ void SvMetaType::WriteContextSvIdl
}
}
-/*************************************************************************
-|* SvMetaType::WriteAttributes()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -1703,11 +1399,6 @@ void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaExtern::WriteAttributes( rBase, rOutStm, nTab, nT, nA );
}
-/*************************************************************************
-|* SvMetaType::MakeSfx()
-|*
-|* Beschreibung
-*************************************************************************/
ULONG SvMetaType::MakeSfx( ByteString * pAttrArray )
{
ULONG nC = 0;
@@ -1715,7 +1406,7 @@ ULONG SvMetaType::MakeSfx( ByteString * pAttrArray )
if( GetBaseType()->GetType() == TYPE_STRUCT )
{
ULONG nAttrCount = GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n = 0; n < nAttrCount; n++ )
{
nC += pAttrList->GetObject( n )->MakeSfx( pAttrArray );
@@ -1737,14 +1428,13 @@ void SvMetaType::WriteSfxItem(
ByteString aTypeName = "SfxType";
ByteString aAttrArray;
ULONG nAttrCount = MakeSfx( &aAttrArray );
- //ULONG nAttrCount = GetAttrCount();
ByteString aAttrCount( ByteString::CreateFromInt32( nAttrCount ) );
aTypeName += aAttrCount;
rOutStm << "extern " << aTypeName.GetBuffer()
<< aVarName.GetBuffer() << ';' << endl;
- // Den Implementationsteil schreiben
+ // write the implementation part
rOutStm << "#ifdef SFX_TYPEMAP" << endl
<< aTypeName.GetBuffer() << aVarName.GetBuffer()
<< " = " << endl;
@@ -1754,7 +1444,7 @@ void SvMetaType::WriteSfxItem(
if( nAttrCount )
{
rOutStm << ", { ";
- // Die einzelnen Attribute schreiben
+ // write the single attributes
rOutStm << aAttrArray.GetBuffer();
rOutStm << " }";
}
@@ -1762,11 +1452,6 @@ void SvMetaType::WriteSfxItem(
<< "#endif" << endl << endl;
}
-/*************************************************************************
-|* SvMetaType::WriteSfx()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
{
if( IsItem() )
@@ -1778,18 +1463,12 @@ void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
}
}
-/*************************************************************************
-|* SvMetaType::ReadMethodArgs()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
if( rInStm.Read( '(' ) )
{
- //DoReadContextSvIdl( rBase, rInStm, ',' );
DoReadContextSvIdl( rBase, rInStm );
if( rInStm.Read( ')' ) )
{
@@ -1801,11 +1480,6 @@ BOOL SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|* SvMetaType::WriteMethodArgs()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteMethodArgs
(
SvIdlDataBase & rBase,
@@ -1904,11 +1578,6 @@ void SvMetaType::WriteMethodArgs
}
}
-/*************************************************************************
-|* SvMetaType::WriteTypePrefix()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab, WriteType nT )
{
@@ -2021,11 +1690,6 @@ void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaType::WriteTheType()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab, WriteType nT )
{
@@ -2034,11 +1698,6 @@ void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
WriteMethodArgs( rBase, rOutStm, nTab +2, nT );
}
-/*************************************************************************
-|* SvMetaType::GetParserString()
-|*
-|* Beschreibung
-*************************************************************************/
ByteString SvMetaType::GetParserString() const
{
SvMetaType * pBT = GetBaseType();
@@ -2051,7 +1710,7 @@ ByteString SvMetaType::GetParserString() const
if( TYPE_METHOD == type || TYPE_STRUCT == type )
{
ULONG nAttrCount = GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n = 0; n < nAttrCount; n++ )
{
SvMetaAttribute * pT = pAttrList->GetObject( n );
@@ -2063,11 +1722,6 @@ ByteString SvMetaType::GetParserString() const
return aPStr;
}
-/*************************************************************************
-|* SvMetaType::WriteParamNames()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
SvStream & rOutStm,
const ByteString & rChief )
@@ -2083,15 +1737,11 @@ void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
if( TYPE_METHOD == type || TYPE_STRUCT == type )
{
ULONG nAttrCount = GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n = 0; n < nAttrCount; n++ )
{
SvMetaAttribute * pA = pAttrList->GetObject( n );
- // Fuer Methoden ist rChief immer ""
- ByteString aStr = /*rChief;
- if( aStr.Len() )
- aStr += "->";
- aStr += */pA->GetName();
+ ByteString aStr = pA->GetName();
pA->GetType()->WriteParamNames( rBase, rOutStm, aStr );
if( n +1 < nAttrCount )
rOutStm << ", ";
@@ -2104,16 +1754,7 @@ void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
#endif // IDL_COMPILER
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaTypeString, SvMetaType );
-/*************************************************************************
-|*
-|* SvMetaTypeString::SvMetaTypeString()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaTypeString::SvMetaTypeString()
: SvMetaType( "String", "SbxSTRING", "BSTR", 's', "char *", "String", "$" )
{
@@ -2129,16 +1770,7 @@ void SvMetaTypeString::Save( SvPersistStream & rStm )
SvMetaType::Save( rStm );
}
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaEnumValue, SvMetaName );
-/*************************************************************************
-|*
-|* SvMetaEnumValue::SvMetaEnumValue()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaEnumValue::SvMetaEnumValue()
{
}
@@ -2162,23 +1794,16 @@ void SvMetaEnumValue::Save( SvPersistStream & rStm )
{
SvMetaName::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aEnumValue.Len() ) nMask |= 0x01;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm.WriteByteString( aEnumValue );
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|* SvMetaEnumValue::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2187,25 +1812,11 @@ BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
return TRUE;
}
-/*************************************************************************
-|*
-|* SvMetaEnumValue::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaEnumValue::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, USHORT )
{
rOutStm << GetName().GetBuffer();
}
-/*************************************************************************
-|*
-|* SvMetaEnumValue::Write()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, USHORT,
WriteType nT, WriteAttribute )
{
@@ -2216,16 +1827,7 @@ void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, USHORT,
}
#endif // IDL_COMPILER
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaTypeEnum, SvMetaType );
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::SvMetaTypeEnum()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaTypeEnum::SvMetaTypeEnum()
{
SetBasicName( "Integer" );
@@ -2251,25 +1853,18 @@ void SvMetaTypeEnum::Save( SvPersistStream & rStm )
{
SvMetaType::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aEnumValueList.Count() ) nMask |= 0x01;
if( aPrefix.Len() ) nMask |= 0x02;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aEnumValueList;
if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::ReadContextSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2280,7 +1875,7 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
if( bOk )
{
if( 0 == aEnumValueList.Count() )
- // der Erste
+ // the first
aPrefix = aEnumVal->GetName();
else
{
@@ -2294,13 +1889,6 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
rInStm.Seek( nTokPos );
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -2316,13 +1904,6 @@ void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2337,13 +1918,6 @@ BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
@@ -2353,13 +1927,6 @@ void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
rOutStm << endl;
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::Write()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -2367,11 +1934,6 @@ void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaType::Write( rBase, rOutStm, nTab, nT, nA );
}
-/*************************************************************************
-|* SvMetaTypeEnum::WriteContext()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -2399,16 +1961,7 @@ void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
#endif // IDL_COMPILER
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaTypevoid, SvMetaType );
-/*************************************************************************
-|*
-|* SvMetaTypevoid::SvMetaTypevoid()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaTypevoid::SvMetaTypevoid()
: SvMetaType( "void", "SbxVOID", "void", 'v', "void", "", "" )
{
@@ -2432,8 +1985,7 @@ ByteString SvMetaAttribute::Compare( SvMetaAttribute* pAttr )
{
if ( aType->GetType() == TYPE_METHOD )
{
- // Nur testen, wenn das Attribut eine Methode ist, nicht wenn es
- // eine hat !!
+ // Test only when the attribute is a method not if it has one!
if ( !pAttr->GetType()->GetType() == TYPE_METHOD )
aStr += " IsMethod\n";
else if ( aType->GetReturnType() &&
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-09 13:47:40 +0000