summaryrefslogtreecommitdiff
path: root/idl/source
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
commitab7324559877ca1fd18178e1a41f821d0dfe4be3 (patch)
tree6acd68306d56b68889b549fdd092df23435a4dbf /idl/source
parent2dadfcaeaeb65ba4dd67c82f76db0fd3093207e9 (diff)
Easy hack: idl removed and translated comments
Diffstat (limited to 'idl/source')
-rw-r--r--idl/source/cmptools/char.cxx2
-rw-r--r--idl/source/cmptools/hash.cxx111
-rw-r--r--idl/source/cmptools/lex.cxx110
-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
-rw-r--r--idl/source/prj/command.cxx101
-rw-r--r--idl/source/prj/database.cxx218
-rw-r--r--idl/source/prj/globals.cxx11
-rw-r--r--idl/source/prj/idldll.cxx8
-rw-r--r--idl/source/prj/svidl.cxx13
14 files changed, 251 insertions, 1714 deletions
diff --git a/idl/source/cmptools/char.cxx b/idl/source/cmptools/char.cxx
index 4f3a6f13faa0..95d0ae0ad389 100644
--- a/idl/source/cmptools/char.cxx
+++ b/idl/source/cmptools/char.cxx
@@ -29,7 +29,6 @@
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_idl.hxx"
-/****************** I N C L U D E S **************************************/
#include <ctype.h>
#include <string.h>
@@ -37,7 +36,6 @@
#include <char.hxx>
-/****************** D A T E N ********************************************/
static unsigned char EqualTab[ 256 ] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
diff --git a/idl/source/cmptools/hash.cxx b/idl/source/cmptools/hash.cxx
index b8a6d0464fa1..197999a95e7a 100644
--- a/idl/source/cmptools/hash.cxx
+++ b/idl/source/cmptools/hash.cxx
@@ -29,33 +29,17 @@
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_idl.hxx"
-/****************** I N C L U D E S **************************************/
-// C and C++ Includes.
+// C and C++ includes
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
-// Programmabhngige Includes.
+// program-sensitive includes
#include <hash.hxx>
#include <tools/debug.hxx>
-/****************** C O D E **********************************************/
-/*************************************************************************
-|*
-|* SvStringHashEntry::~SvStringHashEntry()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvStringHashEntry::~SvStringHashEntry() { };
-/*************************************************************************
-|*
-|* SvHashTable::SvHashTable()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvHashTable::SvHashTable( UINT32 nMaxEntries )
{
nMax = nMaxEntries; // set max entries
@@ -64,13 +48,6 @@ SvHashTable::SvHashTable( UINT32 nMaxEntries )
lAsk = 0;
}
-/*************************************************************************
-|*
-|* SvHashTable::~SvHashTable()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvHashTable::~SvHashTable()
{
#ifdef DOS_NIE
@@ -81,13 +58,6 @@ SvHashTable::~SvHashTable()
#endif
}
-/*************************************************************************
-|*
-|* SvHashTable::Test_Insert()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
UINT32 * pInsertPos )
{
@@ -128,14 +98,6 @@ BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
return( FALSE );
}
-/************************************************************************/
-/*************************************************************************
-|*
-|* SvStringHashTable::SvStringHashTable()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
: SvHashTable( nMaxEntries )
{
@@ -145,7 +107,7 @@ SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
#endif
pEntries = new SvStringHashEntry[ nMaxEntries ];
- // RefCount auf eins setzen
+ // set RefCount to one
SvStringHashEntry * pPos, *pEnd;
pPos = pEntries;
pEnd = pEntries + nMaxEntries;
@@ -156,17 +118,10 @@ SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
}
}
-/*************************************************************************
-|*
-|* ~SvStringHashTable::SvStringHashTable()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvStringHashTable::~SvStringHashTable()
{
#ifdef DBG_UTIL
- // RefCount auf eins setzen
+ // set RefCount to one
SvStringHashEntry * pPos, *pEnd;
pPos = pEntries;
pEnd = pEntries + GetMax();
@@ -180,13 +135,6 @@ SvStringHashTable::~SvStringHashTable()
delete [] pEntries;
}
-/*************************************************************************
-|*
-|* SvStringHashTable::HashFunc()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
UINT32 SvStringHashTable::HashFunc( const void * pElement ) const
{
UINT32 nHash = 0; // hash value
@@ -208,13 +156,6 @@ UINT32 SvStringHashTable::HashFunc( const void * pElement ) const
return( nHash );
}
-/*************************************************************************
-|*
-|* SvStringHashTable::GetNearString()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
ByteString SvStringHashTable::GetNearString( const ByteString & rName ) const
{
for( UINT32 i = 0; i < GetMax(); i++ )
@@ -229,13 +170,6 @@ ByteString SvStringHashTable::GetNearString( const ByteString & rName ) const
return ByteString();
}
-/*************************************************************************
-|*
-|* SvStringHashTable::IsEntry()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const
{
if( nIndex >= GetMax() )
@@ -243,13 +177,6 @@ BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const
return pEntries[ nIndex ].HasId();
}
-/*************************************************************************
-|*
-|* SvStringHashTable::Insert()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvStringHashTable::Insert( const ByteString & rName, UINT32 * pIndex )
{
UINT32 nIndex;
@@ -264,26 +191,12 @@ BOOL SvStringHashTable::Insert( const ByteString & rName, UINT32 * pIndex )
return TRUE;
}
-/*************************************************************************
-|*
-|* SvStringHashTable::Test()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvStringHashTable::Test( const ByteString & rName, UINT32 * pPos ) const
{
return ((SvStringHashTable *)this)->SvHashTable::
Test_Insert( &rName, FALSE, pPos );
}
-/*************************************************************************
-|*
-|* SvStringHashTable::Get()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvStringHashEntry * SvStringHashTable::Get( UINT32 nIndex ) const
{
if( IsEntry( nIndex ) )
@@ -291,26 +204,12 @@ SvStringHashEntry * SvStringHashTable::Get( UINT32 nIndex ) const
return( NULL );
}
-/*************************************************************************
-|*
-|* SvStringHashTable::Get()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
StringCompare SvStringHashTable::Compare( const void * pElement,
UINT32 nIndex ) const
{
return ((const ByteString *)pElement)->CompareTo( pEntries[ nIndex ].GetName() );
}
-/*************************************************************************
-|*
-|* SvStringHashTable::FillHashList()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvStringHashTable::FillHashList( SvStringHashList * pList ) const
{
for( UINT32 n = 0; n < GetMax(); n++ )
@@ -318,7 +217,7 @@ void SvStringHashTable::FillHashList( SvStringHashList * pList ) const
if( IsEntry( n ) )
pList->push_back( Get( n ) );
}
- // Hash Reihenfolge, jetzt sortieren
+ // hash order, sort now
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/idl/source/cmptools/lex.cxx b/idl/source/cmptools/lex.cxx
index 4a1cbc2446a8..494091cb6246 100644
--- a/idl/source/cmptools/lex.cxx
+++ b/idl/source/cmptools/lex.cxx
@@ -39,14 +39,6 @@
#include <globals.hxx>
#include <tools/bigint.hxx>
-/****************** SvToken **********************************************/
-/*************************************************************************
-|*
-|* SvToken::Print()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
ByteString SvToken::GetTokenAsString() const
{
ByteString aStr;
@@ -73,7 +65,7 @@ ByteString SvToken::GetTokenAsString() const
aStr = cChar;
break;
case SVTOKEN_RTTIBASE:
- aStr = "RTTIBASE";//(ULONG)pComplexObj;
+ aStr = "RTTIBASE";
break;
case SVTOKEN_EOF:
case SVTOKEN_HASHID:
@@ -83,68 +75,28 @@ ByteString SvToken::GetTokenAsString() const
return aStr;
}
-/*************************************************************************
-|*
-|* SvToken::SvToken()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvToken::SvToken( const SvToken & rObj )
{
nLine = rObj.nLine;
nColumn = rObj.nColumn;
nType = rObj.nType;
aString = rObj.aString;
-/*
- if( SVTOKEN_RTTIBASE = nType )
- {
- pComplexObj = rObj.pComplexObj;
- pComplexObj->AddRef();
- }
- else
-*/
- nLong = rObj.nLong;
+ nLong = rObj.nLong;
}
-/*************************************************************************
-|*
-|* SvToken::operator = ()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvToken & SvToken::operator = ( const SvToken & rObj )
{
if( this != &rObj )
{
-/*
- if( SVTOKEN_RTTIBASE = nType )
- pComplexObj->ReleaseRef();
-*/
nLine = rObj.nLine;
nColumn = rObj.nColumn;
nType = rObj.nType;
aString = rObj.aString;
-/*
- if( SVTOKEN_RTTIBASE = nType )
- {
- pComplexObj = rObj.pComplexObj;
- pComplexObj->AddRef();
- }
- else
-*/
- nLong = rObj.nLong;
+ nLong = rObj.nLong;
}
return *this;
}
-/****************** SvTokenStream ****************************************/
-/*************************************************************************
-|* SvTokenStream::InitCtor()
-|*
-|* Beschreibung
-*************************************************************************/
void SvTokenStream::InitCtor()
{
#ifdef DOS
@@ -163,11 +115,6 @@ void SvTokenStream::InitCtor()
FillTokenList();
}
-/*************************************************************************
-|* SvTokenStream::SvTokenStream()
-|*
-|* Beschreibung
-*************************************************************************/
SvTokenStream::SvTokenStream( const String & rFileName )
: pInStream( new SvFileStream( rFileName, STREAM_STD_READ | STREAM_NOCREATE ) )
, rInStream( *pInStream )
@@ -177,11 +124,6 @@ SvTokenStream::SvTokenStream( const String & rFileName )
InitCtor();
}
-/*************************************************************************
-|* SvTokenStream::SvTokenStream()
-|*
-|* Beschreibung
-*************************************************************************/
SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName )
: pInStream( NULL )
, rInStream( rStream )
@@ -191,11 +133,6 @@ SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName )
InitCtor();
}
-/*************************************************************************
-|* SvTokenStream::~SvTokenStream()
-|*
-|* Beschreibung
-*************************************************************************/
SvTokenStream::~SvTokenStream()
{
delete pInStream;
@@ -207,11 +144,6 @@ SvTokenStream::~SvTokenStream()
}
}
-/*************************************************************************
-|* SvTokenStream::FillTokenList()
-|*
-|* Beschreibung
-*************************************************************************/
void SvTokenStream::FillTokenList()
{
SvToken * pToken = new SvToken();
@@ -243,11 +175,6 @@ void SvTokenStream::FillTokenList()
pCurToken = aTokList.First();
}
-/*************************************************************************
-|* SvTokenStrem::SetCharSet()
-|*
-|* Beschreibung
-*************************************************************************/
void SvTokenStream::SetCharSet( CharSet nSet )
{
nCharSet = nSet;
@@ -259,11 +186,6 @@ void SvTokenStream::SetCharSet( CharSet nSet )
#endif
}
-/*************************************************************************
-|* SvTokeStream::GetNextChar()
-|*
-|* Beschreibung
-*************************************************************************/
int SvTokenStream::GetNextChar()
{
int nChar;
@@ -288,11 +210,6 @@ int SvTokenStream::GetNextChar()
return nChar;
}
-/*************************************************************************
-|* SvTokenStrem::GetNumber()
-|*
-|* Beschreibung
-*************************************************************************/
ULONG SvTokenStream::GetNumber()
{
ULONG l = 0;
@@ -331,18 +248,13 @@ ULONG SvTokenStream::GetNumber()
return( l );
}
-/*************************************************************************
-|* SvTokenStream::MakeToken()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvTokenStream::MakeToken( SvToken & rToken )
{
do
{
if( 0 == c )
c = GetNextChar();
- // Leerzeichen ueberlesen
+ // skip whitespace
while( isspace( c ) || 26 == c )
{
c = GetFastNextChar();
@@ -353,31 +265,26 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )
ULONG nLastLine = nLine;
ULONG nLastColumn = nColumn;
- // Kommentar
+ // comment
if( '/' == c )
{
- // Zeit Optimierung, keine Kommentare
- //ByteString aComment( (char)c );
+ // time optimization, no comments
int c1 = c;
c = GetFastNextChar();
if( '/' == c )
{
while( '\0' != c )
{
- //aComment += (char)c;
c = GetFastNextChar();
}
c = GetNextChar();
rToken.nType = SVTOKEN_COMMENT;
- //rToken.aString = aComment;
}
else if( '*' == c )
{
- //aComment += (char)c;
c = GetFastNextChar();
do
{
- //aComment += (char)c;
while( '*' != c )
{
if( '\0' == c )
@@ -388,17 +295,14 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )
}
else
c = GetFastNextChar();
- //aComment += (char)c;
}
c = GetFastNextChar();
}
while( '/' != c && !IsEof() && ( SVSTREAM_OK == rInStream.GetError() ) );
if( IsEof() || ( SVSTREAM_OK != rInStream.GetError() ) )
return FALSE;
- //aComment += (char)c;
c = GetNextChar();
rToken.nType = SVTOKEN_COMMENT;
- //rToken.aString = aComment;
CalcColumn();
}
else
@@ -416,7 +320,7 @@ BOOL SvTokenStream::MakeToken( SvToken & rToken )
c = GetFastNextChar();
if( '\0' == c )
{
- // Strings auch "uber das Zeilenende hinauslesen
+ // read strings beyond end of line
aStr += '\n';
c = GetNextChar();
if( IsEof() )
diff --git a/idl/source/objects/basobj.cxx b/idl/source/objects/basobj.cxx
index 24c0ef6e02bf..11d57095dce7 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 4a98c8a5a696..0ebadc98c7bb 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 061740e0ee86..77c3b7146cd3 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 5dc03838ef3a..92f8b7445d02 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 4e6f9967566a..bbb34593423a 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 05ddad32055b..0537b69c3d66 100644
--- a/idl/source/objects/types.cxx
+++ b/idl/source/objects/types.cxx
@@ -38,14 +38,7 @@
#include <globals.hxx>
#include <database.hxx>
-/****************** SvMetaAttribute *************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaAttribute, SvMetaReference );
-/*************************************************************************
-|* SvMetaAttribute::SvMetaAttribute()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaAttribute::SvMetaAttribute()
: aAutomation( TRUE, FALSE )
, aExport( TRUE, FALSE )
@@ -67,12 +60,6 @@ SvMetaAttribute::SvMetaAttribute( SvMetaType * pType )
{
}
-/*************************************************************************
-|* SvMetaAttribute::Load()
-|* SvMetaAttribute::Save()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::Load( SvPersistStream & rStm )
{
SvMetaReference::Load( rStm );
@@ -98,7 +85,7 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
{
SvMetaReference::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aType.Is() ) nMask |= 0x1;
if( aSlotId.IsSet() ) nMask |= 0x2;
@@ -109,7 +96,7 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
if( aReadOnlyDoc.IsSet() ) nMask |= 0x40;
if( aHidden.IsSet() ) nMask |= 0x80;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x1 ) rStm << aType;
if( nMask & 0x2 ) rStm << aSlotId;
@@ -121,59 +108,33 @@ void SvMetaAttribute::Save( SvPersistStream & rStm )
if( nMask & 0x80 ) rStm << aHidden;
}
-/*************************************************************************
-|* SvMetaAttribute::GetType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvMetaAttribute::GetType() const
{
if( aType.Is() || !GetRef() ) return aType;
return ((SvMetaAttribute *)GetRef())->GetType();
}
-/*************************************************************************
-|* SvMetaAttribute::GetSlotId()
-|*
-|* Beschreibung
-*************************************************************************/
const SvNumberIdentifier & SvMetaAttribute::GetSlotId() const
{
if( aSlotId.IsSet() || !GetRef() ) return aSlotId;
return ((SvMetaAttribute *)GetRef())->GetSlotId();
}
-/*************************************************************************
-|* SvMetaAttribute::GetReadonly()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetReadonly() const
{
if( aReadonly.IsSet() || !GetRef() ) return aReadonly;
return ((SvMetaAttribute *)GetRef())->GetReadonly();
}
-/*************************************************************************
-|* SvMetaAttribute::GetExport()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetExport() const
{
if( aExport.IsSet() || !GetRef() ) return aExport;
return ((SvMetaAttribute *)GetRef())->GetExport();
}
-/*************************************************************************
-|* SvMetaAttribute::GetHidden()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetHidden() const
{
- // Wenn Export gesetzt wurde, aber Hidden nicht, gilt der Default
- // aHidden = !aExport
+ // when export is set, but hidden is not the default is used
if ( aExport.IsSet() && !aHidden.IsSet() )
return !aExport;
else if( aHidden.IsSet() || !GetRef() )
@@ -182,11 +143,6 @@ BOOL SvMetaAttribute::GetHidden() const
return ((SvMetaAttribute *)GetRef())->GetHidden();
}
-/*************************************************************************
-|* SvMetaAttribute::GetAutomation()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::GetAutomation() const
{
if( aAutomation.IsSet() || !GetRef() ) return aAutomation;
@@ -216,13 +172,6 @@ BOOL SvMetaAttribute::GetReadOnlyDoc() const
return ((SvMetaSlot *)GetRef())->GetReadOnlyDoc();
}
-/*************************************************************************
-|* SvMetaAttribute::IsMethod()
-|* SvMetaAttribute::IsVariable()
-|* SvMetaAttribute::GetMangleName()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::IsMethod() const
{
SvMetaType * pType = GetType();
@@ -242,11 +191,6 @@ ByteString SvMetaAttribute::GetMangleName( BOOL ) const
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaAttribute::Test()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -260,17 +204,12 @@ BOOL SvMetaAttribute::Test( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaAttribute::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
if( !GetType() )
- // Es wurde kein Typ im ctor mitgegeben
+ // no type in ctor passed on
aType = rBase.ReadKnownType( rInStm );
BOOL bOk = FALSE;
if( GetType() )
@@ -298,11 +237,6 @@ BOOL SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaAttribute::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteSvIdl
(
SvIdlDataBase & rBase,
@@ -323,11 +257,6 @@ void SvMetaAttribute::WriteSvIdl
TestAndSeekSpaceOnly( rOutStm, nPos );
}
-/*************************************************************************
-|* SvMetaAttribute::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -342,18 +271,13 @@ void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
{
if( GetType()->GetType() == TYPE_METHOD )
{
- // Fehler setzen
+ // set error
rBase.SetError( "Readonly in function attribute", rInStm.GetToken() );
rBase.WriteError( rInStm );
}
}
}
-/*************************************************************************
-|* SvMetaAttribute::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteAttributesSvIdl
(
SvIdlDataBase & rBase,
@@ -363,7 +287,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
{
SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab );
- //aSlotId.WriteSvIdl( SvHash_SlotId(), rOutStm, nTab );
if( !aExport || !aAutomation || aReadonly )
{
WriteTab( rOutStm, nTab );
@@ -407,11 +330,6 @@ void SvMetaAttribute::WriteAttributesSvIdl
}
}
-/*************************************************************************
-|* SvMetaAttribute::WriteParam()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab,
@@ -434,10 +352,7 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
rList.GetObject( i )->WriteParam( rBase, rOutStm, nTab, nT );
if( i+1<nCount )
{
-// if ( nT == WRITE_DOCU )
rOutStm << ',';
-// else
-// rOutStm << ',' << endl;
}
}
}
@@ -470,11 +385,6 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaSlot::WriteSlotId()
-|*
-|* Beschreibung
-*************************************************************************/
ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, BOOL bVar ) const
{
const SvNumberIdentifier & rId = GetSlotId();
@@ -493,11 +403,6 @@ ULONG SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, BOOL bVar ) const
return n;
}
-/*************************************************************************
-|* SvMetaSlot::WriteAttributes()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -532,11 +437,6 @@ void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm
}
}
-/*************************************************************************
-|* SvMetaAttribute::WriteCSource()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
BOOL bSet )
{
@@ -544,12 +444,12 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaType * pType = GetType();
SvMetaType * pBaseType = pType->GetBaseType();
- // Bei Set ist der Return immer void
+ // for Set the return is always void
BOOL bVoid = bSet;
if( pBaseType->GetType() == TYPE_METHOD )
bVoid = pBaseType->GetReturnType()->GetBaseType()->GetName() == "void";
- // Methoden/Funktions-Body ausgeben
+ // emit methods/functions body
rOutStm << '{' << endl;
WriteTab( rOutStm, 1 );
@@ -603,7 +503,6 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
{
rOutStm << ", ";
if( IsMethod() )
- // void SetPosSize( C_Object *, C_Rectangle * pRect );
pBaseType->WriteParamNames( rBase, rOutStm, ByteString() );
else if( bSet )
pBaseType->WriteParamNames( rBase, rOutStm, GetName() );
@@ -613,11 +512,6 @@ void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
rOutStm << '}' << endl;
}
-/*************************************************************************
-|* SvMetaAttribute::WriteRecursiv_Impl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
SvStream & rOutStm, USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -629,8 +523,7 @@ void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
if ( GetSlotId().Len() )
rBase.aStructSlotId = GetSlotId();
- // Offizielle Hack-Schnittstelle von MM: spezielle Schalter werden "uber
- // die WriteAttribute "ubergeben
+ // offial hack interface by MM: special controls get passed with the WriteAttribute
if ( GetReadonly() )
nA |= WA_READONLY;
@@ -647,16 +540,11 @@ void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
rBase.aStructSlotId = slotId;
}
-/*************************************************************************
-|* SvMetaAttribute::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
{
- // keine Attribut fuer Automation
+ // no attributes for automation
if( nT == WRITE_DOCU )
{
if ( GetHidden() )
@@ -705,15 +593,12 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
{
if( !bVariable && IsMethod() )
{
- ByteString name; // (rBase.GetActModulePrefix());
+ ByteString name;
name += rBase.aIFaceName;
name += GetName();
const char * pName = name.GetBuffer();
- // Beispiel
- // void SetPosSize( C_Object *, C_Rectangle * );
WriteTab( rOutStm, nTab );
pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
-// rOutStm << " SYSCALL";
rOutStm << ' ' << pName;
pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
if( nT == WRITE_C_HEADER )
@@ -725,21 +610,19 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
{
if( nBType == TYPE_STRUCT )
{
- // Zur Hilfe den Namen des Properties als Kommentar ausgeben
+ // for assistance emit the name of the property as acomment
rOutStm << "/* " << GetName().GetBuffer() << " */" << endl;
WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
}
else
{
- // Beispiel
- // void SetValue( C_Object *, USHORT n );
ByteString name = GetName();
BOOL bReadonly = GetReadonly() || ( nA & WA_READONLY );
if ( !bReadonly && !IsMethod() )
{
- // Zuweisung
+ // allocation
WriteTab( rOutStm, nTab );
rOutStm << "void ";
rOutStm << rBase.aIFaceName.GetBuffer()
@@ -754,7 +637,7 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
WriteCSource( rBase, rOutStm, TRUE );
}
- // Zugriff
+ // access
WriteTab( rOutStm, nTab );
pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
rOutStm << ' ';
@@ -777,7 +660,7 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
<< GetName().GetBuffer() << endl
<< endl; // readonly
- // Returntype
+ // return type
SvMetaType* pType2 = GetType();
SvMetaType* pBaseType2 = pType2->GetBaseType();
rOutStm << pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().GetBuffer() << endl;
@@ -785,20 +668,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
DBG_ASSERT( pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().Len(),
"Leerer BasicName" );
- // Syntax
+ // syntax
rOutStm << GetName().GetBuffer();
pType2->WriteMethodArgs( rBase, rOutStm, nTab, nT );
- // C-Returntype
+ // C return type
pBaseType2->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
rOutStm << endl;
- // Bei Methoden auch C-Syntax
+ // for methods also C syntax
rOutStm << "<C-SYNTAX>" << endl;
Write( rBase, rOutStm, 0, WRITE_C_HEADER, nA );
rOutStm << "</C-SYNTAX>" << endl;
- // Description
+ // description
WriteDescription( rOutStm );
rOutStm << "</METHOD>" << endl << endl;
}
@@ -818,20 +701,20 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
else
rOutStm << endl;
- // Bei properties Type anstelle des return value
+ // for properties type instead of the return value
rOutStm << pBaseType->GetBasicName().GetBuffer() << endl;
DBG_ASSERT( pBaseType->GetBasicName().Len(),
"Leerer BasicName" );
- // Bei properties keine Syntax
+ // for properties no syntax
rOutStm << endl;
- // C-Returntype
+ // C return type
pBaseType->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
rOutStm << endl;
- // Description
+ // description
WriteDescription( rOutStm );
rOutStm << "</PROPERTY>" << endl << endl;
}
@@ -839,11 +722,6 @@ void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaAttribute::MakeSfx()
-|*
-|* Beschreibung
-*************************************************************************/
ULONG SvMetaAttribute::MakeSfx( ByteString * pAttrArray )
{
SvMetaType * pType = GetType();
@@ -867,11 +745,6 @@ void SvMetaAttribute::Insert (SvSlotElementList&, const ByteString &, SvIdlDataB
{
}
-/*************************************************************************
-|* SvMetaAttribute::WriteSrc()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaAttribute::WriteSrc( SvIdlDataBase &, SvStream &, Table * )
{
}
@@ -882,14 +755,7 @@ void SvMetaAttribute::WriteHelpId( SvIdlDataBase &, SvStream &, Table * )
#endif // IDL_COMPILER
-/****************** SvMetaType *************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaType, SvMetaExtern );
-/*************************************************************************
-|* SvMetaType::SvMetaType()
-|*
-|* Beschreibung
-*************************************************************************/
#define CTOR \
: aCall0( CALL_VALUE, FALSE ) \
, aCall1( CALL_VALUE, FALSE ) \
@@ -923,7 +789,6 @@ SvMetaType::SvMetaType( const ByteString & rName,
const ByteString & rBasicPostfix )
CTOR
{
-// aSbxDataType = (int)nT;
SetName( rName );
aSbxName = rSbxName;
aOdlName = rOdlName;
@@ -966,7 +831,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
{
SvMetaExtern::Save( rStm );
- // Maske erstellen
+ // create mask
USHORT nMask = 0;
if( aIn.IsSet() ) nMask |= 0x0001;
if( aOut.IsSet() ) nMask |= 0x0002;
@@ -985,7 +850,7 @@ void SvMetaType::Save( SvPersistStream & rStm )
if( aBasicName.IsSet() ) nMask |= 0x4000;
if( aBasicPostfix.IsSet() ) nMask |= 0x8000;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x0001 ) rStm << aIn;
if( nMask & 0x0002 ) rStm << aOut;
@@ -1003,11 +868,6 @@ void SvMetaType::Save( SvPersistStream & rStm )
if( nMask & 0x8000 ) rStm << aBasicPostfix;
}
-/*************************************************************************
-|* SvMetaType::GetAttrList()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaAttributeMemberList & SvMetaType::GetAttrList() const
{
if( !pAttrList )
@@ -1015,18 +875,12 @@ SvMetaAttributeMemberList & SvMetaType::GetAttrList() const
return *pAttrList;
}
-/*************************************************************************
-|* SvMetaType::SetType()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::SetType( int nT )
{
nType = nT;
if( nType == TYPE_ENUM )
{
aOdlName = "short";
-// aSbxDataType = SbxINTEGER;
}
else if( nType == TYPE_CLASS )
{
@@ -1035,11 +889,6 @@ void SvMetaType::SetType( int nT )
}
}
-/*************************************************************************
-|* SvMetaType::GetBaseType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvMetaType::GetBaseType() const
{
if( GetRef() && GetType() == TYPE_BASE )
@@ -1047,11 +896,6 @@ SvMetaType * SvMetaType::GetBaseType() const
return (SvMetaType *)this;
}
-/*************************************************************************
-|* SvMetaType::GetReturnType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvMetaType::GetReturnType() const
{
DBG_ASSERT( GetType() == TYPE_METHOD, "no method" );
@@ -1059,25 +903,6 @@ SvMetaType * SvMetaType::GetReturnType() const
return (SvMetaType *)GetRef();
}
-/*************************************************************************
-|* SvMetaType::GetSbxDataType()
-|*
-|* Beschreibung
-*************************************************************************/
-/*
-SbxDataType SvMetaType::GetSbxDataType() const
-{
- if( aSbxDataType.IsSet() || !GetRef() )
- return (SbxDataType)(int)aSbxDataType;
- else
- return ((SvMetaType *)GetRef())->GetSbxDataType();
-}
-*/
-/*************************************************************************
-|* SvMetaType::GetBasicName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString& SvMetaType::GetBasicName() const
{
if( aBasicName.IsSet() || !GetRef() )
@@ -1086,17 +911,12 @@ const ByteString& SvMetaType::GetBasicName() const
return ((SvMetaType*)GetRef())->GetBasicName();
}
-/*************************************************************************
-|* SvMetaType::GetBasicPostfix()
-|*
-|* Beschreibung
-*************************************************************************/
ByteString SvMetaType::GetBasicPostfix() const
{
ByteString aRet;
- // MBN und Co wollen immer "As xxx"
+ // MBN and Co always want "As xxx"
{
aRet = " As ";
@@ -1106,11 +926,6 @@ ByteString SvMetaType::GetBasicPostfix() const
return aRet;
}
-/*************************************************************************
-|* SvMetaType::GetIn()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::GetIn() const
{
if( aIn.IsSet() || !GetRef() )
@@ -1119,11 +934,6 @@ BOOL SvMetaType::GetIn() const
return ((SvMetaType *)GetRef())->GetIn();
}
-/*************************************************************************
-|* SvMetaType::GetOut()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::GetOut() const
{
if( aOut.IsSet() || !GetRef() )
@@ -1132,11 +942,6 @@ BOOL SvMetaType::GetOut() const
return ((SvMetaType *)GetRef())->GetOut();
}
-/*************************************************************************
-|* SvMetaType::SetCall0()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::SetCall0( int e )
{
aCall0 = (int)e;
@@ -1153,11 +958,6 @@ void SvMetaType::SetCall0( int e )
}
}
-/*************************************************************************
-|* SvMetaType::GetCall0()
-|*
-|* Beschreibung
-*************************************************************************/
int SvMetaType::GetCall0() const
{
if( aCall0.IsSet() || !GetRef() )
@@ -1166,11 +966,6 @@ int SvMetaType::GetCall0() const
return ((SvMetaType *)GetRef())->GetCall0();
}
-/*************************************************************************
-|* SvMetaType::SetCall1()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::SetCall1( int e )
{
aCall1 = (int)e;
@@ -1187,11 +982,6 @@ void SvMetaType::SetCall1( int e )
}
}
-/*************************************************************************
-|* SvMetaType::GetCall1()
-|*
-|* Beschreibung
-*************************************************************************/
int SvMetaType::GetCall1() const
{
if( aCall1.IsSet() || !GetRef() )
@@ -1200,11 +990,6 @@ int SvMetaType::GetCall1() const
return ((SvMetaType *)GetRef())->GetCall1();
}
-/*************************************************************************
-|* SvMetaType::GetSvName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetSvName() const
{
if( aSvName.IsSet() || !GetRef() )
@@ -1213,11 +998,6 @@ const ByteString & SvMetaType::GetSvName() const
return ((SvMetaType *)GetRef())->GetSvName();
}
-/*************************************************************************
-|* SvMetaType::GetSbxName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetSbxName() const
{
if( aSbxName.IsSet() || !GetRef() )
@@ -1226,11 +1006,6 @@ const ByteString & SvMetaType::GetSbxName() const
return ((SvMetaType *)GetRef())->GetSbxName();
}
-/*************************************************************************
-|* SvMetaType::GetOdlName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetOdlName() const
{
if( aOdlName.IsSet() || !GetRef() )
@@ -1239,11 +1014,6 @@ const ByteString & SvMetaType::GetOdlName() const
return ((SvMetaType *)GetRef())->GetOdlName();
}
-/*************************************************************************
-|* SvMetaType::GetCName()
-|*
-|* Beschreibung
-*************************************************************************/
const ByteString & SvMetaType::GetCName() const
{
if( aCName.IsSet() || !GetRef() )
@@ -1252,11 +1022,6 @@ const ByteString & SvMetaType::GetCName() const
return ((SvMetaType *)GetRef())->GetCName();
}
-/*************************************************************************
-|* SvMetaType::SetName()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pBase )
{
aSvName = rName;
@@ -1268,11 +1033,6 @@ BOOL SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pBase )
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|* SvMetaType::GetString()
-|*
-|* Beschreibung
-*************************************************************************/
ByteString SvMetaType::GetCString() const
{
ByteString out( GetSvName() );
@@ -1287,11 +1047,6 @@ ByteString SvMetaType::GetCString() const
return out;
}
-/*************************************************************************
-|* SvMetaType::ReadHeaderSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1336,12 +1091,8 @@ BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
SetRef( pType );
if( ReadNameSvIdl( rBase, rInStm ) )
{
- /* // um aufwaertskompatibel zu bleiben
- aOdlName = pType->GetOdlName();
- */
if( rInStm.Read( '(' ) )
{
- //DoReadContextSvIdl( rBase, rInStm, ',' );
DoReadContextSvIdl( rBase, rInStm );
if( rInStm.Read( ')' ) )
{
@@ -1369,11 +1120,6 @@ BOOL SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaType::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1385,11 +1131,6 @@ BOOL SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|* SvMetaType::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteSvIdl
(
SvIdlDataBase & rBase,
@@ -1405,16 +1146,11 @@ void SvMetaType::WriteSvIdl
rOutStm << endl;
SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
- // nichts geschrieben
+ // nothin written
rOutStm.Seek( nOldPos );
rOutStm << ';' << endl;
}
-/*************************************************************************
-|* SvMetaType::WriteContext()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -1434,17 +1170,12 @@ void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaType::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
{
if( nT == WRITE_C_HEADER && nType != TYPE_ENUM )
- // nur enum schreiben
+ // write only enum
return;
ByteString name = GetName();
@@ -1519,11 +1250,6 @@ void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaType::ReadNamesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1532,11 +1258,6 @@ BOOL SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
return bOk;
}
-/*************************************************************************
-|* SvMetaType::WriteHeaderSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -1597,11 +1318,6 @@ void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaType::ReadAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1611,11 +1327,6 @@ void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
aOdlName.ReadSvIdl( SvHash_OdlName(), rInStm );
}
-/*************************************************************************
-|* SvMetaType::WriteAttributesSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -1647,11 +1358,6 @@ void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaType::ReadContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -1663,11 +1369,6 @@ void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|* SvMetaType::WriteContextSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteContextSvIdl
(
SvIdlDataBase & rBase,
@@ -1691,11 +1392,6 @@ void SvMetaType::WriteContextSvIdl
}
}
-/*************************************************************************
-|* SvMetaType::WriteAttributes()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -1703,11 +1399,6 @@ void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaExtern::WriteAttributes( rBase, rOutStm, nTab, nT, nA );
}
-/*************************************************************************
-|* SvMetaType::MakeSfx()
-|*
-|* Beschreibung
-*************************************************************************/
ULONG SvMetaType::MakeSfx( ByteString * pAttrArray )
{
ULONG nC = 0;
@@ -1715,7 +1406,7 @@ ULONG SvMetaType::MakeSfx( ByteString * pAttrArray )
if( GetBaseType()->GetType() == TYPE_STRUCT )
{
ULONG nAttrCount = GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n = 0; n < nAttrCount; n++ )
{
nC += pAttrList->GetObject( n )->MakeSfx( pAttrArray );
@@ -1737,14 +1428,13 @@ void SvMetaType::WriteSfxItem(
ByteString aTypeName = "SfxType";
ByteString aAttrArray;
ULONG nAttrCount = MakeSfx( &aAttrArray );
- //ULONG nAttrCount = GetAttrCount();
ByteString aAttrCount( ByteString::CreateFromInt32( nAttrCount ) );
aTypeName += aAttrCount;
rOutStm << "extern " << aTypeName.GetBuffer()
<< aVarName.GetBuffer() << ';' << endl;
- // Den Implementationsteil schreiben
+ // write the implementation part
rOutStm << "#ifdef SFX_TYPEMAP" << endl
<< aTypeName.GetBuffer() << aVarName.GetBuffer()
<< " = " << endl;
@@ -1754,7 +1444,7 @@ void SvMetaType::WriteSfxItem(
if( nAttrCount )
{
rOutStm << ", { ";
- // Die einzelnen Attribute schreiben
+ // write the single attributes
rOutStm << aAttrArray.GetBuffer();
rOutStm << " }";
}
@@ -1762,11 +1452,6 @@ void SvMetaType::WriteSfxItem(
<< "#endif" << endl << endl;
}
-/*************************************************************************
-|* SvMetaType::WriteSfx()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
{
if( IsItem() )
@@ -1778,18 +1463,12 @@ void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
}
}
-/*************************************************************************
-|* SvMetaType::ReadMethodArgs()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
if( rInStm.Read( '(' ) )
{
- //DoReadContextSvIdl( rBase, rInStm, ',' );
DoReadContextSvIdl( rBase, rInStm );
if( rInStm.Read( ')' ) )
{
@@ -1801,11 +1480,6 @@ BOOL SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|* SvMetaType::WriteMethodArgs()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteMethodArgs
(
SvIdlDataBase & rBase,
@@ -1904,11 +1578,6 @@ void SvMetaType::WriteMethodArgs
}
}
-/*************************************************************************
-|* SvMetaType::WriteTypePrefix()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab, WriteType nT )
{
@@ -2021,11 +1690,6 @@ void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
}
}
-/*************************************************************************
-|* SvMetaType::WriteTheType()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab, WriteType nT )
{
@@ -2034,11 +1698,6 @@ void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
WriteMethodArgs( rBase, rOutStm, nTab +2, nT );
}
-/*************************************************************************
-|* SvMetaType::GetParserString()
-|*
-|* Beschreibung
-*************************************************************************/
ByteString SvMetaType::GetParserString() const
{
SvMetaType * pBT = GetBaseType();
@@ -2051,7 +1710,7 @@ ByteString SvMetaType::GetParserString() const
if( TYPE_METHOD == type || TYPE_STRUCT == type )
{
ULONG nAttrCount = GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n = 0; n < nAttrCount; n++ )
{
SvMetaAttribute * pT = pAttrList->GetObject( n );
@@ -2063,11 +1722,6 @@ ByteString SvMetaType::GetParserString() const
return aPStr;
}
-/*************************************************************************
-|* SvMetaType::WriteParamNames()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
SvStream & rOutStm,
const ByteString & rChief )
@@ -2083,15 +1737,11 @@ void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
if( TYPE_METHOD == type || TYPE_STRUCT == type )
{
ULONG nAttrCount = GetAttrCount();
- // Die einzelnen Attribute schreiben
+ // write the single attributes
for( ULONG n = 0; n < nAttrCount; n++ )
{
SvMetaAttribute * pA = pAttrList->GetObject( n );
- // Fuer Methoden ist rChief immer ""
- ByteString aStr = /*rChief;
- if( aStr.Len() )
- aStr += "->";
- aStr += */pA->GetName();
+ ByteString aStr = pA->GetName();
pA->GetType()->WriteParamNames( rBase, rOutStm, aStr );
if( n +1 < nAttrCount )
rOutStm << ", ";
@@ -2104,16 +1754,7 @@ void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
#endif // IDL_COMPILER
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaTypeString, SvMetaType );
-/*************************************************************************
-|*
-|* SvMetaTypeString::SvMetaTypeString()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaTypeString::SvMetaTypeString()
: SvMetaType( "String", "SbxSTRING", "BSTR", 's', "char *", "String", "$" )
{
@@ -2129,16 +1770,7 @@ void SvMetaTypeString::Save( SvPersistStream & rStm )
SvMetaType::Save( rStm );
}
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaEnumValue, SvMetaName );
-/*************************************************************************
-|*
-|* SvMetaEnumValue::SvMetaEnumValue()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaEnumValue::SvMetaEnumValue()
{
}
@@ -2162,23 +1794,16 @@ void SvMetaEnumValue::Save( SvPersistStream & rStm )
{
SvMetaName::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aEnumValue.Len() ) nMask |= 0x01;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm.WriteByteString( aEnumValue );
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|* SvMetaEnumValue::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2187,25 +1812,11 @@ BOOL SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
return TRUE;
}
-/*************************************************************************
-|*
-|* SvMetaEnumValue::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaEnumValue::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, USHORT )
{
rOutStm << GetName().GetBuffer();
}
-/*************************************************************************
-|*
-|* SvMetaEnumValue::Write()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, USHORT,
WriteType nT, WriteAttribute )
{
@@ -2216,16 +1827,7 @@ void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, USHORT,
}
#endif // IDL_COMPILER
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaTypeEnum, SvMetaType );
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::SvMetaTypeEnum()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaTypeEnum::SvMetaTypeEnum()
{
SetBasicName( "Integer" );
@@ -2251,25 +1853,18 @@ void SvMetaTypeEnum::Save( SvPersistStream & rStm )
{
SvMetaType::Save( rStm );
- // Maske erstellen
+ // create mask
BYTE nMask = 0;
if( aEnumValueList.Count() ) nMask |= 0x01;
if( aPrefix.Len() ) nMask |= 0x02;
- // Daten schreiben
+ // write data
rStm << nMask;
if( nMask & 0x01 ) rStm << aEnumValueList;
if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::ReadContextSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2280,7 +1875,7 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
if( bOk )
{
if( 0 == aEnumValueList.Count() )
- // der Erste
+ // the first
aPrefix = aEnumVal->GetName();
else
{
@@ -2294,13 +1889,6 @@ void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
rInStm.Seek( nTokPos );
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
SvStream & rOutStm,
USHORT nTab )
@@ -2316,13 +1904,6 @@ void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
}
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::ReadSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
SvTokenStream & rInStm )
{
@@ -2337,13 +1918,6 @@ BOOL SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
return FALSE;
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::WriteSvIdl()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab )
{
@@ -2353,13 +1927,6 @@ void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
rOutStm << endl;
}
-/*************************************************************************
-|*
-|* SvMetaTypeEnum::Write()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -2367,11 +1934,6 @@ void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
SvMetaType::Write( rBase, rOutStm, nTab, nT, nA );
}
-/*************************************************************************
-|* SvMetaTypeEnum::WriteContext()
-|*
-|* Beschreibung
-*************************************************************************/
void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
USHORT nTab,
WriteType nT, WriteAttribute nA )
@@ -2399,16 +1961,7 @@ void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
#endif // IDL_COMPILER
-/************************************************************************/
-/************************************************************************/
SV_IMPL_META_FACTORY1( SvMetaTypevoid, SvMetaType );
-/*************************************************************************
-|*
-|* SvMetaTypevoid::SvMetaTypevoid()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaTypevoid::SvMetaTypevoid()
: SvMetaType( "void", "SbxVOID", "void", 'v', "void", "", "" )
{
@@ -2432,8 +1985,7 @@ ByteString SvMetaAttribute::Compare( SvMetaAttribute* pAttr )
{
if ( aType->GetType() == TYPE_METHOD )
{
- // Nur testen, wenn das Attribut eine Methode ist, nicht wenn es
- // eine hat !!
+ // Test only when the attribute is a method not if it has one!
if ( !pAttr->GetType()->GetType() == TYPE_METHOD )
aStr += " IsMethod\n";
else if ( aType->GetReturnType() &&
diff --git a/idl/source/prj/command.cxx b/idl/source/prj/command.cxx
index 0f7e422c1dbf..5e85fe86ca4b 100644
--- a/idl/source/prj/command.cxx
+++ b/idl/source/prj/command.cxx
@@ -39,11 +39,6 @@
#include <database.hxx>
#include <tools/fsys.hxx>
-/*************************************************************************
-|*
-|* Syntaxbeschreibung
-|*
-*************************************************************************/
char const * SyntaxStrings[] = {
"basic-type:",
"\tvoid| char| int| float| double|",
@@ -91,7 +86,6 @@ char const * SyntaxStrings[] = {
"\t\tAccelConfig, MenuConfig, StatusBarConfig, ToolbarConfig",
"\t\tAutomation*",
"\t\tAutoUpdate",
-// "\t\tCachable*, Volatile",
"\t\tContainer",
"\t\tDefault = Identifier",
"\t\tExecMethod = Identifier",
@@ -134,11 +128,6 @@ char CommandLineSyntax[] =
"-help, ? @<file> response file\n"
" <filenames>\n";
-/*************************************************************************
-|*
-|* Init()
-|*
-*************************************************************************/
void Init()
{
if( !IDLAPP->pHashTable )
@@ -147,25 +136,11 @@ void Init()
IDLAPP->pGlobalNames = new SvGlobalHashNames();
}
-/*************************************************************************
-|*
-|* DeInit()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void DeInit()
{
delete IDLAPP;
}
-/*************************************************************************
-|*
-|* DeInit()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL ReadIdl( SvIdlWorkingBase * pDataBase, const SvCommand & rCommand )
{
for( size_t n = 0; n < rCommand.aInFileList.size(); ++n )
@@ -204,21 +179,14 @@ BOOL ReadIdl( SvIdlWorkingBase * pDataBase, const SvCommand & rCommand )
return TRUE;
}
-/*************************************************************************
-|*
-|* SvCommand::SvCommand()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
static BOOL ResponseFile( StringList * pList, int argc, char ** argv )
{
- // Programmname
+ // program name
pList->push_back( new String( String::CreateFromAscii(*argv) ) );
for( int i = 1; i < argc; i++ )
{
if( '@' == **(argv +i) )
- { // wenn @, dann Response-Datei
+ { // when @, then response file
SvFileStream aStm( String::CreateFromAscii((*(argv +i)) +1), STREAM_STD_READ | STREAM_NOCREATE );
if( aStm.GetError() != SVSTREAM_OK )
return FALSE;
@@ -246,11 +214,6 @@ static BOOL ResponseFile( StringList * pList, int argc, char ** argv )
return TRUE;
}
-/*************************************************************************
-|* SvCommand::SvCommand()
-|*
-|* Beschreibung
-*************************************************************************/
SvCommand::SvCommand( int argc, char ** argv )
: nVerbosity(1), nFlags( 0 )
{
@@ -271,67 +234,58 @@ SvCommand::SvCommand( int argc, char ** argv )
aFirstChar = aParam.GetChar(0);
String aName( aParam.Copy( 1 ) );
if( 's' == aFirstChar )
- { // Name der Slot-Ausgabe
+ { // name of slot output
aSlotMapFile = aName;
}
else if( 'l' == aFirstChar )
- { // Name der Listing
+ { // name of listing
aListFile = aName;
}
else if( 'i' == aFirstChar )
- { // Name der Item-Datei
-// aSfxItemFile = aName;
+ {
}
else if( 'o' == aFirstChar )
- { // Name der ODL-Datei
-// aODLFile = aName;
+ {
}
else if( 'd' == aFirstChar )
- { // Name der Datenbasis-Datei
+ { // name of data set file
aDataBaseFile = aName;
}
else if( 'D' == aFirstChar )
- { // Name der Docu-Datei f"ur das API
-// aDocuFile = aName;
+ {
}
else if( 'C' == aFirstChar )
- { // Name der cxx-Datei
-// aCxxFile = aName;
+ {
}
else if( 'H' == aFirstChar )
- { // Name der hxx-Datei
-// aHxxFile = aName;
+ {
}
else if( 'c' == aFirstChar )
- { // Name der C-Header-Datei
-// aCSourceFile = aName;
+ {
}
else if( 'h' == aFirstChar )
- { // Name der C-Header-Datei
-// aCHeaderFile = aName;
+ {
}
else if( 't' == aFirstChar )
- { // Name der Info-Datei
-// aCallingFile = aName;
+ {
}
else if( 'm' == aFirstChar )
- { // Name der Info-Datei
+ { // name of info file
aTargetFile = aName;
}
else if( 'r' == aFirstChar )
- { // Name der Resource-Datei
-// aSrcFile = aName;
+ {
}
else if( 'z' == aFirstChar )
- { // Name der HelpId-Datei
+ { // name of HelpId file
aHelpIdFile = aName;
}
else if( 'y' == aFirstChar )
- { // Name der CSV-Datei
+ { // name of CSV file
aCSVFile = aName;
}
else if( 'x' == aFirstChar )
- { // Name der IDL-Datei fuer die CSV-Datei
+ { // name of IDL file for the CSV file
aExportFile = aName;
}
else
@@ -344,7 +298,7 @@ SvCommand::SvCommand( int argc, char ** argv )
}
}
else if( aParam.EqualsIgnoreCaseAscii( "help" ) || aParam.EqualsIgnoreCaseAscii( "?" ) )
- { // Hilfe
+ { // help
printf( "%s", CommandLineSyntax );
}
else if( aParam.EqualsIgnoreCaseAscii( "quiet" ) )
@@ -356,20 +310,20 @@ SvCommand::SvCommand( int argc, char ** argv )
nVerbosity = 2;
}
else if( aParam.EqualsIgnoreCaseAscii( "syntax" ) )
- { // Hilfe
+ { // help
int j = 0;
while(SyntaxStrings[j])
printf("%s\n",SyntaxStrings[j++]);
}
else if( aParam.EqualsIgnoreCaseAscii( "i", 0, 1 ) )
- { // Include-Pfade definieren
+ { // define include paths
String aName( aParam.Copy( 1 ) );
if( aPath.Len() )
aPath += DirEntry::GetSearchDelimiter();
aPath += aName;
}
else if( aParam.EqualsIgnoreCaseAscii( "rsc", 0, 3 ) )
- { // erste Zeile im *.srs File
+ { // first line in *.srs file
if( aList[ i + 1 ] )
{
aSrsLine = ByteString( *aList[ i +1 ], RTL_TEXTENCODING_UTF8 );
@@ -401,7 +355,7 @@ SvCommand::SvCommand( int argc, char ** argv )
aList.clear();
ByteString aInc( getenv( "INCLUDE" ) );
- // Include Environmentvariable anhaengen
+ // append include environment variable
if( aInc.Len() )
{
if( aPath.Len() )
@@ -410,16 +364,9 @@ SvCommand::SvCommand( int argc, char ** argv )
}
}
-/*************************************************************************
-|*
-|* SvCommand::~SvCommand()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvCommand::~SvCommand()
{
- // ByteString Liste freigeben
+ // release ByteString list
for ( size_t i = 0, n = aInFileList.size(); i < n; ++i )
delete aInFileList[ i ];
aInFileList.clear();
diff --git a/idl/source/prj/database.cxx b/idl/source/prj/database.cxx
index 591458983536..81b2620bf5f2 100644
--- a/idl/source/prj/database.cxx
+++ b/idl/source/prj/database.cxx
@@ -37,12 +37,6 @@
#include <database.hxx>
#include <globals.hxx>
-/****************** SvIdlDataBase ****************************************/
-/*************************************************************************
-|* SvIdlDataBase::SvIdlDataBase()
-|*
-|* Beschreibung
-*************************************************************************/
SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
: bExport( FALSE )
, nUniqueId( 0 )
@@ -53,11 +47,6 @@ SvIdlDataBase::SvIdlDataBase( const SvCommand& rCmd )
{
}
-/*************************************************************************
-|* SvIdlDataBase::~SvIdlDataBase()
-|*
-|* Beschreibung
-*************************************************************************/
SvIdlDataBase::~SvIdlDataBase()
{
for ( size_t i = 0, n = aIdFileList.size(); i < n; ++i )
@@ -67,11 +56,6 @@ SvIdlDataBase::~SvIdlDataBase()
delete pIdTable;
}
-/*************************************************************************
-|* SvIdlDataBase::GetTypeList()
-|*
-|* Beschreibung
-*************************************************************************/
#define ADD_TYPE( Name, OdlName, ParserChar, CName, BasName, BasPost ) \
aTypeList.Append( new SvMetaType( SvHash_##Name()->GetName(), \
BasName, OdlName, ParserChar, CName, BasName, BasPost ) );
@@ -79,11 +63,11 @@ SvIdlDataBase::~SvIdlDataBase()
SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
{
if( aTypeList.Count() == 0 )
- { // Initial fuellen
+ { // fill initially
aTypeList.Append( new SvMetaTypeString() );
aTypeList.Append( new SvMetaTypevoid() );
- // MI: IDispatch::Invoke kann keine unsigned
+ // MI: IDispatch::Invoke can not unsigned
ADD_TYPE( UINT16, "long", 'h', "unsigned short", "Long", "&" );
ADD_TYPE( INT16, "short", 'h', "short", "Integer", "%" );
ADD_TYPE( UINT32, "long", 'l', "unsigned long", "Long", "&" );
@@ -96,27 +80,12 @@ SvMetaTypeMemberList & SvIdlDataBase::GetTypeList()
ADD_TYPE( double, "double", 'F', "double", "Double", "#" );
ADD_TYPE( SbxObject, "VARIANT", 'o', "C_Object", "Object", "" );
- // A c h t u n g !!!, bei hinzufuegen von Typen werden alle
- // binren Datenbasen inkompatibel
-
- /*
- // So tun als ob die Init-Daten auf einem Stream gelesen wurden
- SvMemoryStream aStm;
- aPersStream.SetStream( &aStm );
- // Alle Init-Daten Streamen
- aPersStream << aTypeList;
- // Nur die Id-Zuordnung merken
- aPersStream.SetStream( NULL );
- */
+ // Attention! When adding types all binary data bases get incompatible
+
}
return aTypeList;
}
-/*************************************************************************
-|*
-|* SvIdlDataBase::GetModuleInfo()
-|*
-*************************************************************************/
SvMetaModule * SvIdlDataBase::GetModule( const ByteString & rName )
{
for( ULONG n = 0; n < aModuleList.Count(); n++ )
@@ -125,13 +94,6 @@ SvMetaModule * SvIdlDataBase::GetModule( const ByteString & rName )
return NULL;
}
-/*************************************************************************
-|*
-|* SvIdlDataBase::IsBinaryFormat()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
#define DATABASE_SIGNATURE (UINT32)0x13B799F2
#define DATABASE_VER 0x0006
BOOL SvIdlDataBase::IsBinaryFormat( SvStream & rStm )
@@ -144,13 +106,6 @@ BOOL SvIdlDataBase::IsBinaryFormat( SvStream & rStm )
return nSig == DATABASE_SIGNATURE;
}
-/*************************************************************************
-|*
-|* SvIdlDataBase::Load()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
void SvIdlDataBase::Load( SvStream & rStm )
{
DBG_ASSERT( aTypeList.Count() == 0, "type list already initialized" );
@@ -181,11 +136,6 @@ void SvIdlDataBase::Load( SvStream & rStm )
aPStm.SetError( SVSTREAM_GENERALERROR );
}
-/*************************************************************************
-|* SvIdlDataBase::Save()
-|*
-|* Beschreibung
-*************************************************************************/
void SvIdlDataBase::Save( SvStream & rStm, UINT32 nFlags )
{
SvPersistStream aPStm( *IDLAPP->pClassMgr, &rStm );
@@ -212,18 +162,12 @@ void SvIdlDataBase::Save( SvStream & rStm, UINT32 nFlags )
else
aPStm << aClassList;
- //aClassList.WriteObjects( aPStm, bOnlyStreamedObjs );
aTypeList.WriteObjects( aPStm, bOnlyStreamedObjs );
aAttrList.WriteObjects( aPStm, bOnlyStreamedObjs );
aModuleList.WriteObjects( aPStm, bOnlyStreamedObjs );
aPStm << nUniqueId;
}
-/*************************************************************************
-|* SvIdlDataBase::SetError()
-|*
-|* Beschreibung
-*************************************************************************/
void SvIdlDataBase::SetError( const ByteString & rError, SvToken * pTok )
{
if( pTok->GetLine() > 10000 )
@@ -237,24 +181,12 @@ void SvIdlDataBase::SetError( const ByteString & rError, SvToken * pTok )
}
}
-/*************************************************************************
-|* SvIdlDataBase::Push()
-|*
-|* Beschreibung
-*************************************************************************/
void SvIdlDataBase::Push( SvMetaObject * pObj )
{
GetStack().Push( pObj );
}
#ifdef IDL_COMPILER
-/*************************************************************************
-|*
-|* SvIdlDataBase::FindId()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvIdlDataBase::FindId( const ByteString & rIdName, ULONG * pVal )
{
if( pIdTable )
@@ -269,13 +201,6 @@ BOOL SvIdlDataBase::FindId( const ByteString & rIdName, ULONG * pVal )
return FALSE;
}
-/*************************************************************************
-|*
-|* SvIdlDataBase::InsertId()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
BOOL SvIdlDataBase::InsertId( const ByteString & rIdName, ULONG nVal )
{
if( !pIdTable )
@@ -290,11 +215,6 @@ BOOL SvIdlDataBase::InsertId( const ByteString & rIdName, ULONG nVal )
return FALSE;
}
-/*************************************************************************
-|* SvIdlDataBase::ReadIdFile()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
{
DirEntry aFullName( rFileName );
@@ -325,7 +245,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
else
{
ByteString aStr( "unexpected token after define" );
- // Fehler setzen
+ // set error
SetError( aStr, pTok );
WriteError( aTokStm );
return FALSE;
@@ -357,7 +277,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
ByteString aStr( "unknown operator '" );
aStr += pTok->GetChar();
aStr += "'in define";
- // Fehler setzen
+ // set error
SetError( aStr, pTok );
WriteError( aTokStm );
return FALSE;
@@ -365,8 +285,8 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
if( pTok->GetChar() != '+'
&& pTok->GetChar() != '('
&& pTok->GetChar() != ')' )
- // nur + erlaubt, Klammern spielen kein Rolle,
- // da + komutativ ist
+ // only + is allowed, parentheses are immaterial
+ // because + is commutative
break;
}
else if( pTok->IsInteger() )
@@ -405,7 +325,7 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
if( pTok->IsEof() )
{
ByteString aStr( "unexpected eof in #include" );
- // Fehler setzen
+ // set error
SetError( aStr, pTok );
WriteError( aTokStm );
return FALSE;
@@ -430,11 +350,6 @@ BOOL SvIdlDataBase::ReadIdFile( const String & rFileName )
return TRUE;
}
-/*************************************************************************
-|* SvIdlDataBase::FindType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvIdlDataBase::FindType( const SvMetaType * pPType,
SvMetaTypeMemberList & rList )
{
@@ -452,25 +367,20 @@ SvMetaType * SvIdlDataBase::FindType( const ByteString & rName )
return pType;
}
-/*************************************************************************
-|* SvIdlDataBase::ReadKnownType()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
{
BOOL bIn = FALSE;
BOOL bOut = FALSE;
int nCall0 = CALL_VALUE;
int nCall1 = CALL_VALUE;
- BOOL bSet = FALSE; //irgent ein Attribut gesetzt
+ BOOL bSet = FALSE; // any attribute set
UINT32 nTokPos = rInStm.Tell();
SvToken * pTok = rInStm.GetToken_Next();
if( pTok->HasHash() )
{
- UINT32 nBeginPos = 0; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos = 0; // can not happen with Tell
while( nBeginPos != rInStm.Tell() )
{
nBeginPos = rInStm.Tell();
@@ -529,7 +439,7 @@ SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
}
if( !bSet )
- // Ist genau dieser Typ
+ // is exactly this type
return pType;
DBG_ASSERT( aTmpTypeList.First(), "mindestens ein Element" );
@@ -548,18 +458,11 @@ SvMetaType * SvIdlDataBase::ReadKnownType( SvTokenStream & rInStm )
return NULL;
}
-/*************************************************************************
-|*
-|* SvIdlDataBase::ReadKnownAttr()
-|*
-|* Beschreibung
-|*
-*************************************************************************/
SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
(
SvTokenStream & rInStm,
- SvMetaType * pType /* Wenn der pType == NULL, dann muss der Typ
- noch gelesen werden. */
+ SvMetaType * pType /* If pType == NULL, then the type has
+ still to be read. */
)
{
UINT32 nTokPos = rInStm.Tell();
@@ -569,7 +472,7 @@ SvMetaAttribute * SvIdlDataBase::ReadKnownAttr
if( !pType )
{
- // sonst SlotId?
+ // otherwise SlotId?
SvToken * pTok = rInStm.GetToken_Next();
if( pTok->IsIdentifier() )
{
@@ -613,11 +516,6 @@ SvMetaAttribute* SvIdlDataBase::SearchKnownAttr
return NULL;
}
-/*************************************************************************
-|* SvIdlDataBase::ReadKnownClass()
-|*
-|* Beschreibung
-*************************************************************************/
SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
{
UINT32 nTokPos = rInStm.Tell();
@@ -635,11 +533,6 @@ SvMetaClass * SvIdlDataBase::ReadKnownClass( SvTokenStream & rInStm )
return NULL;
}
-/*************************************************************************
-|* SvIdlDataBase::Write()
-|*
-|* Beschreibung
-*************************************************************************/
void SvIdlDataBase::Write( const ByteString & rText )
{
#ifndef W31
@@ -648,36 +541,26 @@ void SvIdlDataBase::Write( const ByteString & rText )
#endif
}
-/*************************************************************************
-|* SvIdlDataBase::WriteError()
-|*
-|* Beschreibung
-*************************************************************************/
void SvIdlDataBase::WriteError( const ByteString & rErrWrn,
const ByteString & rFileName,
const ByteString & rErrorText,
ULONG nRow, ULONG nColumn ) const
{
- //Fehlerbehandlung
+ // error treatment
#ifndef W31
fprintf( stderr, "\n%s --- %s: ( %ld, %ld )\n",
rFileName.GetBuffer(), rErrWrn.GetBuffer(), nRow, nColumn );
if( rErrorText.Len() )
- { // Fehler gesetzt
+ { // error set
fprintf( stderr, "\t%s\n", rErrorText.GetBuffer() );
}
#endif
}
-/*************************************************************************
-|* SvIdlDataBase::WriteError()
-|*
-|* Beschreibung
-*************************************************************************/
void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
{
- //Fehlerbehandlung
+ // error treatment
#ifndef W31
String aFileName( rInStm.GetFileName() );
ByteString aErrorText;
@@ -686,14 +569,14 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
rInStm.SeekEnd();
SvToken *pTok = rInStm.GetToken();
- // Fehlerposition
+ // error position
nRow = pTok->GetLine();
nColumn = pTok->GetColumn();
if( aError.IsError() )
- { // Fehler gesetzt
- // Fehler Token suchen
- // Fehlertext
+ { // error set
+ // search error token
+ // error text
if( aError.GetText().Len() )
{
aErrorText = "may be <";
@@ -709,14 +592,14 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
pTok = rInStm.GetToken_PrevAll();
}
- // Fehlerposition
+ // error position
aErrorText += "> at ( ";
aErrorText += ByteString::CreateFromInt64(aError.nLine);
aErrorText += ", ";
aErrorText += ByteString::CreateFromInt64(aError.nColumn);
aErrorText += " )";
- // Fehler zuruecksetzen
+ // reset error
aError = SvIdlError();
}
@@ -726,7 +609,7 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
if( !pTok )
return;
- // Identifier in der Naehe suchen
+ // look for identifier close by
if( !pTok->IsIdentifier() )
{
rInStm.GetToken_PrevAll();
@@ -741,28 +624,17 @@ void SvIdlDataBase::WriteError( SvTokenStream & rInStm )
#endif
}
-/****************** SvIdlWorkingBase ****************************************/
-/*************************************************************************
-|* SvIdlWorkingBase::SvIdlWorkingBase()
-|*
-|* Beschreibung
-*************************************************************************/
SvIdlWorkingBase::SvIdlWorkingBase(const SvCommand& rCmd) : SvIdlDataBase(rCmd)
{
}
-/*************************************************************************
-|* SvIdlWorkingBase::ReadSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const String & rPath )
{
- aPath = rPath; // nur fuer den durchlauf gueltig
+ aPath = rPath; // only valid for this iteration
SvToken * pTok;
BOOL bOk = TRUE;
pTok = rInStm.GetToken();
- // nur ein import ganz am Anfang
+ // only one import at the very beginning
if( pTok->Is( SvHash_import() ) )
{
rInStm.GetToken_Next();
@@ -802,7 +674,7 @@ BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const
bOk = FALSE;
}
- UINT32 nBeginPos = 0xFFFFFFFF; // kann mit Tell nicht vorkommen
+ UINT32 nBeginPos = 0xFFFFFFFF; // can not happen with Tell
while( bOk && nBeginPos != rInStm.Tell() )
{
@@ -813,8 +685,8 @@ BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const
if( pTok->IsEmpty() )
bOk = FALSE;
- // nur ein import ganz am Anfang
- /*else */if( pTok->Is( SvHash_module() ) )
+ // only one import at the very beginning
+ if( pTok->Is( SvHash_module() ) )
{
SvMetaModuleRef aModule = new SvMetaModule( rInStm.GetFileName(), bImported );
if( aModule->ReadSvIdl( *this, rInStm ) )
@@ -827,18 +699,13 @@ BOOL SvIdlWorkingBase::ReadSvIdl( SvTokenStream & rInStm, BOOL bImported, const
}
if( !bOk || !pTok->IsEof() )
{
- //Fehlerbehandlung
+ // error treatment
WriteError( rInStm );
return FALSE;
}
return TRUE;
}
-/*************************************************************************
-|* SvIdlWorkingBase::WriteSvIdl()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
{
if( rOutStm.GetError() != SVSTREAM_OK )
@@ -862,23 +729,17 @@ BOOL SvIdlWorkingBase::WriteSvIdl( SvStream & rOutStm )
for( ULONG n = 0; n < GetModuleList().Count(); n++ )
{
SvMetaModule * pModule = GetModuleList().GetObject( n );
- //if( !pModule->IsImported() )
- pModule->WriteSvIdl( *this, rOutStm, 0 );
+ pModule->WriteSvIdl( *this, rOutStm, 0 );
}
return TRUE;
}
-/*************************************************************************
-|* SvIdlWorkingBase::WriteSfx()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvIdlWorkingBase::WriteSfx( SvStream & rOutStm )
{
if( rOutStm.GetError() != SVSTREAM_OK )
return FALSE;
- // alle Tmp-Variablen fuer das Schreiben zuruecksetzen
+ // reset all tmp variables for writing
WriteReset();
SvMemoryStream aTmpStm( 256000, 256000 );
ULONG n;
@@ -909,8 +770,7 @@ BOOL SvIdlWorkingBase::WriteHelpIds( SvStream& rOutStm )
for( n = 0; n < GetModuleList().Count(); n++ )
{
SvMetaModule * pModule = GetModuleList().GetObject( n );
- //if( !pModule->IsImported() )
- pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
+ pModule->WriteHelpIds( *this, rOutStm, &aIdTable );
}
const SvMetaAttributeMemberList & rAttrList = GetAttrList();
@@ -923,11 +783,6 @@ BOOL SvIdlWorkingBase::WriteHelpIds( SvStream& rOutStm )
return TRUE;
}
-/*************************************************************************
-|* SvIdlWorkingBase::WriteSfxItem()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvIdlWorkingBase::WriteSfxItem( SvStream & )
{
return FALSE;
@@ -963,11 +818,6 @@ BOOL SvIdlWorkingBase::WriteCSV( SvStream& rStrm )
return TRUE;
}
-/*************************************************************************
-|* SvIdlWorkingBase::WriteDocumentation()
-|*
-|* Beschreibung
-*************************************************************************/
BOOL SvIdlWorkingBase::WriteDocumentation( SvStream & rOutStm )
{
if( rOutStm.GetError() != SVSTREAM_OK )
diff --git a/idl/source/prj/globals.cxx b/idl/source/prj/globals.cxx
index b3a00e00e71e..de1f5256271a 100644
--- a/idl/source/prj/globals.cxx
+++ b/idl/source/prj/globals.cxx
@@ -29,13 +29,11 @@
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_idl.hxx"
-/****************** I N C L U D E S **************************************/
#include <tools/shl.hxx>
#include <globals.hxx>
#include <database.hxx>
-/****************** G L O B A L S ****************************************/
#ifdef DOS
static IdlDll * pApp = NULL;
IdlDll * GetIdlApp()
@@ -50,9 +48,6 @@ IdlDll * GetIdlApp()
if( !(*(IdlDll**)GetAppData(SHL_IDL)) )
{
(*(IdlDll**)GetAppData(SHL_IDL)) = new IdlDll();
- // Temporaer, sonst nur wenn Compiler
- //GetIdlApp()->pHashTable = new SvStringHashTable( 2801 );
- //GetIdlApp()->pGlobalNames = new SvGlobalHashNames();
}
return (*(IdlDll**)GetAppData(SHL_IDL));
}
@@ -93,11 +88,6 @@ IdlDll::~IdlDll()
delete pHashTable;
}
-/*************************************************************************
-|*
-|* SvGlobalHashNames::SvGlobalHashNames()
-|*
-*************************************************************************/
inline SvStringHashEntry * INS( const ByteString & rName )
{
UINT32 nIdx;
@@ -126,7 +116,6 @@ SvGlobalHashNames::SvGlobalHashNames()
, MM_SlotId( INS( "SlotId" ) )
, MM_HasCoreId( INS( "HasCoreId" ) )
, MM_Cachable( INS( "Cachable" ) )
-// , MM_Volatile( INS( "Volatile" ) )
, MM_Toggle( INS( "Toggle" ) )
, MM_AutoUpdate( INS( "AutoUpdate" ) )
, MM_Synchron( INS( "Synchron" ) )
diff --git a/idl/source/prj/idldll.cxx b/idl/source/prj/idldll.cxx
index 1898bf0c2fd7..ac891ef470c4 100644
--- a/idl/source/prj/idldll.cxx
+++ b/idl/source/prj/idldll.cxx
@@ -34,15 +34,15 @@
#include <sysdep.hxx>
-// Statische DLL-Verwaltungs-Variablen
-static HINSTANCE hDLLInst = 0; // HANDLE der DLL
+// static DLL handle
+static HINSTANCE hDLLInst = 0; // HANDLE of the DLL
/***************************************************************************
|*
|* LibMain()
|*
-|* Beschreibung Initialisierungsfunktion der DLL
+|* description initializing function of the DLL
|*
***************************************************************************/
@@ -62,7 +62,7 @@ extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
|*
|* WEP()
|*
-|* Beschreibung DLL-Deinitialisierung
+|* description DLL de-initializing
|*
***************************************************************************/
diff --git a/idl/source/prj/svidl.cxx b/idl/source/prj/svidl.cxx
index 14f8f585c9a9..be9e73bbf1df 100644
--- a/idl/source/prj/svidl.cxx
+++ b/idl/source/prj/svidl.cxx
@@ -74,13 +74,13 @@ BOOL FileMove_Impl( const String & rFile1, const String & rFile2, BOOL bImmerVer
}
DirEntry aF2( rFile2 );
if( nC1 != nC2 )
- {// es hat sich etwas geaendert
+ {// something has changed
DirEntry aF1( rFile1 );
aF1.Kill();
- // Datei verschieben
+ // move file
if( aF2.MoveTo( aF1 ) )
{
- // Beide Dateien loeschen
+ // delete both files
aF1.Kill();
aF2.Kill();
return FALSE;
@@ -90,11 +90,6 @@ BOOL FileMove_Impl( const String & rFile1, const String & rFile2, BOOL bImmerVer
return 0 == aF2.Kill();
}
-/*************************************************************************
-|* main()
-|*
-|* Beschreibung
-*************************************************************************/
#if defined( UNX ) || (defined( PM2 ) && defined( CSET )) || defined (WTC) || defined (MTW) || defined (__MINGW32__) || defined( OS2 )
int main ( int argc, char ** argv)
{
@@ -338,7 +333,7 @@ int cdecl main ( int argc, char ** argv)
DirEntry aT(aCommand.aTargetFile);
aT.Kill();
#endif
- // Datei stempeln, da idl korrekt durchlaufen wurde
+ // stamp file, because idl passed through correctly
SvFileStream aOutStm( aCommand.aTargetFile,
STREAM_READWRITE | STREAM_TRUNC );
}
generated by cgit (git 2.34.1) at 2025-01-08 21:48:23 +0000