diff options
Diffstat (limited to 'idl')
| -rw-r--r-- | idl/inc/basobj.hxx | 7 | ||||
| -rw-r--r-- | idl/inc/bastype.hxx | 15 | ||||
| -rw-r--r-- | idl/inc/char.hxx | 1 | ||||
| -rw-r--r-- | idl/inc/command.hxx | 3 | ||||
| -rw-r--r-- | idl/inc/database.hxx | 10 | ||||
| -rw-r--r-- | idl/inc/hash.hxx | 7 | ||||
| -rw-r--r-- | idl/inc/lex.hxx | 27 | ||||
| -rw-r--r-- | idl/inc/module.hxx | 3 | ||||
| -rw-r--r-- | idl/inc/object.hxx | 13 | ||||
| -rw-r--r-- | idl/inc/slot.hxx | 13 | ||||
| -rw-r--r-- | idl/inc/types.hxx | 21 | ||||
| -rw-r--r-- | idl/source/cmptools/char.cxx | 2 | ||||
| -rw-r--r-- | idl/source/cmptools/hash.cxx | 117 | ||||
| -rw-r--r-- | idl/source/cmptools/lex.cxx | 119 | ||||
| -rw-r--r-- | idl/source/objects/basobj.cxx | 225 | ||||
| -rw-r--r-- | idl/source/objects/bastype.cxx | 135 | ||||
| -rw-r--r-- | idl/source/objects/module.cxx | 131 | ||||
| -rw-r--r-- | idl/source/objects/object.cxx | 219 | ||||
| -rw-r--r-- | idl/source/objects/slot.cxx | 225 | ||||
| -rw-r--r-- | idl/source/objects/types.cxx | 532 | ||||
| -rw-r--r-- | idl/source/prj/command.cxx | 101 | ||||
| -rw-r--r-- | idl/source/prj/database.cxx | 218 | ||||
| -rw-r--r-- | idl/source/prj/globals.cxx | 21 | ||||
| -rw-r--r-- | idl/source/prj/idldll.cxx | 76 | ||||
| -rw-r--r-- | idl/source/prj/makefile.mk | 1 | ||||
| -rw-r--r-- | idl/source/prj/svidl.cxx | 15 |
26 files changed, 295 insertions, 1962 deletions
diff --git a/idl/inc/basobj.hxx b/idl/inc/basobj.hxx index f029b71b4cc8..2db45be5f523 100644 --- a/idl/inc/basobj.hxx +++ b/idl/inc/basobj.hxx @@ -59,7 +59,6 @@ enum }; typedef int WriteAttribute; -/******************** Meta Factory **************************************/ #define SV_DECL_META_FACTORY( Class, CLASS_ID ) \ SV_DECL_PERSIST( Class, CLASS_ID ) @@ -74,7 +73,6 @@ typedef int WriteAttribute; #define SV_IMPL_META_FACTORY1( Class, Super1 ) \ SV_IMPL_PERSIST1( Class, Super1 ) -/******************** class SvMetaObject ********************************/ class SvMetaObject : public SvPersistBase { public: @@ -128,7 +126,6 @@ public: } }; -/******************** class SvMetaName **********************************/ class SvMetaName : public SvMetaObject { SvString aName; @@ -180,7 +177,6 @@ SV_DECL_IMPL_REF(SvMetaName) SV_DECL_IMPL_PERSIST_LIST(SvMetaName,SvMetaName *) -/******************** class SvMetaReference *****************************/ SV_DECL_REF(SvMetaReference) class SvMetaReference : public SvMetaName { @@ -229,11 +225,10 @@ SV_IMPL_REF(SvMetaReference) SV_DECL_IMPL_PERSIST_LIST(SvMetaReference,SvMetaReference *) -/******************** class SvMetaExtern *********************************/ class SvMetaModule; class SvMetaExtern : public SvMetaReference { - SvMetaModule * pModule; // in welchem Modul enthalten + SvMetaModule * pModule; // included in which module SvUUId aUUId; SvVersion aVersion; diff --git a/idl/inc/bastype.hxx b/idl/inc/bastype.hxx index bc9c8867377e..79290a46c39b 100644 --- a/idl/inc/bastype.hxx +++ b/idl/inc/bastype.hxx @@ -40,7 +40,6 @@ class SvStringHashEntry; class SvIdlDataBase; class SvTokenStream; -/******************** class SvUINT32 **********************************/ class SvUINT32 { UINT32 nVal; @@ -61,7 +60,6 @@ public: }; -/******************** class SvINT16 **********************************/ class SvINT16 { short nVal; @@ -79,7 +77,6 @@ public: }; -/******************** class SvUINT16 **********************************/ class SvUINT16 { USHORT nVal; @@ -97,7 +94,6 @@ public: }; -/******************** class SvINT32 **********************************/ class SvINT32 { INT32 nVal; @@ -115,7 +111,6 @@ public: }; -/******************** class Svint **********************************/ class Svint { int nVal; @@ -136,7 +131,6 @@ public: }; -/******************** class SvBOOL **********************************/ class SvBOOL { BOOL nVal:1, @@ -165,7 +159,6 @@ public: }; -/******************** class SvIdentifier **********************************/ class SvIdentifier : public ByteString { public: @@ -184,11 +177,10 @@ public: }; -/******************** class SvIdentifier **********************************/ class SvNumberIdentifier : public SvIdentifier { UINT32 nValue; - // darf nicht benutzt werden + // must not be used BOOL ReadSvIdl( SvStringHashEntry * pName, SvTokenStream & rInStm ); public: SvNumberIdentifier() : nValue( 0 ) {}; @@ -209,7 +201,6 @@ public: }; -/******************** class SvString **********************************/ class SvString : public ByteString { public: @@ -228,7 +219,6 @@ public: }; -/******************** class SvHelpText **********************************/ class SvHelpText : public SvString { public: @@ -241,12 +231,10 @@ public: }; -/******************** class SvHelpContext *******************************/ class SvHelpContext : public SvNumberIdentifier { }; -/******************** class SvUUId *************************************/ class SvUUId : public SvGlobalName { public: @@ -258,7 +246,6 @@ public: }; -/******************** class SvVersion **********************************/ class SvVersion { USHORT nMajorVersion; diff --git a/idl/inc/char.hxx b/idl/inc/char.hxx index f27eb1028965..0c0528d08a98 100644 --- a/idl/inc/char.hxx +++ b/idl/inc/char.hxx @@ -31,7 +31,6 @@ #include <tools/string.hxx> -/******************* T y p e s *******************************************/ class SvChar { public: diff --git a/idl/inc/command.hxx b/idl/inc/command.hxx index 8332569453c7..2882ba07a226 100644 --- a/idl/inc/command.hxx +++ b/idl/inc/command.hxx @@ -29,8 +29,6 @@ #ifndef _COMMAND_HXX #define _COMMAND_HXX - -#include <tools/list.hxx> #include <tools/string.hxx> #include <vector> @@ -41,7 +39,6 @@ typedef ::std::vector< String* > StringList; typedef ::std::vector< ByteString* > ByteStringList; -/******************** class SvCommand ************************************/ class SvCommand { public: diff --git a/idl/inc/database.hxx b/idl/inc/database.hxx index 1127ed60b7e5..8d28bb0ce349 100644 --- a/idl/inc/database.hxx +++ b/idl/inc/database.hxx @@ -34,13 +34,10 @@ #include <lex.hxx> #include <tools/pstm.hxx> -/************************************************************************* -*************************************************************************/ - class SvCommand; #ifdef IDL_COMPILER -/******************** class SvIdlError ***********************************/ + class SvIdlError { ByteString aText; @@ -64,7 +61,6 @@ public: }; #endif -/******************** class SvIdlDataBase ********************************/ class SvIdlDataBase { BOOL bExport; @@ -82,7 +78,7 @@ class SvIdlDataBase SvMetaClassMemberList aClassList; SvMetaModuleMemberList aModuleList; SvMetaAttributeMemberList aAttrList; - SvMetaTypeMemberList aTmpTypeList; // nicht Persistent + SvMetaTypeMemberList aTmpTypeList; // not persistent protected: #ifdef IDL_COMPILER @@ -111,7 +107,7 @@ public: SvMetaModuleMemberList & GetModuleList() { return aModuleList; } SvMetaModule * GetModule( const ByteString & rName ); - // Liste der benutzten Typen beim Schreiben + // list of used types while writing SvMetaTypeMemberList aUsedTypes; ByteString aIFaceName; SvNumberIdentifier aStructSlotId; diff --git a/idl/inc/hash.hxx b/idl/inc/hash.hxx index 8f13536265ce..41ee6db65c65 100644 --- a/idl/inc/hash.hxx +++ b/idl/inc/hash.hxx @@ -33,13 +33,12 @@ #include <tools/string.hxx> #include <vector> -/****************** H a s h - T a b l e **********************************/ class SvHashTable { UINT32 nMax; // size of hash-tabel UINT32 nFill; // elements in hash-tabel - UINT32 lAsk; // Anzahl der Anfragen - UINT32 lTry; // Anzahl der Versuche + UINT32 lAsk; // number of requests + UINT32 lTry; // number of tries protected: BOOL Test_Insert( const void *, BOOL bInsert, UINT32 * pInsertPos ); @@ -56,7 +55,6 @@ public: virtual BOOL IsEntry( UINT32 ) const = 0; }; -/************** S t r i n g H a s h T a b l e E n t r y ******************/ class SvStringHashTable; class SvStringHashEntry : public SvRefBase { @@ -97,7 +95,6 @@ public: SV_DECL_IMPL_REF(SvStringHashEntry) -/****************** S t r i n g H a s h T a b l e ************************/ typedef ::std::vector< SvStringHashEntry* > SvStringHashList; class SvStringHashTable : public SvHashTable diff --git a/idl/inc/lex.hxx b/idl/inc/lex.hxx index a2553e063316..749d109bbf95 100644 --- a/idl/inc/lex.hxx +++ b/idl/inc/lex.hxx @@ -32,15 +32,14 @@ #include <hash.hxx> #include <tools/gen.hxx> #include <tools/stream.hxx> +#include <tools/list.hxx> -/******************** enum ***********************************************/ enum SVTOKEN_ENUM { SVTOKEN_EMPTY, SVTOKEN_COMMENT, SVTOKEN_INTEGER, SVTOKEN_STRING, SVTOKEN_BOOL, SVTOKEN_IDENTIFIER, SVTOKEN_CHAR, SVTOKEN_RTTIBASE, SVTOKEN_EOF, SVTOKEN_HASHID }; -/******************** class SvToken **************************************/ class BigInt; class SvToken { @@ -53,7 +52,6 @@ friend class SvTokenStream; ULONG nLong; BOOL bBool; char cChar; -// SvRttiBase * pComplexObj; SvStringHashEntry * pHash; }; public: @@ -63,7 +61,6 @@ public: SvToken( SVTOKEN_ENUM nTypeP, BOOL b ); SvToken( char c ); SvToken( SVTOKEN_ENUM nTypeP, const ByteString & rStr ); -// SvToken( SvRttiBase * pComplexObj ); SvToken( SVTOKEN_ENUM nTypeP ); SvToken & operator = ( const SvToken & rObj ); @@ -102,7 +99,6 @@ public: ULONG GetNumber() const { return nLong; } BOOL GetBool() const { return bBool; } char GetChar() const { return cChar; } -// SvRttiBase *GetObject() const { return pComplexObj; } void SetHash( SvStringHashEntry * pHashP ) { pHash = pHashP; nType = SVTOKEN_HASHID; } @@ -128,26 +124,19 @@ inline SvToken::SvToken( char c ) inline SvToken::SvToken( SVTOKEN_ENUM nTypeP, const ByteString & rStr ) : nType( nTypeP ), aString( rStr ) {} -/* -inline SvToken::SvToken( SvRttiBase * pObj ) - : nType( SVTOKEN_RTTIBASE ), pComplexObj( pObj ) - { pObj->AddRef(); } -*/ - inline SvToken::SvToken( SVTOKEN_ENUM nTypeP ) : nType( nTypeP ) {} DECLARE_LIST( SvTokenList, SvToken * ) -/******************** class SvTokenStream ********************************/ class SvTokenStream { ULONG nLine, nColumn; int nBufPos; - int c; // naechstes Zeichen + int c; // next character CharSet nCharSet; - char * pCharTab; // Zeiger auf die Konverierungstabelle - USHORT nTabSize; // Tabulator Laenge + char * pCharTab; // pointer to conversion table + USHORT nTabSize; // length of tabulator ByteString aStrTrue; ByteString aStrFalse; ULONG nMaxPos; @@ -179,7 +168,7 @@ class SvTokenStream } void CalcColumn() { - // wenn Zeilenende berechnung sparen + // if end of line spare calculation if( 0 != c ) { USHORT n = 0; @@ -207,7 +196,7 @@ public: { SvToken * pRetToken = pCurToken; if( NULL == (pCurToken = aTokList.Prev()) ) - // Current Zeiger nie Null + // current pointer never null pCurToken = pRetToken; return pRetToken; @@ -216,14 +205,14 @@ public: { SvToken * pRetToken = pCurToken; if( NULL == (pCurToken = aTokList.Next()) ) - // Current Zeiger nie Null + // current pointer never null pCurToken = pRetToken; SetMax(); return pRetToken; } SvToken * GetToken_Next() { - // Kommentare werden initial entfernt + // comments get removed initially return GetToken_NextAll(); } SvToken * GetToken() const { return pCurToken; } diff --git a/idl/inc/module.hxx b/idl/inc/module.hxx index 1bea395d41be..5d206e0f4794 100644 --- a/idl/inc/module.hxx +++ b/idl/inc/module.hxx @@ -41,13 +41,12 @@ struct SvNamePos , nStmPos( nPos ) {} }; -/******************** class SvMetaModule *********************************/ class SvMetaModule : public SvMetaExtern { SvMetaClassMemberList aClassList; SvMetaTypeMemberList aTypeList; SvMetaAttributeMemberList aAttrList; -// Browser +// browser String aIdlFileName; SvString aHelpFileName; SvString aSlotIdFile; diff --git a/idl/inc/object.hxx b/idl/inc/object.hxx index ee8d88a2c418..417885184dfb 100644 --- a/idl/inc/object.hxx +++ b/idl/inc/object.hxx @@ -33,6 +33,7 @@ #include <types.hxx> #include <slot.hxx> #include <vector> +#include <tools/list.hxx> struct SvSlotElement { @@ -48,15 +49,6 @@ DECLARE_LIST( SvSlotElementList, SvSlotElement* ) class SvMetaClass; typedef ::std::vector< SvMetaClass* > SvMetaClassList; -class SvULongs : public List -{ -public: - void Insert( ULONG& rId, ULONG nPos ) { ULONG nId(rId ); List::Insert( (void*) nId, nPos ); } - void Remove( ULONG& rId ){ ULONG nId(rId ); List::Remove( (void*) nId ); } - ULONG GetObject( ULONG nPos ){ return (ULONG) List::GetObject( nPos ); } -}; - -/******************** class SvClassElement *******************************/ SV_DECL_REF(SvMetaClass) class SvClassElement : public SvPersistBase { @@ -86,7 +78,6 @@ public: SV_DECL_IMPL_REF(SvClassElement) SV_DECL_IMPL_PERSIST_LIST(SvClassElement,SvClassElement *) -/******************** class SvMetaClass *********************************/ class SvMetaModule; SV_DECL_PERSIST_LIST(SvMetaClass,SvMetaClass *) class SvMetaClass : public SvMetaType @@ -112,7 +103,7 @@ class SvMetaClass : public SvMetaType SvIdlDataBase & rBase, SvStream & rOutStm ); - void InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList, + void InsertSlots( SvSlotElementList& rList, std::vector<ULONG>& rSuperList, SvMetaClassList & rClassList, const ByteString & rPrefix, SvIdlDataBase& rBase ); diff --git a/idl/inc/slot.hxx b/idl/inc/slot.hxx index d185b8acfbea..bc8832a60f0b 100644 --- a/idl/inc/slot.hxx +++ b/idl/inc/slot.hxx @@ -32,8 +32,6 @@ #include <types.hxx> #include <command.hxx> -/******************** class SvMetaSlot **********************************/ -//class SbxObject; class SvMetaSlotMemberList; class SvMetaSlot : public SvMetaAttribute { @@ -49,15 +47,15 @@ class SvMetaSlot : public SvMetaAttribute SvBOOL aGet; SvBOOL aSet; - SvBOOL aCachable; // exclusiv + SvBOOL aCachable; // exclusive SvBOOL aVolatile; SvBOOL aToggle; SvBOOL aAutoUpdate; - SvBOOL aSynchron; // exclusiv + SvBOOL aSynchron; // exclusive SvBOOL aAsynchron; - SvBOOL aRecordPerItem;// exclusiv + SvBOOL aRecordPerItem;// exclusive SvBOOL aRecordPerSet; SvBOOL aRecordManual; SvBOOL aNoRecord; @@ -202,10 +200,6 @@ public: const ByteString & GetDefault() const; const ByteString & GetDisableFlags() const; BOOL GetPseudoSlots() const; - /* - BOOL GetGet() const; - BOOL GetSet() const; - */ BOOL GetCachable() const; BOOL GetVolatile() const; BOOL GetToggle() const; @@ -242,7 +236,6 @@ public: void ResetSlotPointer() { pNextSlot = pLinkedSlot = 0; } -// void FillSbxObject( SvIdlDataBase & rBase, SbxObject *, BOOL bProp ); #ifdef IDL_COMPILER SvMetaEnumValue* GetEnumValue() const { return pEnumValue; } diff --git a/idl/inc/types.hxx b/idl/inc/types.hxx index d4539ae47c70..46882af1f85e 100644 --- a/idl/inc/types.hxx +++ b/idl/inc/types.hxx @@ -35,7 +35,6 @@ class SvSlotElementList; struct SvSlotElement; -/******************** class SvMetaAttribute *****************************/ SV_DECL_REF(SvMetaType) SV_DECL_REF(SvMetaAttribute) SV_DECL_PERSIST_LIST(SvMetaAttribute,SvMetaAttribute *) @@ -105,8 +104,6 @@ public: virtual BOOL IsVariable() const; virtual ByteString GetMangleName( BOOL bVariable ) const; -// void FillSbxObject( SbxInfo * pInfo, USHORT nSbxFlags = 0 ); -// virtual void FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj, BOOL bVariable ); #ifdef IDL_COMPILER virtual BOOL Test( SvIdlDataBase &, SvTokenStream & rInStm ); @@ -135,14 +132,13 @@ SV_IMPL_REF(SvMetaAttribute) SV_IMPL_PERSIST_LIST(SvMetaAttribute,SvMetaAttribute *) -/******************** class SvType *********************************/ enum { CALL_VALUE, CALL_POINTER, CALL_REFERENCE }; enum { TYPE_METHOD, TYPE_STRUCT, TYPE_BASE, TYPE_ENUM, TYPE_UNION, TYPE_CLASS, TYPE_POINTER }; class SvMetaType : public SvMetaExtern { - SvBOOL aIn; // Eingangsparameter - SvBOOL aOut; // Returnparameter + SvBOOL aIn; // input parameter + SvBOOL aOut; // return parameter Svint aCall0, aCall1; Svint aSbxDataType; SvIdentifier aSvName; @@ -186,7 +182,7 @@ public: SvMetaType( const ByteString & rTypeName, const ByteString & rSbxName, const ByteString & rOdlName, char cParserChar, const ByteString & rCName, const ByteString & rBasicName, - const ByteString & rBasicPostfix/*, SbxDataType nT = SbxEMPTY */); + const ByteString & rBasicPostfix ); SvMetaAttributeMemberList & GetAttrList() const; ULONG GetAttrCount() const @@ -205,10 +201,6 @@ public: BOOL IsItem() const { return bIsItem; } BOOL IsShell() const { return bIsShell; } -// void SetSbxDataType( SbxDataType nT ) -// { aSbxDataType = (int)nT; } -// SbxDataType GetSbxDataType() const; - void SetIn( BOOL b ) { aIn = b; } BOOL GetIn() const; @@ -234,7 +226,6 @@ public: virtual BOOL SetName( const ByteString & rName, SvIdlDataBase * = NULL ); -// void FillSbxObject( SbxVariable * pObj, BOOL bVariable ); #ifdef IDL_COMPILER virtual BOOL ReadSvIdl( SvIdlDataBase &, SvTokenStream & rInStm ); @@ -249,7 +240,6 @@ public: ULONG MakeSfx( ByteString * pAtrrArray ); virtual void WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm ); - //BOOL ReadTypePrefix( SvIdlDataBase &, SvTokenStream & rInStm ); BOOL ReadMethodArgs( SvIdlDataBase & rBase, SvTokenStream & rInStm ); void WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab, WriteType ); @@ -261,11 +251,9 @@ public: #endif }; SV_IMPL_REF(SvMetaType) -DECLARE_LIST(SvMetaTypeList,SvMetaType *) SV_DECL_IMPL_PERSIST_LIST(SvMetaType,SvMetaType *) -/******************** class SvTypeString *********************************/ class SvMetaTypeString : public SvMetaType { public: @@ -276,7 +264,6 @@ SV_DECL_IMPL_REF(SvMetaTypeString) SV_DECL_IMPL_PERSIST_LIST(SvMetaTypeString,SvMetaTypeString *) -/******************** class SvMetaEnumValue **********************************/ class SvMetaEnumValue : public SvMetaName { ByteString aEnumValue; @@ -295,7 +282,6 @@ SV_DECL_IMPL_REF(SvMetaEnumValue) SV_DECL_IMPL_PERSIST_LIST(SvMetaEnumValue,SvMetaEnumValue *) -/******************** class SvTypeEnum *********************************/ class SvMetaTypeEnum : public SvMetaType { SvMetaEnumValueMemberList aEnumValueList; @@ -331,7 +317,6 @@ SV_DECL_IMPL_REF(SvMetaTypeEnum) SV_DECL_IMPL_PERSIST_LIST(SvMetaTypeEnum,SvMetaTypeEnum *) -/******************** class SvTypeVoid ***********************************/ class SvMetaTypevoid : public SvMetaType { public: diff --git a/idl/source/cmptools/char.cxx b/idl/source/cmptools/char.cxx index 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..bded3d1f7a38 100644 --- a/idl/source/cmptools/hash.cxx +++ b/idl/source/cmptools/hash.cxx @@ -29,33 +29,17 @@ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_idl.hxx" -/****************** I N C L U D E S **************************************/ -// C and C++ Includes. +// C and C++ includes #include <stdlib.h> #include <stdio.h> #include <ctype.h> -// Programmabh„ngige Includes. +// program-sensitive includes #include <hash.hxx> #include <tools/debug.hxx> -/****************** C O D E **********************************************/ -/************************************************************************* -|* -|* SvStringHashEntry::~SvStringHashEntry() -|* -|* Beschreibung -|* -*************************************************************************/ SvStringHashEntry::~SvStringHashEntry() { }; -/************************************************************************* -|* -|* SvHashTable::SvHashTable() -|* -|* Beschreibung -|* -*************************************************************************/ SvHashTable::SvHashTable( UINT32 nMaxEntries ) { nMax = nMaxEntries; // set max entries @@ -64,30 +48,10 @@ SvHashTable::SvHashTable( UINT32 nMaxEntries ) lAsk = 0; } -/************************************************************************* -|* -|* SvHashTable::~SvHashTable() -|* -|* Beschreibung -|* -*************************************************************************/ SvHashTable::~SvHashTable() { -#ifdef DOS_NIE - printf( "Maximum: %ld, Fllung: %ld\n", (ULONG)nMax, (ULONG)nFill ); - printf( "Anfragen: %ld, Versuche: %ld", (ULONG)lAsk, (ULONG)lTry ); - if( lTry != 0 ) - printf( ", V/E = %ld\n", lTry / lAsk ); -#endif } -/************************************************************************* -|* -|* SvHashTable::Test_Insert() -|* -|* Beschreibung -|* -*************************************************************************/ BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert, UINT32 * pInsertPos ) { @@ -128,14 +92,6 @@ BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert, return( FALSE ); } -/************************************************************************/ -/************************************************************************* -|* -|* SvStringHashTable::SvStringHashTable() -|* -|* Beschreibung -|* -*************************************************************************/ SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries ) : SvHashTable( nMaxEntries ) { @@ -145,7 +101,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 +112,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 +129,6 @@ SvStringHashTable::~SvStringHashTable() delete [] pEntries; } -/************************************************************************* -|* -|* SvStringHashTable::HashFunc() -|* -|* Beschreibung -|* -*************************************************************************/ UINT32 SvStringHashTable::HashFunc( const void * pElement ) const { UINT32 nHash = 0; // hash value @@ -208,13 +150,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 +164,6 @@ ByteString SvStringHashTable::GetNearString( const ByteString & rName ) const return ByteString(); } -/************************************************************************* -|* -|* SvStringHashTable::IsEntry() -|* -|* Beschreibung -|* -*************************************************************************/ BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const { if( nIndex >= GetMax() ) @@ -243,13 +171,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 +185,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 +198,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 +211,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..fd8265513694 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,75 +75,31 @@ 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 - SetCharSet( CHARSET_ANSI ); -#else SetCharSet( gsl_getSystemTextEncoding() ); -#endif aStrTrue = "TRUE"; aStrFalse = "FALSE"; nLine = nColumn = 0; @@ -163,11 +111,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 +120,6 @@ SvTokenStream::SvTokenStream( const String & rFileName ) InitCtor(); } -/************************************************************************* -|* SvTokenStream::SvTokenStream() -|* -|* Beschreibung -*************************************************************************/ SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName ) : pInStream( NULL ) , rInStream( rStream ) @@ -191,11 +129,6 @@ SvTokenStream::SvTokenStream( SvStream & rStream, const String & rFileName ) InitCtor(); } -/************************************************************************* -|* SvTokenStream::~SvTokenStream() -|* -|* Beschreibung -*************************************************************************/ SvTokenStream::~SvTokenStream() { delete pInStream; @@ -207,11 +140,6 @@ SvTokenStream::~SvTokenStream() } } -/************************************************************************* -|* SvTokenStream::FillTokenList() -|* -|* Beschreibung -*************************************************************************/ void SvTokenStream::FillTokenList() { SvToken * pToken = new SvToken(); @@ -243,27 +171,12 @@ void SvTokenStream::FillTokenList() pCurToken = aTokList.First(); } -/************************************************************************* -|* SvTokenStrem::SetCharSet() -|* -|* Beschreibung -*************************************************************************/ void SvTokenStream::SetCharSet( CharSet nSet ) { nCharSet = nSet; - -#ifdef DOS - pCharTab = SvChar::GetTable( nSet, CHARSET_ANSI ); -#else pCharTab = SvChar::GetTable( nSet, gsl_getSystemTextEncoding() ); -#endif } -/************************************************************************* -|* SvTokeStream::GetNextChar() -|* -|* Beschreibung -*************************************************************************/ int SvTokenStream::GetNextChar() { int nChar; @@ -288,11 +201,6 @@ int SvTokenStream::GetNextChar() return nChar; } -/************************************************************************* -|* SvTokenStrem::GetNumber() -|* -|* Beschreibung -*************************************************************************/ ULONG SvTokenStream::GetNumber() { ULONG l = 0; @@ -331,18 +239,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 +256,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 +286,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 +311,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..6c87ed895ea2 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() { } @@ -204,7 +146,7 @@ void SvMetaName::Load( SvPersistStream & rStm ) if( nMask >= 0x20 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "wrong format" ); + OSL_FAIL( "wrong format" ); return; } if( nMask & 0x01 ) rStm >> aName; @@ -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() { } @@ -562,7 +429,7 @@ void SvMetaReference::Load( SvPersistStream & rStm ) if( nMask >= 0x2 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "wrong format" ); + OSL_FAIL( "wrong format" ); return; } if( nMask & 0x01 ) @@ -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 ) @@ -612,7 +472,7 @@ void SvMetaExtern::Load( SvPersistStream & rStm ) if( nMask >= 0x20 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "wrong format" ); + OSL_FAIL( "wrong format" ); return; } if( nMask & 0x01 ) rStm >> pModule; @@ -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..97dac4b46534 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; @@ -111,24 +98,18 @@ SvStream& operator >> (SvStream & rStm, SvBOOL & rb ) if( n & ~0x03 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "format error" ); + OSL_FAIL( "format error" ); } 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 7545fa0118ea..77c3b7146cd3 100644 --- a/idl/source/objects/module.cxx +++ b/idl/source/objects/module.cxx @@ -38,14 +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 ) @@ -62,32 +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 @@ -101,27 +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; @@ -129,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 ) ); @@ -137,11 +121,6 @@ void SvMetaModule::Save( SvPersistStream & rStm ) #endif } -/************************************************************************* -|* -|* SvMetaModule::SetName() -|* -*************************************************************************/ BOOL SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * pBase ) { if( pBase ) @@ -153,11 +132,6 @@ BOOL SvMetaModule::SetName( const ByteString & rName, SvIdlDataBase * pBase ) } #ifdef IDL_COMPILER -/************************************************************************* -|* SvMetaModule::GetNextName() -|* -|* Beschreibung -*************************************************************************/ BOOL SvMetaModule::FillNextName( SvGlobalName * pName ) { *pName = aNextName; @@ -171,11 +145,6 @@ BOOL SvMetaModule::FillNextName( SvGlobalName * pName ) return FALSE; } -/************************************************************************* -|* SvMetaModule::ReadSvIdl() -|* -|* Beschreibung -*************************************************************************/ void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) { @@ -199,11 +168,6 @@ void SvMetaModule::ReadAttributesSvIdl( SvIdlDataBase & rBase, aModulePrefix.ReadSvIdl( SvHash_ModulePrefix(), rInStm ); } -/************************************************************************* -|* SvMetaModule::WriteAttributesSvIdl() -|* -|* Beschreibung -*************************************************************************/ void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab ) @@ -232,11 +196,6 @@ void SvMetaModule::WriteAttributesSvIdl( SvIdlDataBase & rBase, } } -/************************************************************************* -|* SvMetaModule::ReadContextSvIdl() -|* -|* Beschreibung -*************************************************************************/ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) { @@ -248,7 +207,7 @@ void SvMetaModule::ReadContextSvIdl( SvIdlDataBase & rBase, if( aClass->ReadSvIdl( rBase, rInStm ) ) { aClassList.Append( aClass ); - // Global bekanntgeben + // announce globally rBase.GetClassList().Append( aClass ); } } @@ -258,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 ); } } @@ -272,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 ); } } @@ -292,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(); @@ -309,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 @@ -337,20 +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() -|* -|* Beschreibung -*************************************************************************/ void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab ) @@ -376,16 +330,9 @@ void SvMetaModule::WriteContextSvIdl( SvIdlDataBase & rBase, } } -/************************************************************************* -|* -|* SvMetaModule::ReadSvIdl() -|* -|* Beschreibung -|* -*************************************************************************/ 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(); @@ -409,28 +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() -|* -|* Beschreibung -|* -*************************************************************************/ void SvMetaModule::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab ) { @@ -443,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++ ) @@ -465,9 +402,6 @@ void SvMetaModule::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm, } } -/************************************************************************* -|* SvMetaModule::WriteAttributes() -*************************************************************************/ void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab, @@ -483,9 +417,6 @@ void SvMetaModule::WriteAttributes( SvIdlDataBase & rBase, } } -/************************************************************************* -|* SvMetaModule::Write() -*************************************************************************/ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab, WriteType nT, WriteAttribute nA ) @@ -542,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() ) { @@ -564,7 +495,7 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm, } } rOutStm << "</CLASSES>" << endl << endl; - // kein Break! + // no break! } case WRITE_C_SOURCE: @@ -573,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 ); } } @@ -584,13 +515,9 @@ void SvMetaModule::Write( SvIdlDataBase & rBase, SvStream & rOutStm, } } -/************************************************************************* -|* SvMetaModule::WriteSrc() -*************************************************************************/ void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, Table * pTable ) { -// rOutStm << "#pragma CHARSET IBMPC" << endl; if( aSlotIdFile.Len() ) rOutStm << "//#include <" << aSlotIdFile.GetBuffer() << '>' << endl; for( ULONG n = 0; n < aClassList.Count(); n++ ) @@ -599,9 +526,6 @@ void SvMetaModule::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, } } -/************************************************************************* -|* SvMetaModule::WriteHxx() -*************************************************************************/ void SvMetaModule::WriteHxx( SvIdlDataBase & rBase, SvStream & rOutStm, USHORT nTab ) { @@ -612,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..3b7f4583081a 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; @@ -62,7 +51,7 @@ void SvClassElement::Load( SvPersistStream & rStm ) if( nMask >= 0x08 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "wrong format" ); + OSL_FAIL( "wrong format" ); return; } if( nMask & 0x01 ) rStm >> aAutomation; @@ -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 ); @@ -121,7 +94,7 @@ void SvMetaClass::Load( SvPersistStream & rStm ) if( nMask >= 0x20 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "wrong format" ); + OSL_FAIL( "wrong format" ); return; } if( nMask & 0x01 ) rStm >> aAttrList; @@ -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,17 +319,12 @@ BOOL SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) return FALSE; } -/************************************************************************* -|* SvMetaClass::TestAttribute() -|* -|* Beschreibung -*************************************************************************/ BOOL SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm, SvMetaAttribute & rAttr ) const { if ( !rAttr.GetRef() && rAttr.IsA( TYPE( SvMetaSlot ) ) ) { - DBG_ERROR( "Neuer Slot : " ); + OSL_FAIL( "Neuer Slot : " ); DBG_ERROR( rAttr.GetSlotId().GetBuffer() ); } @@ -396,10 +333,10 @@ 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 : " ); + OSL_FAIL( "Gleicher Name in MetaClass : " ); DBG_ERROR( pS->GetName().GetBuffer() ); DBG_ERROR( pS->GetSlotId().GetBuffer() ); DBG_ERROR( rAttr.GetSlotId().GetBuffer() ); @@ -416,9 +353,9 @@ 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 : " ); + OSL_FAIL( "Gleiche Id in MetaClass : " ); DBG_ERROR( ByteString::CreateFromInt32( pS->GetSlotId().GetValue() ).GetBuffer() ); DBG_ERROR( pS->GetSlotId().GetBuffer() ); DBG_ERROR( rAttr.GetSlotId().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 ) @@ -470,13 +397,13 @@ void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm, { case WRITE_ODL: { - DBG_ERROR( "Not supported anymore!" ); + OSL_FAIL( "Not supported anymore!" ); break; } case WRITE_C_SOURCE: case WRITE_C_HEADER: { - DBG_ERROR( "Not supported anymore!" ); + OSL_FAIL( "Not supported anymore!" ); break; } case WRITE_DOCU: @@ -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,54 +472,46 @@ USHORT SvMetaClass::WriteSlots( const ByteString & rShellName, return nSCount; } -/************************************************************************* -|* SvMetaClass::InsertSlots() -|* -|* Beschreibung -*************************************************************************/ -void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList, +void SvMetaClass::InsertSlots( SvSlotElementList& rList, std::vector<ULONG>& 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++ ) { SvMetaAttribute * pAttr = aAttrList.GetObject( n ); ULONG nId = pAttr->GetSlotId().GetValue(); - USHORT nPos; - for ( nPos=0; nPos < rSuperList.Count(); nPos++ ) - { - if ( rSuperList.GetObject(nPos) == nId ) - break; - } - if( nPos == rSuperList.Count() ) + std::vector<ULONG>::iterator iter = std::find(rSuperList.begin(), + rSuperList.end(),nId); + + if( iter == rSuperList.end() ) { - // nur schreiben, wenn nicht schon bei SubClass oder - // importiertem Interface geschrieben - rSuperList.Insert( nId, nPos ); + // Write only if not already written by subclass or + // imported interface. + rSuperList.push_back(nId); 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 +521,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 +549,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,31 +569,26 @@ 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; - SvULongs aSuperList; + std::vector<ULONG> aSuperList; SvMetaClassList classList; SvSlotElementList aSlotList; InsertSlots(aSlotList, aSuperList, classList, ByteString(), rBase); @@ -707,13 +601,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 +621,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 +663,6 @@ void SvMetaClass::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm, } } -/************************************************************************* -|* SvMetaShell::WriteSrc() -*************************************************************************/ void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, Table * pTable ) { @@ -782,11 +673,6 @@ void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, } } -/************************************************************************* -|* SvMetaClass::WriteHxx() -|* -|* Beschreibung -*************************************************************************/ void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, USHORT ) { ByteString aSuperName( "SvDispatch" ); @@ -812,11 +698,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..fa1d3c6a659c 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,16 +859,16 @@ 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!"); + OSL_FAIL("Illegal definition!"); rInStm.Seek( nTokPos ); return FALSE; } @@ -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() ); @@ -1133,7 +1022,7 @@ void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix, if ( m == rBase.GetAttrList().Count() ) { - DBG_ERROR("Invalid EnumSlot!"); + OSL_FAIL("Invalid EnumSlot!"); xEnumSlot = Clone(); ULONG nValue; if ( rBase.FindId(aSId , &nValue) ) @@ -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..2d6f8d746447 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; } } } @@ -461,7 +376,7 @@ void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase, pBaseType->GetType() == TYPE_STRUCT || pBaseType->GetType() == TYPE_ENUM ) { - DBG_ERROR( "Falscher Parametertyp!" ); + OSL_FAIL( "Falscher Parametertyp!" ); } else rOutStm << pBaseType->GetBasicPostfix().GetBuffer(); @@ -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() { } @@ -2152,7 +1784,7 @@ void SvMetaEnumValue::Load( SvPersistStream & rStm ) if( nMask >= 0x02 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "wrong format" ); + OSL_FAIL( "wrong format" ); return; } if( nMask & 0x01 ) rStm.ReadByteString( aEnumValue ); @@ -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" ); @@ -2240,7 +1842,7 @@ void SvMetaTypeEnum::Load( SvPersistStream & rStm ) if( nMask >= 0x04 ) { rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); - DBG_ERROR( "wrong format" ); + OSL_FAIL( "wrong format" ); return; } if( nMask & 0x01 ) rStm >> aEnumValueList; @@ -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 - // bin„ren 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..f5162c6e03c7 100644 --- a/idl/source/prj/globals.cxx +++ b/idl/source/prj/globals.cxx @@ -29,34 +29,19 @@ // 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() -{ - if( !pApp ) - pApp = new IdlDll(); - return pApp; -} -#else 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)); } -#endif IdlDll::IdlDll() : pHashTable( NULL ) @@ -93,11 +78,6 @@ IdlDll::~IdlDll() delete pHashTable; } -/************************************************************************* -|* -|* SvGlobalHashNames::SvGlobalHashNames() -|* -*************************************************************************/ inline SvStringHashEntry * INS( const ByteString & rName ) { UINT32 nIdx; @@ -126,7 +106,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 deleted file mode 100644 index 1898bf0c2fd7..000000000000 --- a/idl/source/prj/idldll.cxx +++ /dev/null @@ -1,76 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/************************************************************************* - * - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * Copyright 2000, 2010 Oracle and/or its affiliates. - * - * OpenOffice.org - a multi-platform office productivity suite - * - * This file is part of OpenOffice.org. - * - * OpenOffice.org is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 3 - * only, as published by the Free Software Foundation. - * - * OpenOffice.org is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License version 3 for more details - * (a copy is included in the LICENSE file that accompanied this code). - * - * You should have received a copy of the GNU Lesser General Public License - * version 3 along with OpenOffice.org. If not, see - * <http://www.openoffice.org/license.html> - * for a copy of the LGPLv3 License. - * - ************************************************************************/ - -// MARKER(update_precomp.py): autogen include statement, do not remove -#include "precompiled_idl.hxx" - -#ifdef WIN -#include <svwin.h> - -#include <sysdep.hxx> - -// Statische DLL-Verwaltungs-Variablen -static HINSTANCE hDLLInst = 0; // HANDLE der DLL - - -/*************************************************************************** -|* -|* LibMain() -|* -|* Beschreibung Initialisierungsfunktion der DLL -|* -***************************************************************************/ - -extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR ) -{ -#ifndef WNT - if ( nHeap ) - UnlockData( 0 ); -#endif - - hDLLInst = hDLL; - - return TRUE; -} - -/*************************************************************************** -|* -|* WEP() -|* -|* Beschreibung DLL-Deinitialisierung -|* -***************************************************************************/ - -extern "C" int CALLBACK WEP( int ) -{ - return 1; -} - -#endif - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/idl/source/prj/makefile.mk b/idl/source/prj/makefile.mk index 3e0a55a7fd05..c33d2e9f3d7a 100644 --- a/idl/source/prj/makefile.mk +++ b/idl/source/prj/makefile.mk @@ -41,7 +41,6 @@ CDEFS+=-DIDL_COMPILER OBJFILES= $(OBJ)$/command.obj \ $(OBJ)$/svidl.obj \ $(OBJ)$/globals.obj \ - $(OBJ)$/idldll.obj \ $(OBJ)$/database.obj # --- Targets ------------------------------------------------------------ diff --git a/idl/source/prj/svidl.cxx b/idl/source/prj/svidl.cxx index 14f8f585c9a9..526240dd83a3 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,12 +90,7 @@ 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 ) +#if defined( UNX ) || defined( PM2 ) || defined (__MINGW32__) || defined( OS2 ) int main ( int argc, char ** argv) { #else @@ -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 ); } |